├── .editorconfig
├── .gitattributes
├── EditorConfig.py
├── editorconfig
    ├── __init__.py
    ├── compat.py
    ├── exceptions.py
    ├── fnmatch.py
    ├── handler.py
    ├── ini.py
    ├── main.py
    ├── odict.py
    └── versiontools.py
└── readme.md


/.editorconfig:
--------------------------------------------------------------------------------
 1 | # editorconfig.org
 2 | root = true
 3 | 
 4 | [*]
 5 | indent_style = tab
 6 | end_of_line = lf
 7 | charset = utf-8
 8 | trim_trailing_whitespace = true
 9 | insert_final_newline = true
10 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | * text=auto
2 | 


--------------------------------------------------------------------------------
/EditorConfig.py:
--------------------------------------------------------------------------------
 1 | import sublime_plugin
 2 | from editorconfig import get_properties, EditorConfigError
 3 | 
 4 | 
 5 | LINE_ENDINGS = {
 6 | 	'lf': 'unix',
 7 | 	'crlf': 'windows',
 8 | 	'cr': 'cr'
 9 | }
10 | 
11 | CHARSETS = {
12 | 	'latin1': 'Western (ISO 8859-1)',
13 | 	'utf-8': 'utf-8',
14 | 	'utf-8-bom': 'utf-8 with bom',
15 | 	'utf-16be': 'utf-16 be',
16 | 	'utf-16le': 'utf-16 le'
17 | }
18 | 
19 | class EditorConfig(sublime_plugin.EventListener):
20 | 	def on_load(self, view):
21 | 		self.init(view, False)
22 | 
23 | 	def on_pre_save(self, view):
24 | 		self.init(view, True)
25 | 
26 | 	def init(self, view, pre_save):
27 | 		path = view.file_name()
28 | 		if not path:
29 | 			return
30 | 		try:
31 | 			config = get_properties(path)
32 | 		except EditorConfigError:
33 | 			print 'Error occurred while getting EditorConfig properties'
34 | 		else:
35 | 			if config:
36 | 				if pre_save:
37 | 					self.apply_charset(view, config)
38 | 				else:
39 | 					self.apply_config(view, config)
40 | 
41 | 	def apply_charset(self, view, config):
42 | 		charset = config.get('charset')
43 | 		if charset in CHARSETS:
44 | 			view.set_encoding(CHARSETS[charset])
45 | 
46 | 	def apply_config(self, view, config):
47 | 		settings = view.settings()
48 | 		indent_style = config.get('indent_style')
49 | 		indent_size = config.get('indent_size')
50 | 		end_of_line = config.get('end_of_line')
51 | 		trim_trailing_whitespace = config.get('trim_trailing_whitespace')
52 | 		insert_final_newline = config.get('insert_final_newline')
53 | 		if indent_style == 'space':
54 | 			settings.set('translate_tabs_to_spaces', True)
55 | 		elif indent_style == 'tab':
56 | 			settings.set('translate_tabs_to_spaces', False)
57 | 		if indent_size:
58 | 			try:
59 | 				settings.set('tab_size', int(indent_size))
60 | 			except ValueError:
61 | 				pass
62 | 		if end_of_line in LINE_ENDINGS:
63 | 			view.set_line_endings(LINE_ENDINGS[end_of_line])
64 | 		if trim_trailing_whitespace == 'true':
65 | 			settings.set('trim_trailing_white_space_on_save', True)
66 | 		elif trim_trailing_whitespace == 'false':
67 | 			settings.set('trim_trailing_white_space_on_save', False)
68 | 		if insert_final_newline == 'true':
69 | 			settings.set('ensure_newline_at_eof_on_save', True)
70 | 		elif insert_final_newline == 'false':
71 | 			settings.set('ensure_newline_at_eof_on_save', False)
72 | 


--------------------------------------------------------------------------------
/editorconfig/__init__.py:
--------------------------------------------------------------------------------
 1 | """EditorConfig Python Core"""
 2 | 
 3 | from editorconfig.versiontools import join_version
 4 | 
 5 | VERSION = (0, 11, 1, "final")
 6 | 
 7 | __all__ = ['get_properties', 'EditorConfigError', 'exceptions']
 8 | 
 9 | __version__ = join_version(VERSION)
10 | 
11 | 
12 | def get_properties(filename):
13 |     """Locate and parse EditorConfig files for the given filename"""
14 |     handler = EditorConfigHandler(filename)
15 |     return handler.get_configurations()
16 | 
17 | 
18 | from editorconfig.handler import EditorConfigHandler
19 | from editorconfig.exceptions import *
20 | 


--------------------------------------------------------------------------------
/editorconfig/compat.py:
--------------------------------------------------------------------------------
 1 | """EditorConfig Python2/Python3/Jython compatibility utilities"""
 2 | import sys
 3 | import types
 4 | 
 5 | __all__ = ['slice', 'u']
 6 | 
 7 | 
 8 | if sys.version_info[0] == 2:
 9 |     slice = types.SliceType
10 | else:
11 |     slice = slice
12 | 
13 | 
14 | if sys.version_info[0] == 2:
15 |     import codecs
16 |     u = lambda s: codecs.unicode_escape_decode(s)[0]
17 | else:
18 |     u = lambda s: s
19 | 


--------------------------------------------------------------------------------
/editorconfig/exceptions.py:
--------------------------------------------------------------------------------
 1 | """EditorConfig exception classes
 2 | 
 3 | Licensed under PSF License (see LICENSE.txt file).
 4 | 
 5 | """
 6 | 
 7 | 
 8 | class EditorConfigError(Exception):
 9 |     """Parent class of all exceptions raised by EditorConfig"""
10 | 
11 | 
12 | try:
13 |     from ConfigParser import ParsingError as _ParsingError
14 | except:
15 |     from configparser import ParsingError as _ParsingError
16 | 
17 | 
18 | class ParsingError(_ParsingError, EditorConfigError):
19 |     """Error raised if an EditorConfig file could not be parsed"""
20 | 
21 | 
22 | class PathError(ValueError, EditorConfigError):
23 |     """Error raised if invalid filepath is specified"""
24 | 
25 | 
26 | class VersionError(ValueError, EditorConfigError):
27 |     """Error raised if invalid version number is specified"""
28 | 


