Refactoring with named tuples

noelladsa · noelladsa · commit 66d7b5234fab · 2015-05-28T22:16:45.000-04:00
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -2,7 +2,6 @@
 
 # The MIT License
 #
-# Copyright (c) 2009-2015 the bpython authors.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -39,6 +38,7 @@
 from bpython import inspection
 from bpython import importcompletion
 from bpython import line as lineparts
+from bpython.line import LinePart
 from bpython._py3compat import py3, try_decode
 from bpython.lazyre import LazyReCompile
 
@@ -126,8 +126,8 @@ def format(self, word):
 
     def substitute(self, cursor_offset, line, match):
         """Returns a cursor offset and line with match swapped in"""
-        start, end, word = self.locate(cursor_offset, line)
-        result = start + len(match), line[:start] + match + line[end:]
+        lpart =  self.locate(cursor_offset, line)
+        result = lpart.start + len(match), line[:lpart.start] + match + line[lpart.end:]
         return result
 
     @property
@@ -200,14 +200,13 @@ def matches(self, cursor_offset, line, **kwargs):
         cs = lineparts.current_string(cursor_offset, line)
         if cs is None:
             return None
-        start, end, text = cs
         matches = set()
-        username = text.split(os.path.sep, 1)[0]
+        username = cs.word.split(os.path.sep, 1)[0]
         user_dir = os.path.expanduser(username)
-        for filename in self.safe_glob(os.path.expanduser(text)):
+        for filename in self.safe_glob(os.path.expanduser(cs.word)):
             if os.path.isdir(filename):
                 filename += os.path.sep
-            if text.startswith('~'):
+            if cs.word.startswith('~'):
                 filename = username + filename[len(user_dir):]
             matches.add(filename)
         return matches
@@ -235,25 +234,24 @@ def matches(self, cursor_offset, line, **kwargs):
         r = self.locate(cursor_offset, line)
         if r is None:
             return None
-        text = r[2]
 
         if locals_ is None:
             locals_ = __main__.__dict__
 
-        assert '.' in text
+        assert '.' in r.word
 
-        for i in range(1, len(text) + 1):
-            if text[-i] == '[':
+        for i in range(1, len(r.word) + 1):
+            if r.word[-i] == '[':
                 i -= 1
                 break
-        methodtext = text[-i:]
-        matches = set(''.join([text[:-i], m])
+        methodtext = r.word[-i:]
+        matches = set(''.join([r.word[:-i], m])
                       for m in self.attr_matches(methodtext, locals_))
 
         # TODO add open paren for methods via _callable_prefix (or decide not
         # to) unless the first character is a _ filter out all attributes
         # starting with a _
-        if not text.split('.')[-1].startswith('_'):
+        if not r.word.split('.')[-1].startswith('_'):
             matches = set(match for match in matches
                           if not match.split('.')[-1].startswith('_'))
         return matches
@@ -340,15 +338,14 @@ def matches(self, cursor_offset, line, **kwargs):
         r = self.locate(cursor_offset, line)
         if r is None:
             return None
-        start, end, orig = r
         _, _, dexpr = lineparts.current_dict(cursor_offset, line)
         try:
             obj = safe_eval(dexpr, locals_)
         except EvaluationError:
             return set()
         if isinstance(obj, dict) and obj.keys():
             return set("{0!r}]".format(k) for k in obj.keys()
-                       if repr(k).startswith(orig))
+                       if repr(k).startswith(r.word))
         else:
             return set()
 
@@ -371,8 +368,7 @@ def matches(self, cursor_offset, line, **kwargs):
             return None
         if 'class' not in current_block:
             return None
-        start, end, word = r
-        return set(name for name in MAGIC_METHODS if name.startswith(word))
+        return set(name for name in MAGIC_METHODS if name.startswith(r.word))
 
     def locate(self, current_offset, line):
         return lineparts.current_method_definition_name(current_offset, line)
@@ -392,20 +388,19 @@ def matches(self, cursor_offset, line, **kwargs):
         r = self.locate(cursor_offset, line)
         if r is None:
             return None
-        start, end, text = r
 
         matches = set()
-        n = len(text)
+        n = len(r.word)
         for word in KEYWORDS:
-            if self.method_match(word, n, text):
+            if self.method_match(word, n, r.word):
                 matches.add(word)
         for nspace in (builtins.__dict__, locals_):
             for word, val in iteritems(nspace):
                 word = try_decode(word, 'ascii')
                 # if identifier isn't ascii, don't complete (syntax error)
                 if word is None:
                     continue
-                if self.method_match(word, n, text) and word != "__builtins__":
+                if self.method_match(word, n, r.word) and word != "__builtins__":
                     matches.add(_callable_postfix(val, word))
         return matches
 
@@ -425,14 +420,13 @@ def matches(self, cursor_offset, line, **kwargs):
         r = self.locate(cursor_offset, line)
         if r is None:
             return None
-        start, end, word = r
         if argspec:
             matches = set(name + '=' for name in argspec[1][0]
                           if isinstance(name, string_types) and
-                          name.startswith(word))
+                          name.startswith(r.word))
             if py3:
                 matches.update(name + '=' for name in argspec[1][4]
-                               if name.startswith(word))
+                               if name.startswith(r.word))
         return matches
 
     def locate(self, current_offset, line):
@@ -446,14 +440,13 @@ def matches(self, cursor_offset, line, **kwargs):
         if r is None:
             return None
 
-        start, end, word = r
         attrs = dir('')
         if not py3:
             # decode attributes
             attrs = (att.decode('ascii') for att in attrs)
 
-        matches = set(att for att in attrs if att.startswith(word))
-        if not word.startswith('_'):
+        matches = set(att for att in attrs if att.startswith(r.word))
+        if not r.word.startswith('_'):
             return set(match for match in matches if not match.startswith('_'))
         return matches
 
