Test edge case for current word attribute

thomasballinger · thomasballinger · commit 8254e8704bb3 · 2015-12-14T17:39:19.000-05:00
diff --git a/bpython/line.py b/bpython/line.py
@@ -3,10 +3,16 @@
 All functions take cursor offset from the beginning of the line and the line of
 Python code, and return None, or a tuple of the start index, end index, and the
 word."""
+from __future__ import unicode_literals
+
+import re
 
 from itertools import chain
 from collections import namedtuple
+from pygments.token import Token
+
 from bpython.lazyre import LazyReCompile
+from bpython._py3compat import PythonLexer, py3
 
 current_word_re = LazyReCompile(r'[\w_][\w0-9._]*[(]?')
 LinePart = namedtuple('LinePart', ['start', 'stop', 'word'])
@@ -93,7 +99,7 @@ def current_object(cursor_offset, line):
     return LinePart(start, start+len(s), s)
 
 
-current_object_attribute_re = LazyReCompile(r'([\w_][\w0-9_]*)[.]?')
+current_object_attribute_re = LazyReCompile(r'([\w_][\w0-9_]*)')
 
 
 def current_object_attribute(cursor_offset, line):
@@ -264,14 +270,40 @@ def current_indexed_member_access_member(cursor_offset, line):
         if m.start(3) <= cursor_offset and m.end(3) >= cursor_offset:
             return LinePart(m.start(3), m.end(3), m.group(3))
 
+current_simple_expression_re = LazyReCompile(
+    r'''([a-zA-Z_][\w.]*)\[([a-zA-Z0-9_"']+)\]\.([\w.]*)''')
+
+def _current_simple_expression(cursor_offset, line):
+    """
+    Returns the current "simple expression" being attribute accessed
+
+    build asts from with increasing numbers of characters.
+    Find the biggest valid ast.
+    Once our attribute access is a subtree, stop
+
+
+    """
+    for i in range(cursor):
+        pass
+
+
 def current_simple_expression(cursor_offset, line):
     """The expression attribute lookup being performed on
 
     e.g. <foo[0][1].bar>.ba|z
     A "simple expression" contains only . lookup and [] indexing."""
 
+
 def current_simple_expression_attribute(cursor_offset, line):
     """The attribute being looked up on a simple expression
 
     e.g. foo[0][1].bar.<ba|z>
     A "simple expression" contains only . lookup and [] indexing."""
+
+
+
+
+
+
+
+
diff --git a/bpython/simpleeval.py b/bpython/simpleeval.py
@@ -81,3 +81,33 @@ def safe_getitem(obj, index):
     if type(obj) in (list, tuple, dict, bytes) + string_types:
         return obj[index]
     raise ValueError('unsafe to lookup on object of type %s' % (type(obj), ))
+
+
+class AttributeSearcher(NodeVisitor):
+    """Search for a Load of an Attribute at col_offset"""
+    def visit_attribute(self, node):
+        print node.attribute
+
+def _current_simple_expression(cursor_offset, line):
+    """
+    Returns the current "simple expression" being attribute accessed
+
+    build asts from with increasing numbers of characters.
+    Find the biggest valid ast.
+    Once our attribute access is a subtree, stop
+
+
+    """
+
+    # in case attribute is blank, e.g. foo.| -> foo.xxx|
+    temp_line = line[:cursor_offset] + 'xxx' + line[cursor_offset:]
+    temp_cursor = cursor_offset + 3
+
+    for i in range(temp_cursor-1, -1, -1):
+        try:
+            tree = parse(temp_line[i:temp_cursor])
+        except SyntaxError:
+            return None
+        
+
+
diff --git a/bpython/test/test_line_properties.py b/bpython/test/test_line_properties.py
@@ -225,6 +225,11 @@ def test_simple(self):
         self.assertAccess('stuff[asdf[asd|fg]')
         self.assertAccess('Object.attr1.<|attr2>')
         self.assertAccess('Object.<attr1|>.attr2')
+        self.assertAccess('Object.<attr1|>.attr2')
+
+    def test_after_dot(self):
+        self.assertAccess('Object.<attr1|>.')
+        self.assertAccess('Object.attr1.|')
 
 
 class TestCurrentFromImportFrom(LineTestCase):
@@ -343,42 +348,6 @@ def test_simple(self):
         self.assertAccess('abc[def].gh |i')
         self.assertAccess('abc[def]|')
 
-@unittest.skip("TODO")
-class TestCurrentSimpleExpression(LineTestCase):
-    def setUp(self):
-        self.func = current_simple_expression
-
-    def test_only_dots(self):
-        self.assertAccess('<Object>.attr1|')
-        self.assertAccess('<Object>.|')
-        self.assertAccess('Object|')
-        self.assertAccess('Object|.')
-        self.assertAccess('<Object>.|')
-        self.assertAccess('<Object.attr1>.attr2|')
-        self.assertAccess('<Object>.att|r1.attr2')
-        self.assertAccess('stuff[stuff] + {123: 456} + <Object.attr1>.attr2|')
-        self.assertAccess('stuff[asd|fg]')
-        self.assertAccess('stuff[asdf[asd|fg]')
-
-    def test_with_brackets(self):
-        self.assertAccess('<foo[a]>.ba|r')
-        self.assertAccess('<foo[a]>.ba|r baz[qux]xyzzy')
-        self.assertAccess('foo[<bar[baz]>.qux|].xyzzy')
-        self.assertAccess('<foo[bar[baz].qux]>.xyzzy|')
-        self.assertAccess('foo[bar[baz].qux].xyzzy, <a>.b|')
-        self.assertAccess('foo[bar[<baz>.|')
-        self.assertAccess('foo[bar[<baz>.|] + 1].qux')
-
-    def test_cases_disallowed_by_simple_eval(self):
-        # These are allowed for now, but could be changed.
-        # for example, function calls are not allowed in simple expressions but
-        # seem like they'd be a pain to weed out so we catch them in the next step."""
-        self.assertAccess('foo().bar|')
-        self.assertAccess('foo[bar(a, b)].baz|')
-        self.assertAccess('foo(a, b).bar|')
-        self.assertAccess('<(1 + 1)>.bar|')
-        self.assertAccess('<(1 + 1 - foo.bar()[1])>.baz|')
-
 
 if __name__ == '__main__':
     unittest.main()