--------------------------------------------------------------------------------
/editorconfig/fnmatch.py:
--------------------------------------------------------------------------------
  1 | """Filename matching with shell patterns.
  2 | 
  3 | fnmatch(FILENAME, PATTERN) matches according to the local convention.
  4 | fnmatchcase(FILENAME, PATTERN) always takes case in account.
  5 | 
  6 | The functions operate by translating the pattern into a regular
  7 | expression.  They cache the compiled regular expressions for speed.
  8 | 
  9 | The function translate(PATTERN) returns a regular expression
 10 | corresponding to PATTERN.  (It does not compile it.)
 11 | 
 12 | Based on code from fnmatch.py file distributed with Python 2.6.
 13 | 
 14 | Licensed under PSF License (see LICENSE.txt file).
 15 | 
 16 | Changes to original fnmatch module:
 17 | - translate function supports ``*`` and ``**`` similarly to fnmatch C library
 18 | """
 19 | 
 20 | import os
 21 | import re
 22 | 
 23 | __all__ = ["fnmatch", "fnmatchcase", "translate"]
 24 | 
 25 | _cache = {}
 26 | 
 27 | 
 28 | def fnmatch(name, pat):
 29 |     """Test whether FILENAME matches PATTERN.
 30 | 
 31 |     Patterns are Unix shell style:
 32 | 
 33 |     - ``*``             matches everything except path separator
 34 |     - ``**``            matches everything
 35 |     - ``?``             matches any single character
 36 |     - ``[seq]``         matches any character in seq
 37 |     - ``[!seq]``        matches any char not in seq
 38 |     - ``{s1,s2,s3}``    matches any of the strings given (separated by commas)
 39 | 
 40 |     An initial period in FILENAME is not special.
 41 |     Both FILENAME and PATTERN are first case-normalized
 42 |     if the operating system requires it.
 43 |     If you don't want this, use fnmatchcase(FILENAME, PATTERN).
 44 |     """
 45 | 
 46 |     name = os.path.normcase(name).replace(os.sep, "/")
 47 |     return fnmatchcase(name, pat)
 48 | 
 49 | 
 50 | def fnmatchcase(name, pat):
 51 |     """Test whether FILENAME matches PATTERN, including case.
 52 | 
 53 |     This is a version of fnmatch() which doesn't case-normalize
 54 |     its arguments.
 55 |     """
 56 | 
 57 |     if not pat in _cache:
 58 |         res = translate(pat)
 59 |         _cache[pat] = re.compile(res)
 60 |     return _cache[pat].match(name) is not None
 61 | 
 62 | 
 63 | def translate(pat):
 64 |     """Translate a shell PATTERN to a regular expression.
 65 | 
 66 |     There is no way to quote meta-characters.
 67 |     """
 68 | 
 69 |     i, n = 0, len(pat)
 70 |     res = ''
 71 |     escaped = False
 72 |     while i < n:
 73 |         c = pat[i]
 74 |         i = i + 1
 75 |         if c == '*':
 76 |             j = i
 77 |             if j < n and pat[j] == '*':
 78 |                 res = res + '.*'
 79 |             else:
 80 |                 res = res + '[^/]*'
 81 |         elif c == '?':
 82 |             res = res + '.'
 83 |         elif c == '[':
 84 |             j = i
 85 |             if j < n and pat[j] == '!':
 86 |                 j = j + 1
 87 |             if j < n and pat[j] == ']':
 88 |                 j = j + 1
 89 |             while j < n and (pat[j] != ']' or escaped):
 90 |                 escaped = pat[j] == '\\' and not escaped
 91 |                 j = j + 1
 92 |             if j >= n:
 93 |                 res = res + '\\['
 94 |             else:
 95 |                 stuff = pat[i:j]
 96 |                 i = j + 1
 97 |                 if stuff[0] == '!':
 98 |                     stuff = '^' + stuff[1:]
 99 |                 elif stuff[0] == '^':
100 |                     stuff = '\\' + stuff
101 |                 res = '%s[%s]' % (res, stuff)
102 |         elif c == '{':
103 |             j = i
104 |             groups = []
105 |             while j < n and pat[j] != '}':
106 |                 k = j
107 |                 while k < n and (pat[k] not in (',', '}') or escaped):
108 |                     escaped = pat[k] == '\\' and not escaped
109 |                     k = k + 1
110 |                 group = pat[j:k]
111 |                 for char in (',', '}', '\\'):
112 |                     group = group.replace('\\' + char, char)
113 |                 groups.append(group)
114 |                 j = k
115 |                 if j < n and pat[j] == ',':
116 |                     j = j + 1
117 |                     if j < n and pat[j] == '}':
118 |                         groups.append('')
119 |             if j >= n or len(groups) < 2:
120 |                 res = res + '\\{'
121 |             else:
122 |                 res = '%s(%s)' % (res, '|'.join(map(re.escape, groups)))
123 |                 i = j + 1
124 |         else:
125 |             res = res + re.escape(c)
126 |     return res + '\Z(?ms)'
127 | 


--------------------------------------------------------------------------------
/editorconfig/handler.py:
--------------------------------------------------------------------------------
  1 | """EditorConfig file handler
  2 | 
  3 | Provides ``EditorConfigHandler`` class for locating and parsing
  4 | EditorConfig files relevant to a given filepath.
  5 | 
  6 | Licensed under PSF License (see LICENSE.txt file).
  7 | 
  8 | """
  9 | 
 10 | import os
 11 | 
 12 | from editorconfig import VERSION
 13 | from editorconfig.ini import EditorConfigParser
 14 | from editorconfig.exceptions import PathError, VersionError
 15 | 
 16 | 
 17 | __all__ = ['EditorConfigHandler']
 18 | 
 19 | 
 20 | def get_filenames(path, filename):
 21 |     """Yield full filepath for filename in each directory in and above path"""
 22 |     path_list = []
 23 |     while True:
 24 |         path_list.append(os.path.join(path, filename))
 25 |         newpath = os.path.dirname(path)
 26 |         if path == newpath:
 27 |             break
 28 |         path = newpath
 29 |     return path_list
 30 | 
 31 | 
 32 | class EditorConfigHandler(object):
 33 | 
 34 |     """
 35 |     Allows locating and parsing of EditorConfig files for given filename
 36 | 
 37 |     In addition to the constructor a single public method is provided,
 38 |     ``get_configurations`` which returns the EditorConfig options for
 39 |     the ``filepath`` specified to the constructor.
 40 | 
 41 |     """
 42 | 
 43 |     def __init__(self, filepath, conf_filename='.editorconfig', version=None):
 44 |         """Create EditorConfigHandler for matching given filepath"""
 45 |         self.filepath = filepath
 46 |         self.conf_filename = conf_filename
 47 |         self.version = version
 48 |         self.options = None
 49 | 
 50 |     def get_configurations(self):
 51 | 
 52 |         """
 53 |         Find EditorConfig files and return all options matching filepath
 54 | 
 55 |         Special exceptions that may be raised by this function include:
 56 | 
 57 |         - ``VersionError``: self.version is invalid EditorConfig version
 58 |         - ``PathError``: self.filepath is not a valid absolute filepath
 59 |         - ``ParsingError``: improperly formatted EditorConfig file found
 60 | 
 61 |         """
 62 | 
 63 |         self.check_assertions()
 64 |         path, filename = os.path.split(self.filepath)
 65 |         conf_files = get_filenames(path, self.conf_filename)
 66 | 
 67 |         # Attempt to find and parse every EditorConfig file in filetree
 68 |         for filename in conf_files:
 69 |             parser = EditorConfigParser(self.filepath)
 70 |             parser.read(filename)
 71 | 
 72 |             # Merge new EditorConfig file's options into current options
 73 |             old_options = self.options
 74 |             self.options = parser.options
 75 |             if old_options:
 76 |                 self.options.update(old_options)
 77 | 
 78 |             # Stop parsing if parsed file has a ``root = true`` option
 79 |             if parser.root_file:
 80 |                 break
 81 | 
 82 |         self.preprocess_values()
 83 |         return self.options
 84 | 
 85 |     def check_assertions(self):
 86 | 
 87 |         """Raise error if filepath or version have invalid values"""
 88 | 
 89 |         # Raise ``PathError`` if filepath isn't an absolute path
 90 |         if not os.path.isabs(self.filepath):
 91 |             raise PathError("Input file must be a full path name.")
 92 | 
 93 |         # Raise ``VersionError`` if version specified is greater than current
 94 |         if self.version is not None and self.version[:3] > VERSION[:3]:
 95 |             raise VersionError(
 96 |                     "Required version is greater than the current version.")
 97 | 
 98 |     def preprocess_values(self):
 99 | 
100 |         """Preprocess option values for consumption by plugins"""
101 | 
102 |         opts = self.options
103 | 
104 |         # Lowercase option value for certain options
105 |         for name in ["end_of_line", "indent_style", "indent_size",
106 |             "insert_final_newline", "trim_trailing_whitespace", "charset"]:
107 |             if name in opts:
108 |                 opts[name] = opts[name].lower()
109 | 
110 |         # Set indent_size to "tab" if indent_size is unspecified and
111 |         # indent_style is set to "tab".
112 |         if (opts.get("indent_style") == "tab" and
113 |             not "indent_size" in opts and self.version >= VERSION[:3]):
114 |             opts["indent_size"] = "tab"
115 | 
116 |         # Set tab_width to indent_size if indent_size is specified and
117 |         # tab_width is unspecified
118 |         if ("indent_size" in opts and "tab_width" not in opts and
119 |             opts["indent_size"] != "tab"):
120 |             opts["tab_width"] = opts["indent_size"]
121 | 
122 |         # Set indent_size to tab_width if indent_size is "tab"
123 |         if ("indent_size" in opts and "tab_width" in opts and
124 |             opts["indent_size"] == "tab"):
125 |             opts["indent_size"] = opts["tab_width"]
126 | 