@@ -513,7 +506,7 @@ def matches(self, cursor_offset, line, **kwargs):
         def locate(self, cursor_offset, line):
             start = self._orig_start
             end = cursor_offset
-            return start, end, line[start:end]
+            return LinePart(start, end, line[start:end])
 
     class MultilineJediCompletion(JediCompletion):
         def matches(self, cursor_offset, line, **kwargs):
diff --git a/bpython/line.py b/bpython/line.py
@@ -5,10 +5,11 @@
 word."""
 
 from itertools import chain
+from collections import namedtuple
 from bpython.lazyre import LazyReCompile
 
-
 current_word_re = LazyReCompile(r'[\w_][\w0-9._]*[(]?')
+LinePart = namedtuple('LinePart', ['start', 'stop', 'word'])
 
 
 def current_word(cursor_offset, line):
@@ -25,7 +26,7 @@ def current_word(cursor_offset, line):
             word = m.group()
     if word is None:
         return None
-    return (start, end, word)
+    return LinePart(start, end, word)
 
 
 current_dict_key_re = LazyReCompile(r'''[\w_][\w0-9._]*\[([\w0-9._(), '"]*)''')
@@ -36,7 +37,7 @@ def current_dict_key(cursor_offset, line):
     matches = current_dict_key_re.finditer(line)
     for m in matches:
         if m.start(1) <= cursor_offset and m.end(1) >= cursor_offset:
-            return (m.start(1), m.end(1), m.group(1))
+            return LinePart(m.start(1), m.end(1), m.group(1))
     return None
 
 
@@ -48,7 +49,7 @@ def current_dict(cursor_offset, line):
     matches = current_dict_re.finditer(line)
     for m in matches:
         if m.start(2) <= cursor_offset and m.end(2) >= cursor_offset:
-            return (m.start(1), m.end(1), m.group(1))
+            return LinePart(m.start(1), m.end(1), m.group(1))
     return None
 
 
@@ -66,7 +67,7 @@ def current_string(cursor_offset, line):
     for m in current_string_re.finditer(line):
         i = 3 if m.group(3) else 4
         if m.start(i) <= cursor_offset and m.end(i) >= cursor_offset:
-            return m.start(i), m.end(i), m.group(i)
+            return LinePart(m.start(i), m.end(i), m.group(i))
     return None
 
 
@@ -89,7 +90,7 @@ def current_object(cursor_offset, line):
             s += m.group(1)
     if not s:
         return None
-    return start, start+len(s), s
+    return LinePart(start, start+len(s), s)
 
 
 current_object_attribute_re = LazyReCompile(r'([\w_][\w0-9_]*)[.]?')
@@ -106,7 +107,7 @@ def current_object_attribute(cursor_offset, line):
     for m in matches:
         if (m.start(1) + start <= cursor_offset and
                 m.end(1) + start >= cursor_offset):
-            return m.start(1) + start, m.end(1) + start, m.group(1)
+            return LinePart(m.start(1) + start, m.end(1) + start, m.group(1))
     return None
 
 
@@ -128,7 +129,7 @@ def current_from_import_from(cursor_offset, line):
     for m in matches:
         if ((m.start(1) < cursor_offset and m.end(1) >= cursor_offset) or
                 (m.start(2) < cursor_offset and m.end(2) >= cursor_offset)):
-            return m.start(1), m.end(1), m.group(1)
+            return LinePart(m.start(1), m.end(1), m.group(1))
     return None
 
 
@@ -153,7 +154,7 @@ def current_from_import_import(cursor_offset, line):
         start = baseline.end() + m.start(1)
         end = baseline.end() + m.end(1)
         if start < cursor_offset and end >= cursor_offset:
-            return start, end, m.group(1)
+            return LinePart(start, end, m.group(1))
     return None
 
 
@@ -175,7 +176,7 @@ def current_import(cursor_offset, line):
         start = baseline.end() + m.start(1)
         end = baseline.end() + m.end(1)
         if start < cursor_offset and end >= cursor_offset:
-            return start, end, m.group(1)
+            return LinePart(start, end, m.group(1))
 
 
 current_method_definition_name_re = LazyReCompile("def\s+([a-zA-Z_][\w]*)")
@@ -186,7 +187,7 @@ def current_method_definition_name(cursor_offset, line):
     matches = current_method_definition_name_re.finditer(line)
     for m in matches:
         if (m.start(1) <= cursor_offset and m.end(1) >= cursor_offset):
-            return m.start(1), m.end(1), m.group(1)
+            return LinePart(m.start(1), m.end(1), m.group(1))
     return None
 
 
@@ -198,7 +199,7 @@ def current_single_word(cursor_offset, line):
     matches = current_single_word_re.finditer(line)
     for m in matches:
         if m.start(1) <= cursor_offset and m.end(1) >= cursor_offset:
-            return m.start(1), m.end(1), m.group(1)
+            return LinePart(m.start(1), m.end(1), m.group(1))
     return None
 
 
@@ -209,7 +210,7 @@ def current_dotted_attribute(cursor_offset, line):
         return None
     start, end, word = match
     if '.' in word[1:]:
-        return start, end, word
+        return LinePart(start, end, word)
 
 
 current_string_literal_attr_re = LazyReCompile(
@@ -223,5 +224,5 @@ def current_string_literal_attr(cursor_offset, line):
     matches = current_string_literal_attr_re.finditer(line)
     for m in matches:
         if m.start(4) <= cursor_offset and m.end(4) >= cursor_offset:
-            return m.start(4), m.end(4), m.group(4)
+            return LinePart(m.start(4), m.end(4), m.group(4))
     return None