--------------------------------------------------------------------------------
/editorconfig/ini.py:
--------------------------------------------------------------------------------
  1 | """EditorConfig file parser
  2 | 
  3 | Based on code from ConfigParser.py file distributed with Python 2.6.
  4 | 
  5 | Licensed under PSF License (see LICENSE.txt file).
  6 | 
  7 | Changes to original ConfigParser:
  8 | 
  9 | - Special characters can be used in section names
 10 | - Octothorpe can be used for comments (not just at beginning of line)
 11 | - Only track INI options in sections that match target filename
 12 | - Stop parsing files with when ``root = true`` is found
 13 | 
 14 | """
 15 | 
 16 | import re
 17 | from codecs import open
 18 | import posixpath
 19 | from os import sep
 20 | from os.path import normcase, dirname
 21 | 
 22 | from editorconfig.exceptions import ParsingError
 23 | from editorconfig.fnmatch import fnmatch
 24 | from editorconfig.odict import OrderedDict
 25 | from editorconfig.compat import u
 26 | 
 27 | 
 28 | __all__ = ["ParsingError", "EditorConfigParser"]
 29 | 
 30 | 
 31 | class EditorConfigParser(object):
 32 | 
 33 |     """Parser for EditorConfig-style configuration files
 34 | 
 35 |     Based on RawConfigParser from ConfigParser.py in Python 2.6.
 36 |     """
 37 | 
 38 |     # Regular expressions for parsing section headers and options.
 39 |     # Allow ``]`` and escaped ``;`` and ``#`` characters in section headers
 40 |     SECTCRE = re.compile(
 41 |         r'\s*\['                              # [
 42 |         r'(?P<header>([^#;]|\\#|\\;)+)'       # very permissive!
 43 |         r'\]'                                 # ]
 44 |         )
 45 |     # Regular expression for parsing option name/values.
 46 |     # Allow any amount of whitespaces, followed by separator
 47 |     # (either ``:`` or ``=``), followed by any amount of whitespace and then
 48 |     # any characters to eol
 49 |     OPTCRE = re.compile(
 50 |         r'\s*(?P<option>[^:=\s][^:=]*)'
 51 |         r'\s*(?P<vi>[:=])\s*'
 52 |         r'(?P<value>.*)$'
 53 |         )
 54 | 
 55 |     def __init__(self, filename):
 56 |         self.filename = filename
 57 |         self.options = OrderedDict()
 58 |         self.root_file = False
 59 | 
 60 |     def matches_filename(self, config_filename, glob):
 61 |         """Return True if section glob matches filename"""
 62 |         config_dirname = normcase(dirname(config_filename)).replace(sep, '/')
 63 |         glob = glob.replace("\\#", "#")
 64 |         glob = glob.replace("\\;", ";")
 65 |         if '/' in glob:
 66 |             if glob.find('/') == 0:
 67 |                 glob = glob[1:]
 68 |             glob = posixpath.join(config_dirname, glob)
 69 |         else:
 70 |             glob = posixpath.join('**/', glob)
 71 |         return fnmatch(self.filename, glob)
 72 | 
 73 |     def read(self, filename):
 74 |         """Read and parse single EditorConfig file"""
 75 |         try:
 76 |             fp = open(filename, encoding='utf-8')
 77 |         except IOError:
 78 |             return
 79 |         self._read(fp, filename)
 80 |         fp.close()
 81 | 
 82 |     def _read(self, fp, fpname):
 83 |         """Parse a sectioned setup file.
 84 | 
 85 |         The sections in setup file contains a title line at the top,
 86 |         indicated by a name in square brackets (`[]'), plus key/value
 87 |         options lines, indicated by `name: value' format lines.
 88 |         Continuations are represented by an embedded newline then
 89 |         leading whitespace.  Blank lines, lines beginning with a '#',
 90 |         and just about everything else are ignored.
 91 |         """
 92 |         in_section = False
 93 |         matching_section = False
 94 |         optname = None
 95 |         lineno = 0
 96 |         e = None                                  # None, or an exception
 97 |         while True:
 98 |             line = fp.readline()
 99 |             if not line:
100 |                 break
101 |             if lineno == 0 and line.startswith(u('\ufeff')):
102 |                 line = line[1:]  # Strip UTF-8 BOM
103 |             lineno = lineno + 1
104 |             # comment or blank line?
105 |             if line.strip() == '' or line[0] in '#;':
106 |                 continue
107 |             # a section header or option header?
108 |             else:
109 |                 # is it a section header?
110 |                 mo = self.SECTCRE.match(line)
111 |                 if mo:
112 |                     sectname = mo.group('header')
113 |                     in_section = True
114 |                     matching_section = self.matches_filename(fpname, sectname)
115 |                     # So sections can't start with a continuation line
116 |                     optname = None
117 |                 # an option line?
118 |                 else:
119 |                     mo = self.OPTCRE.match(line)
120 |                     if mo:
121 |                         optname, vi, optval = mo.group('option', 'vi', 'value')
122 |                         if ';' in optval or '#' in optval:
123 |                             # ';' and '#' are comment delimiters only if
124 |                             # preceeded by a spacing character
125 |                             m = re.search('(.*?) [;#]', optval)
126 |                             if m:
127 |                                 optval = m.group(1)
128 |                         optval = optval.strip()
129 |                         # allow empty values
130 |                         if optval == '""':
131 |                             optval = ''
132 |                         optname = self.optionxform(optname.rstrip())
133 |                         if not in_section and optname == 'root':
134 |                             self.root_file = (optval.lower() == 'true')
135 |                         if matching_section:
136 |                             self.options[optname] = optval
137 |                     else:
138 |                         # a non-fatal parsing error occurred.  set up the
139 |                         # exception but keep going. the exception will be
140 |                         # raised at the end of the file and will contain a
141 |                         # list of all bogus lines
142 |                         if not e:
143 |                             e = ParsingError(fpname)
144 |                         e.append(lineno, repr(line))
145 |         # if any parsing errors occurred, raise an exception
146 |         if e:
147 |             raise e
148 | 
149 |     def optionxform(self, optionstr):
150 |         return optionstr.lower()
151 | 


--------------------------------------------------------------------------------
/editorconfig/main.py:
--------------------------------------------------------------------------------
 1 | """EditorConfig command line interface
 2 | 
 3 | Licensed under PSF License (see LICENSE.txt file).
 4 | 
 5 | """
 6 | 
 7 | import getopt
 8 | import sys
 9 | 
10 | from editorconfig import __version__, VERSION
11 | from editorconfig.versiontools import split_version
12 | from editorconfig.handler import EditorConfigHandler
13 | from editorconfig.exceptions import ParsingError, PathError, VersionError
14 | 
15 | 
16 | def version():
17 |     print("Version %s" % __version__)
18 | 
19 | 
20 | def usage(command, error=False):
21 |     if error:
22 |         out = sys.stderr
23 |     else:
24 |         out = sys.stdout
25 |     out.write("%s [OPTIONS] FILENAME\n" % command)
26 |     out.write('-f                 '
27 |             'Specify conf filename other than ".editorconfig".\n')
28 |     out.write("-b                 "
29 |             "Specify version (used by devs to test compatibility).\n")
30 |     out.write("-h OR --help       Print this help message.\n")
31 |     out.write("-v OR --version    Display version information.\n")
32 | 
33 | 
34 | def main():
35 |     command_name = sys.argv[0]
36 |     try:
37 |         opts, args = getopt.getopt(sys.argv[1:], "vhb:f:", ["version", "help"])
38 |     except getopt.GetoptError:
39 |         print(str(sys.exc_info()[1]))  # For Python 2/3 compatibility
40 |         usage(command_name, error=True)
41 |         sys.exit(2)
42 | 
43 |     version_tuple = VERSION
44 |     conf_filename = '.editorconfig'
45 | 
46 |     for option, arg in opts:
47 |         if option in ('-h', '--help'):
48 |             usage(command_name)
49 |             sys.exit()
50 |         if option in ('-v', '--version'):
51 |             version()
52 |             sys.exit()
53 |         if option == '-f':
54 |             conf_filename = arg
55 |         if option == '-b':
56 |             version_tuple = split_version(arg)
57 |             if version_tuple is None:
58 |                 sys.exit("Invalid version number: %s" % arg)
59 | 
60 |     if len(args) < 1:
61 |         usage(command_name, error=True)
62 |         sys.exit(2)
63 |     filenames = args
64 |     multiple_files = len(args) > 1
65 | 
66 |     for filename in filenames:
67 |         handler = EditorConfigHandler(filename, conf_filename, version_tuple)
68 |         try:
69 |             options = handler.get_configurations()
70 |         except (ParsingError, PathError, VersionError):
71 |             print(str(sys.exc_info()[1]))  # For Python 2/3 compatibility
72 |             sys.exit(2)
73 |         if multiple_files:
74 |             print("[%s]" % filename)
75 |         for key, value in options.items():
76 |             print("%s=%s" % (key, value))
77 | 


--------------------------------------------------------------------------------
/editorconfig/odict.py:
--------------------------------------------------------------------------------
  1 | """odict.py: An Ordered Dictionary object"""
  2 | # Copyright (C) 2005 Nicola Larosa, Michael Foord
  3 | # E-mail: nico AT tekNico DOT net, fuzzyman AT voidspace DOT org DOT uk
  4 | # Copyright (c) 2003-2010, Michael Foord
  5 | # E-mail : fuzzyman AT voidspace DOT org DOT uk
  6 | #
  7 | # Redistribution and use in source and binary forms, with or without
  8 | # modification, are permitted provided that the following conditions are
  9 | # met:
 10 | #
 11 | #
 12 | #     * Redistributions of source code must retain the above copyright
 13 | #       notice, this list of conditions and the following disclaimer.
 14 | #
 15 | #     * Redistributions in binary form must reproduce the above
 16 | #       copyright notice, this list of conditions and the following
 17 | #       disclaimer in the documentation and/or other materials provided
 18 | #       with the distribution.
 19 | #
 20 | #     * Neither the name of Michael Foord nor the name of Voidspace
 21 | #       may be used to endorse or promote products derived from this
 22 | #       software without specific prior written permission.
 23 | #
 24 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 25 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 26 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 27 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 28 | # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 29 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 30 | # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 31 | # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 32 | # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 33 | # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 34 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 35 | 
 36 | 
 37 | from __future__ import generators
 38 | import sys
 39 | import warnings
 40 | 
 41 | from editorconfig.compat import slice
 42 | 
 43 | 
 44 | __docformat__ = "restructuredtext en"
 45 | __all__ = ['OrderedDict']
 46 | 
 47 | 
 48 | INTP_VER = sys.version_info[:2]
 49 | if INTP_VER < (2, 2):
 50 |     raise RuntimeError("Python v.2.2 or later required")
 51 | 
 52 | 
 53 | class OrderedDict(dict):
 54 |     """
 55 |     A class of dictionary that keeps the insertion order of keys.
 56 | 
 57 |     All appropriate methods return keys, items, or values in an ordered way.
 58 | 
 59 |     All normal dictionary methods are available. Update and comparison is
 60 |     restricted to other OrderedDict objects.
 61 | 
 62 |     Various sequence methods are available, including the ability to explicitly
 63 |     mutate the key ordering.
 64 | 
 65 |     __contains__ tests:
 66 | 
 67 |     >>> d = OrderedDict(((1, 3),))
 68 |     >>> 1 in d
 69 |     1
 70 |     >>> 4 in d
 71 |     0
 72 | 
 73 |     __getitem__ tests:
 74 | 
 75 |     >>> OrderedDict(((1, 3), (3, 2), (2, 1)))[2]
 76 |     1
 77 |     >>> OrderedDict(((1, 3), (3, 2), (2, 1)))[4]
 78 |     Traceback (most recent call last):
 79 |     KeyError: 4
 80 | 
 81 |     __len__ tests:
 82 | 
 83 |     >>> len(OrderedDict())
 84 |     0
 85 |     >>> len(OrderedDict(((1, 3), (3, 2), (2, 1))))
 86 |     3
 87 | 
 88 |     get tests:
 89 | 
 90 |     >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
 91 |     >>> d.get(1)
 92 |     3
 93 |     >>> d.get(4) is None
 94 |     1
 95 |     >>> d.get(4, 5)
 96 |     5
 97 |     >>> d
 98 |     OrderedDict([(1, 3), (3, 2), (2, 1)])
 99 | 
100 |     has_key tests:
101 | 
102 |     >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
103 |     >>> d.has_key(1)
104 |     1
105 |     >>> d.has_key(4)
106 |     0
107 |     """
108 | 
109 |     def __init__(self, init_val=(), strict=False):
110 |         """
111 |         Create a new ordered dictionary. Cannot init from a normal dict,
112 |         nor from kwargs, since items order is undefined in those cases.
113 | 
114 |         If the ``strict`` keyword argument is ``True`` (``False`` is the
115 |         default) then when doing slice assignment - the ``OrderedDict`` you are
116 |         assigning from *must not* contain any keys in the remaining dict.
117 | 
118 |         >>> OrderedDict()
119 |         OrderedDict([])
120 |         >>> OrderedDict({1: 1})
121 |         Traceback (most recent call last):
122 |         TypeError: undefined order, cannot get items from dict
123 |         >>> OrderedDict({1: 1}.items())
124 |         OrderedDict([(1, 1)])
125 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
126 |         >>> d
127 |         OrderedDict([(1, 3), (3, 2), (2, 1)])
128 |         >>> OrderedDict(d)
129 |         OrderedDict([(1, 3), (3, 2), (2, 1)])
130 |         """
131 |         self.strict = strict
132 |         dict.__init__(self)
133 |         if isinstance(init_val, OrderedDict):
134 |             self._sequence = init_val.keys()
135 |             dict.update(self, init_val)
136 |         elif isinstance(init_val, dict):
137 |             # we lose compatibility with other ordered dict types this way
138 |             raise TypeError('undefined order, cannot get items from dict')
139 |         else:
140 |             self._sequence = []
141 |             self.update(init_val)
142 | 
143 | ### Special methods ###
144 | 
145 |     def __delitem__(self, key):
146 |         """
147 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
148 |         >>> del d[3]
149 |         >>> d
150 |         OrderedDict([(1, 3), (2, 1)])
151 |         >>> del d[3]
152 |         Traceback (most recent call last):
153 |         KeyError: 3
154 |         >>> d[3] = 2
155 |         >>> d
156 |         OrderedDict([(1, 3), (2, 1), (3, 2)])
157 |         >>> del d[0:1]
158 |         >>> d
159 |         OrderedDict([(2, 1), (3, 2)])
160 |         """
161 |         if isinstance(key, slice):
162 |             # FIXME: efficiency?
163 |             keys = self._sequence[key]
164 |             for entry in keys:
165 |                 dict.__delitem__(self, entry)
166 |             del self._sequence[key]
167 |         else:
168 |             # do the dict.__delitem__ *first* as it raises
169 |             # the more appropriate error
170 |             dict.__delitem__(self, key)
171 |             self._sequence.remove(key)
172 | 
173 |     def __eq__(self, other):
174 |         """
175 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
176 |         >>> d == OrderedDict(d)
177 |         True
178 |         >>> d == OrderedDict(((1, 3), (2, 1), (3, 2)))
179 |         False
180 |         >>> d == OrderedDict(((1, 0), (3, 2), (2, 1)))
181 |         False
182 |         >>> d == OrderedDict(((0, 3), (3, 2), (2, 1)))
183 |         False
184 |         >>> d == dict(d)
185 |         False
186 |         >>> d == False
187 |         False
188 |         """
189 |         if isinstance(other, OrderedDict):
190 |             # FIXME: efficiency?
191 |             #   Generate both item lists for each compare
192 |             return (self.items() == other.items())
193 |         else:
194 |             return False
195 | 
196 |     def __lt__(self, other):
197 |         """
198 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
199 |         >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))
200 |         >>> c < d
201 |         True
202 |         >>> d < c
203 |         False
204 |         >>> d < dict(c)
205 |         Traceback (most recent call last):
206 |         TypeError: Can only compare with other OrderedDicts
207 |         """
208 |         if not isinstance(other, OrderedDict):
209 |             raise TypeError('Can only compare with other OrderedDicts')
210 |         # FIXME: efficiency?
211 |         #   Generate both item lists for each compare
212 |         return (self.items() < other.items())
213 | 
214 |     def __le__(self, other):
215 |         """
216 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
217 |         >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))
218 |         >>> e = OrderedDict(d)
219 |         >>> c <= d
220 |         True
221 |         >>> d <= c
222 |         False
223 |         >>> d <= dict(c)
224 |         Traceback (most recent call last):
225 |         TypeError: Can only compare with other OrderedDicts
226 |         >>> d <= e
227 |         True
228 |         """
229 |         if not isinstance(other, OrderedDict):
230 |             raise TypeError('Can only compare with other OrderedDicts')
231 |         # FIXME: efficiency?
232 |         #   Generate both item lists for each compare
233 |         return (self.items() <= other.items())
234 | 
235 |     def __ne__(self, other):
236 |         """
237 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
238 |         >>> d != OrderedDict(d)
239 |         False
240 |         >>> d != OrderedDict(((1, 3), (2, 1), (3, 2)))
241 |         True
242 |         >>> d != OrderedDict(((1, 0), (3, 2), (2, 1)))
243 |         True
244 |         >>> d == OrderedDict(((0, 3), (3, 2), (2, 1)))
245 |         False
246 |         >>> d != dict(d)
247 |         True
248 |         >>> d != False
249 |         True
250 |         """
251 |         if isinstance(other, OrderedDict):
252 |             # FIXME: efficiency?
253 |             #   Generate both item lists for each compare
254 |             return not (self.items() == other.items())
255 |         else:
256 |             return True
257 | 
258 |     def __gt__(self, other):
259 |         """
260 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
261 |         >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))
262 |         >>> d > c
263 |         True
264 |         >>> c > d
265 |         False
266 |         >>> d > dict(c)
267 |         Traceback (most recent call last):
268 |         TypeError: Can only compare with other OrderedDicts
269 |         """
270 |         if not isinstance(other, OrderedDict):
271 |             raise TypeError('Can only compare with other OrderedDicts')
272 |         # FIXME: efficiency?
273 |         #   Generate both item lists for each compare
274 |         return (self.items() > other.items())
275 | 
276 |     def __ge__(self, other):
277 |         """
278 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
279 |         >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))
280 |         >>> e = OrderedDict(d)
281 |         >>> c >= d
282 |         False
283 |         >>> d >= c
284 |         True
285 |         >>> d >= dict(c)
286 |         Traceback (most recent call last):
287 |         TypeError: Can only compare with other OrderedDicts
288 |         >>> e >= d
289 |         True
290 |         """
291 |         if not isinstance(other, OrderedDict):
292 |             raise TypeError('Can only compare with other OrderedDicts')
293 |         # FIXME: efficiency?
294 |         #   Generate both item lists for each compare
295 |         return (self.items() >= other.items())
296 | 
297 |     def __repr__(self):
298 |         """
299 |         Used for __repr__ and __str__
300 | 
301 |         >>> r1 = repr(OrderedDict((('a', 'b'), ('c', 'd'), ('e', 'f'))))
302 |         >>> r1
303 |         "OrderedDict([('a', 'b'), ('c', 'd'), ('e', 'f')])"
304 |         >>> r2 = repr(OrderedDict((('a', 'b'), ('e', 'f'), ('c', 'd'))))
305 |         >>> r2
306 |         "OrderedDict([('a', 'b'), ('e', 'f'), ('c', 'd')])"
307 |         >>> r1 == str(OrderedDict((('a', 'b'), ('c', 'd'), ('e', 'f'))))
308 |         True
309 |         >>> r2 == str(OrderedDict((('a', 'b'), ('e', 'f'), ('c', 'd'))))
310 |         True
311 |         """
312 |         return '%s([%s])' % (self.__class__.__name__, ', '.join(
313 |             ['(%r, %r)' % (key, self[key]) for key in self._sequence]))
314 | 
315 |     def __setitem__(self, key, val):
316 |         """
317 |         Allows slice assignment, so long as the slice is an OrderedDict
318 |         >>> d = OrderedDict()
319 |         >>> d['a'] = 'b'
320 |         >>> d['b'] = 'a'
321 |         >>> d[3] = 12
322 |         >>> d
323 |         OrderedDict([('a', 'b'), ('b', 'a'), (3, 12)])
324 |         >>> d[:] = OrderedDict(((1, 2), (2, 3), (3, 4)))
325 |         >>> d
326 |         OrderedDict([(1, 2), (2, 3), (3, 4)])
327 |         >>> d[::2] = OrderedDict(((7, 8), (9, 10)))
328 |         >>> d
329 |         OrderedDict([(7, 8), (2, 3), (9, 10)])
330 |         >>> d = OrderedDict(((0, 1), (1, 2), (2, 3), (3, 4)))
331 |         >>> d[1:3] = OrderedDict(((1, 2), (5, 6), (7, 8)))
332 |         >>> d
333 |         OrderedDict([(0, 1), (1, 2), (5, 6), (7, 8), (3, 4)])
334 |         >>> d = OrderedDict(((0, 1), (1, 2), (2, 3), (3, 4)), strict=True)
335 |         >>> d[1:3] = OrderedDict(((1, 2), (5, 6), (7, 8)))
336 |         >>> d
337 |         OrderedDict([(0, 1), (1, 2), (5, 6), (7, 8), (3, 4)])
338 | 
339 |         >>> a = OrderedDict(((0, 1), (1, 2), (2, 3)), strict=True)
340 |         >>> a[3] = 4
341 |         >>> a
342 |         OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
343 |         >>> a[::1] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
344 |         >>> a
345 |         OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
346 |         >>> a[:2] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)])
347 |         Traceback (most recent call last):
348 |         ValueError: slice assignment must be from unique keys
349 |         >>> a = OrderedDict(((0, 1), (1, 2), (2, 3)))
350 |         >>> a[3] = 4
351 |         >>> a
352 |         OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
353 |         >>> a[::1] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
354 |         >>> a
355 |         OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
356 |         >>> a[:2] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
357 |         >>> a
358 |         OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
359 |         >>> a[::-1] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
360 |         >>> a
361 |         OrderedDict([(3, 4), (2, 3), (1, 2), (0, 1)])
362 | 
363 |         >>> d = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
364 |         >>> d[:1] = 3
365 |         Traceback (most recent call last):
366 |         TypeError: slice assignment requires an OrderedDict
367 | 
368 |         >>> d = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
369 |         >>> d[:1] = OrderedDict([(9, 8)])
370 |         >>> d
371 |         OrderedDict([(9, 8), (1, 2), (2, 3), (3, 4)])
372 |         """
373 |         if isinstance(key, slice):
374 |             if not isinstance(val, OrderedDict):
375 |                 # FIXME: allow a list of tuples?
376 |                 raise TypeError('slice assignment requires an OrderedDict')
377 |             keys = self._sequence[key]
378 |             # NOTE: Could use ``range(*key.indices(len(self._sequence)))``
379 |             indexes = range(len(self._sequence))[key]
380 |             if key.step is None:
381 |                 # NOTE: new slice may not be the same size as the one being
382 |                 #   overwritten !
383 |                 # NOTE: What is the algorithm for an impossible slice?
384 |                 #   e.g. d[5:3]
385 |                 pos = key.start or 0
386 |                 del self[key]
387 |                 newkeys = val.keys()
388 |                 for k in newkeys:
389 |                     if k in self:
390 |                         if self.strict:
391 |                             raise ValueError('slice assignment must be from '
392 |                                 'unique keys')
393 |                         else:
394 |                             # NOTE: This removes duplicate keys *first*
395 |                             #   so start position might have changed?
396 |                             del self[k]
397 |                 self._sequence = (self._sequence[:pos] + newkeys +
398 |                     self._sequence[pos:])
399 |                 dict.update(self, val)
400 |             else:
401 |                 # extended slice - length of new slice must be the same
402 |                 # as the one being replaced
403 |                 if len(keys) != len(val):
404 |                     raise ValueError('attempt to assign sequence of size %s '
405 |                         'to extended slice of size %s' % (len(val), len(keys)))
406 |                 # FIXME: efficiency?
407 |                 del self[key]
408 |                 item_list = zip(indexes, val.items())
409 |                 # smallest indexes first - higher indexes not guaranteed to
410 |                 # exist
411 |                 item_list.sort()
412 |                 for pos, (newkey, newval) in item_list:
413 |                     if self.strict and newkey in self:
414 |                         raise ValueError('slice assignment must be from unique'
415 |                             ' keys')
416 |                     self.insert(pos, newkey, newval)
417 |         else:
418 |             if key not in self:
419 |                 self._sequence.append(key)
420 |             dict.__setitem__(self, key, val)
421 | 
422 |     def __getitem__(self, key):
423 |         """
424 |         Allows slicing. Returns an OrderedDict if you slice.
425 |         >>> b = OrderedDict([(7, 0), (6, 1), (5, 2), (4, 3), (3, 4), (2, 5), (1, 6)])
426 |         >>> b[::-1]
427 |         OrderedDict([(1, 6), (2, 5), (3, 4), (4, 3), (5, 2), (6, 1), (7, 0)])
428 |         >>> b[2:5]
429 |         OrderedDict([(5, 2), (4, 3), (3, 4)])
430 |         >>> type(b[2:4])
431 |         <class '__main__.OrderedDict'>
432 |         """
433 |         if isinstance(key, slice):
434 |             # FIXME: does this raise the error we want?
435 |             keys = self._sequence[key]
436 |             # FIXME: efficiency?
437 |             return OrderedDict([(entry, self[entry]) for entry in keys])
438 |         else:
439 |             return dict.__getitem__(self, key)
440 | 
441 |     __str__ = __repr__
442 | 
443 |     def __setattr__(self, name, value):
444 |         """
445 |         Implemented so that accesses to ``sequence`` raise a warning and are
446 |         diverted to the new ``setkeys`` method.
447 |         """
448 |         if name == 'sequence':
449 |             warnings.warn('Use of the sequence attribute is deprecated.'
450 |                 ' Use the keys method instead.', DeprecationWarning)
451 |             # NOTE: doesn't return anything
452 |             self.setkeys(value)
453 |         else:
454 |             # FIXME: do we want to allow arbitrary setting of attributes?
455 |             #   Or do we want to manage it?
456 |             object.__setattr__(self, name, value)
457 | 
458 |     def __getattr__(self, name):
459 |         """
460 |         Implemented so that access to ``sequence`` raises a warning.
461 | 
462 |         >>> d = OrderedDict()
463 |         >>> d.sequence
464 |         []
465 |         """
466 |         if name == 'sequence':
467 |             warnings.warn('Use of the sequence attribute is deprecated.'
468 |                 ' Use the keys method instead.', DeprecationWarning)
469 |             # NOTE: Still (currently) returns a direct reference. Need to
470 |             #   because code that uses sequence will expect to be able to
471 |             #   mutate it in place.
472 |             return self._sequence
473 |         else:
474 |             # raise the appropriate error
475 |             raise AttributeError("OrderedDict has no '%s' attribute" % name)
476 | 
477 |     def __deepcopy__(self, memo):
478 |         """
479 |         To allow deepcopy to work with OrderedDict.
480 | 
481 |         >>> from copy import deepcopy
482 |         >>> a = OrderedDict([(1, 1), (2, 2), (3, 3)])
483 |         >>> a['test'] = {}
484 |         >>> b = deepcopy(a)
485 |         >>> b == a
486 |         True
487 |         >>> b is a
488 |         False
489 |         >>> a['test'] is b['test']
490 |         False
491 |         """
492 |         from copy import deepcopy
493 |         return self.__class__(deepcopy(self.items(), memo), self.strict)
494 | 
495 | ### Read-only methods ###
496 | 
497 |     def copy(self):
498 |         """
499 |         >>> OrderedDict(((1, 3), (3, 2), (2, 1))).copy()
500 |         OrderedDict([(1, 3), (3, 2), (2, 1)])
501 |         """
502 |         return OrderedDict(self)
503 | 
504 |     def items(self):
505 |         """
506 |         ``items`` returns a list of tuples representing all the
507 |         ``(key, value)`` pairs in the dictionary.
508 | 
509 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
510 |         >>> d.items()
511 |         [(1, 3), (3, 2), (2, 1)]
512 |         >>> d.clear()
513 |         >>> d.items()
514 |         []
515 |         """
516 |         return zip(self._sequence, self.values())
517 | 
518 |     def keys(self):
519 |         """
520 |         Return a list of keys in the ``OrderedDict``.
521 | 
522 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
523 |         >>> d.keys()
524 |         [1, 3, 2]
525 |         """
526 |         return self._sequence[:]
527 | 
528 |     def values(self, values=None):
529 |         """
530 |         Return a list of all the values in the OrderedDict.
531 | 
532 |         Optionally you can pass in a list of values, which will replace the
533 |         current list. The value list must be the same len as the OrderedDict.
534 | 
535 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
536 |         >>> d.values()
537 |         [3, 2, 1]
538 |         """
539 |         return [self[key] for key in self._sequence]
540 | 
541 |     def iteritems(self):
542 |         """
543 |         >>> ii = OrderedDict(((1, 3), (3, 2), (2, 1))).iteritems()
544 |         >>> ii.next()
545 |         (1, 3)
546 |         >>> ii.next()
547 |         (3, 2)
548 |         >>> ii.next()
549 |         (2, 1)
550 |         >>> ii.next()
551 |         Traceback (most recent call last):
552 |         StopIteration
553 |         """
554 |         def make_iter(self=self):
555 |             keys = self.iterkeys()
556 |             while True:
557 |                 key = keys.next()
558 |                 yield (key, self[key])
559 |         return make_iter()
560 | 
561 |     def iterkeys(self):
562 |         """
563 |         >>> ii = OrderedDict(((1, 3), (3, 2), (2, 1))).iterkeys()
564 |         >>> ii.next()
565 |         1
566 |         >>> ii.next()
567 |         3
568 |         >>> ii.next()
569 |         2
570 |         >>> ii.next()
571 |         Traceback (most recent call last):
572 |         StopIteration
573 |         """
574 |         return iter(self._sequence)
575 | 
576 |     __iter__ = iterkeys
577 | 
578 |     def itervalues(self):
579 |         """
580 |         >>> iv = OrderedDict(((1, 3), (3, 2), (2, 1))).itervalues()
581 |         >>> iv.next()
582 |         3
583 |         >>> iv.next()
584 |         2
585 |         >>> iv.next()
586 |         1
587 |         >>> iv.next()
588 |         Traceback (most recent call last):
589 |         StopIteration
590 |         """
591 |         def make_iter(self=self):
592 |             keys = self.iterkeys()
593 |             while True:
594 |                 yield self[keys.next()]
595 |         return make_iter()
596 | 
597 | ### Read-write methods ###
598 | 
599 |     def clear(self):
600 |         """
601 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
602 |         >>> d.clear()
603 |         >>> d
604 |         OrderedDict([])
605 |         """
606 |         dict.clear(self)
607 |         self._sequence = []
608 | 
609 |     def pop(self, key, *args):
610 |         """
611 |         No dict.pop in Python 2.2, gotta reimplement it
612 | 
613 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
614 |         >>> d.pop(3)
615 |         2
616 |         >>> d
617 |         OrderedDict([(1, 3), (2, 1)])
618 |         >>> d.pop(4)
619 |         Traceback (most recent call last):
620 |         KeyError: 4
621 |         >>> d.pop(4, 0)
622 |         0
623 |         >>> d.pop(4, 0, 1)
624 |         Traceback (most recent call last):
625 |         TypeError: pop expected at most 2 arguments, got 3
626 |         """
627 |         if len(args) > 1:
628 |             raise TypeError('pop expected at most 2 arguments, got %s' %
629 |                 (len(args) + 1))
630 |         if key in self:
631 |             val = self[key]
632 |             del self[key]
633 |         else:
634 |             try:
635 |                 val = args[0]
636 |             except IndexError:
637 |                 raise KeyError(key)
638 |         return val
639 | 
640 |     def popitem(self, i=-1):
641 |         """
642 |         Delete and return an item specified by index, not a random one as in
643 |         dict. The index is -1 by default (the last item).
644 | 
645 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
646 |         >>> d.popitem()
647 |         (2, 1)
648 |         >>> d
649 |         OrderedDict([(1, 3), (3, 2)])
650 |         >>> d.popitem(0)
651 |         (1, 3)
652 |         >>> OrderedDict().popitem()
653 |         Traceback (most recent call last):
654 |         KeyError: 'popitem(): dictionary is empty'
655 |         >>> d.popitem(2)
656 |         Traceback (most recent call last):
657 |         IndexError: popitem(): index 2 not valid
658 |         """
659 |         if not self._sequence:
660 |             raise KeyError('popitem(): dictionary is empty')
661 |         try:
662 |             key = self._sequence[i]
663 |         except IndexError:
664 |             raise IndexError('popitem(): index %s not valid' % i)
665 |         return (key, self.pop(key))
666 | 
667 |     def setdefault(self, key, defval=None):
668 |         """
669 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
670 |         >>> d.setdefault(1)
671 |         3
672 |         >>> d.setdefault(4) is None
673 |         True
674 |         >>> d
675 |         OrderedDict([(1, 3), (3, 2), (2, 1), (4, None)])
676 |         >>> d.setdefault(5, 0)
677 |         0
678 |         >>> d
679 |         OrderedDict([(1, 3), (3, 2), (2, 1), (4, None), (5, 0)])
680 |         """
681 |         if key in self:
682 |             return self[key]
683 |         else:
684 |             self[key] = defval
685 |             return defval
686 | 
687 |     def update(self, from_od):
688 |         """
689 |         Update from another OrderedDict or sequence of (key, value) pairs
690 | 
691 |         >>> d = OrderedDict(((1, 0), (0, 1)))
692 |         >>> d.update(OrderedDict(((1, 3), (3, 2), (2, 1))))
693 |         >>> d
694 |         OrderedDict([(1, 3), (0, 1), (3, 2), (2, 1)])
695 |         >>> d.update({4: 4})
696 |         Traceback (most recent call last):
697 |         TypeError: undefined order, cannot get items from dict
698 |         >>> d.update((4, 4))
699 |         Traceback (most recent call last):
700 |         TypeError: cannot convert dictionary update sequence element "4" to a 2-item sequence
701 |         """
702 |         if isinstance(from_od, OrderedDict):
703 |             for key, val in from_od.items():
704 |                 self[key] = val
705 |         elif isinstance(from_od, dict):
706 |             # we lose compatibility with other ordered dict types this way
707 |             raise TypeError('undefined order, cannot get items from dict')
708 |         else:
709 |             # FIXME: efficiency?
710 |             # sequence of 2-item sequences, or error
711 |             for item in from_od:
712 |                 try:
713 |                     key, val = item
714 |                 except TypeError:
715 |                     raise TypeError('cannot convert dictionary update'
716 |                         ' sequence element "%s" to a 2-item sequence' % item)
717 |                 self[key] = val
718 | 
719 |     def rename(self, old_key, new_key):
720 |         """
721 |         Rename the key for a given value, without modifying sequence order.
722 | 
723 |         For the case where new_key already exists this raise an exception,
724 |         since if new_key exists, it is ambiguous as to what happens to the
725 |         associated values, and the position of new_key in the sequence.
726 | 
727 |         >>> od = OrderedDict()
728 |         >>> od['a'] = 1
729 |         >>> od['b'] = 2
730 |         >>> od.items()
731 |         [('a', 1), ('b', 2)]
732 |         >>> od.rename('b', 'c')
733 |         >>> od.items()
734 |         [('a', 1), ('c', 2)]
735 |         >>> od.rename('c', 'a')
736 |         Traceback (most recent call last):
737 |         ValueError: New key already exists: 'a'
738 |         >>> od.rename('d', 'b')
739 |         Traceback (most recent call last):
740 |         KeyError: 'd'
741 |         """
742 |         if new_key == old_key:
743 |             # no-op
744 |             return
745 |         if new_key in self:
746 |             raise ValueError("New key already exists: %r" % new_key)
747 |         # rename sequence entry
748 |         value = self[old_key]
749 |         old_idx = self._sequence.index(old_key)
750 |         self._sequence[old_idx] = new_key
751 |         # rename internal dict entry
752 |         dict.__delitem__(self, old_key)
753 |         dict.__setitem__(self, new_key, value)
754 | 
755 |     def setitems(self, items):
756 |         """
757 |         This method allows you to set the items in the dict.
758 | 
759 |         It takes a list of tuples - of the same sort returned by the ``items``
760 |         method.
761 | 
762 |         >>> d = OrderedDict()
763 |         >>> d.setitems(((3, 1), (2, 3), (1, 2)))
764 |         >>> d
765 |         OrderedDict([(3, 1), (2, 3), (1, 2)])
766 |         """
767 |         self.clear()
768 |         # FIXME: this allows you to pass in an OrderedDict as well :-)
769 |         self.update(items)
770 | 
771 |     def setkeys(self, keys):
772 |         """
773 |         ``setkeys`` all ows you to pass in a new list of keys which will
774 |         replace the current set. This must contain the same set of keys, but
775 |         need not be in the same order.
776 | 
777 |         If you pass in new keys that don't match, a ``KeyError`` will be
778 |         raised.
779 | 
780 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
781 |         >>> d.keys()
782 |         [1, 3, 2]
783 |         >>> d.setkeys((1, 2, 3))
784 |         >>> d
785 |         OrderedDict([(1, 3), (2, 1), (3, 2)])
786 |         >>> d.setkeys(['a', 'b', 'c'])
787 |         Traceback (most recent call last):
788 |         KeyError: 'Keylist is not the same as current keylist.'
789 |         """
790 |         # FIXME: Efficiency? (use set for Python 2.4 :-)
791 |         # NOTE: list(keys) rather than keys[:] because keys[:] returns
792 |         #   a tuple, if keys is a tuple.
793 |         kcopy = list(keys)
794 |         kcopy.sort()
795 |         self._sequence.sort()
796 |         if kcopy != self._sequence:
797 |             raise KeyError('Keylist is not the same as current keylist.')
798 |         # NOTE: This makes the _sequence attribute a new object, instead
799 |         #       of changing it in place.
800 |         # FIXME: efficiency?
801 |         self._sequence = list(keys)
802 | 
803 |     def setvalues(self, values):
804 |         """
805 |         You can pass in a list of values, which will replace the
806 |         current list. The value list must be the same len as the OrderedDict.
807 | 
808 |         (Or a ``ValueError`` is raised.)
809 | 
810 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
811 |         >>> d.setvalues((1, 2, 3))
812 |         >>> d
813 |         OrderedDict([(1, 1), (3, 2), (2, 3)])
814 |         >>> d.setvalues([6])
815 |         Traceback (most recent call last):
816 |         ValueError: Value list is not the same length as the OrderedDict.
817 |         """
818 |         if len(values) != len(self):
819 |             # FIXME: correct error to raise?
820 |             raise ValueError('Value list is not the same length as the '
821 |                 'OrderedDict.')
822 |         self.update(zip(self, values))
823 | 
824 | ### Sequence Methods ###
825 | 
826 |     def index(self, key):
827 |         """
828 |         Return the position of the specified key in the OrderedDict.
829 | 
830 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
831 |         >>> d.index(3)
832 |         1
833 |         >>> d.index(4)
834 |         Traceback (most recent call last):
835 |         ValueError: 4 is not in list
836 |         """
837 |         return self._sequence.index(key)
838 | 
839 |     def insert(self, index, key, value):
840 |         """
841 |         Takes ``index``, ``key``, and ``value`` as arguments.
842 | 
843 |         Sets ``key`` to ``value``, so that ``key`` is at position ``index`` in
844 |         the OrderedDict.
845 | 
846 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
847 |         >>> d.insert(0, 4, 0)
848 |         >>> d
849 |         OrderedDict([(4, 0), (1, 3), (3, 2), (2, 1)])
850 |         >>> d.insert(0, 2, 1)
851 |         >>> d
852 |         OrderedDict([(2, 1), (4, 0), (1, 3), (3, 2)])
853 |         >>> d.insert(8, 8, 1)
854 |         >>> d
855 |         OrderedDict([(2, 1), (4, 0), (1, 3), (3, 2), (8, 1)])
856 |         """
857 |         if key in self:
858 |             # FIXME: efficiency?
859 |             del self[key]
860 |         self._sequence.insert(index, key)
861 |         dict.__setitem__(self, key, value)
862 | 
863 |     def reverse(self):
864 |         """
865 |         Reverse the order of the OrderedDict.
866 | 
867 |         >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
868 |         >>> d.reverse()
869 |         >>> d
870 |         OrderedDict([(2, 1), (3, 2), (1, 3)])
871 |         """
872 |         self._sequence.reverse()
873 | 
874 |     def sort(self, *args, **kwargs):
875 |         """
876 |         Sort the key order in the OrderedDict.
877 | 
878 |         This method takes the same arguments as the ``list.sort`` method on
879 |         your version of Python.
880 | 
881 |         >>> d = OrderedDict(((4, 1), (2, 2), (3, 3), (1, 4)))
882 |         >>> d.sort()
883 |         >>> d
884 |         OrderedDict([(1, 4), (2, 2), (3, 3), (4, 1)])
885 |         """
886 |         self._sequence.sort(*args, **kwargs)
887 | 
888 | 
889 | if __name__ == '__main__':
890 |     # turn off warnings for tests
891 |     warnings.filterwarnings('ignore')
892 |     # run the code tests in doctest format
893 |     import doctest
894 |     m = sys.modules.get('__main__')
895 |     globs = m.__dict__.copy()
896 |     globs.update({
897 |         'INTP_VER': INTP_VER,
898 |     })
899 |     doctest.testmod(m, globs=globs)
900 | 


--------------------------------------------------------------------------------
/editorconfig/versiontools.py:
--------------------------------------------------------------------------------
 1 | """EditorConfig version tools
 2 | 
 3 | Provides ``join_version`` and ``split_version`` classes for converting
 4 | __version__ strings to VERSION tuples and vice versa.
 5 | 
 6 | """
 7 | 
 8 | import re
 9 | 
10 | 
11 | __all__ = ['join_version', 'split_version']
12 | 
13 | 
14 | _version_re = re.compile(r'^(\d+)\.(\d+)\.(\d+)(\..*)?$', re.VERBOSE)
15 | 
16 | 
17 | def join_version(version_tuple):
18 |     """Return a string representation of version from given VERSION tuple"""
19 |     version = "%s.%s.%s" % version_tuple[:3]
20 |     if version_tuple[3] != "final":
21 |         version += "-%s" % version_tuple[3]
22 |     return version
23 | 
24 | 
25 | def split_version(version):
26 |     """Return VERSION tuple for given string representation of version"""
27 |     match = _version_re.search(version)
28 |     if not match:
29 |         return None
30 |     else:
31 |         split_version = list(match.groups())
32 |         if split_version[3] is None:
33 |             split_version[3] = "final"
34 |         split_version = list(map(int, split_version[:3])) + split_version[3:]
35 |         return tuple(split_version)
36 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | # EditorConfig - Sublime Text plugin
 2 | 
 3 | > [EditorConfig](http://editorconfig.org) helps developers define and maintain consistent coding styles between different editors and IDEs. The EditorConfig project consists of a file format for defining coding styles and a collection of text editor plugins that enable editors to read the file format and adhere to defined styles. EditorConfig files are easily readibly and they work nicely with version control systems.
 4 | 
 5 | 
 6 | ## Install
 7 | 
 8 | 
 9 | ### Sublime Text 2
10 | 
11 | Install with [Package Control](http://wbond.net/sublime_packages/package_control)
12 | 
13 | 
14 | ### Sublime Text 3
15 | 
16 | [Download](https://github.com/sindresorhus/editorconfig-sublime/archive/st3.zip), unzip, and put the contents in `~/Library/Application Support/Sublime Text 3/Packages/EditorConfig`.  
17 | Will be easier when Package Control is fully compatible.
18 | 
19 | 
20 | ## Getting started
21 | 
22 | See the [EditorConfig site][] for documentation.
23 | 
24 | 
25 | ## Supported properties
26 | 
27 | - root
28 | - indent_style
29 | - indent_size
30 | - end\_of\_line
31 | - charset
32 | - trim_trailing_whitespace
33 | - insert_final_newline
34 | 
35 | Explanation of the properties can be found on the [EditorConfig site][].
36 | 
37 | 
38 | ## Example file
39 | 
40 | *My recommended default settings*
41 | 
42 | ```ini
43 | # editorconfig.org
44 | root = true
45 | 
46 | [*]
47 | indent_style = tab
48 | end_of_line = lf
49 | charset = utf-8
50 | trim_trailing_whitespace = true
51 | insert_final_newline = true
52 | ```
53 | 
54 | 
55 | ## Tips
56 | 
57 | ### Trailing whitespace
58 | 
59 | Even though there is a `trim_trailing_whitespace` property. I would still recommend you set `"draw_white_space": "all"` in your Sublime preferences to prevent you from accidentally committing whitespace garbage whenever a project is missing a .editorconfig file.
60 | 
61 | 
62 | ### Show changes
63 | 
64 | This plugin does its changes transparently in the background. I would recommend the excellent [Modific](https://github.com/gornostal/Modific) plugin if you would like to see what changed.
65 | 
66 | 
67 | ## License
68 | 
69 | [MIT License](http://en.wikipedia.org/wiki/MIT_License)
70 | (c) [Sindre Sorhus](http://sindresorhus.com)
71 | 
72 | 
73 | 
74 | [EditorConfig site]: http://editorconfig.org
75 | 


--------------------------------------------------------------------------------