Allow arithmetic symbols in the reader (#119)

* Allow arithmetic symbols in the reader

* A few additional cases

Author: chrisrink10

basilisp/reader.py

@@ -22,7 +22,7 @@
 from basilisp.lang.typing import LispForm, IterableLispForm
 from basilisp.util import Maybe
 
-ns_name_chars = re.compile(r'\w|-|\+|\*|\?|/|\=|\\|!|&|%')
+ns_name_chars = re.compile(r'\w|-|\+|\*|\?|/|\=|\\|!|&|%|>|<')
 begin_num_chars = re.compile('[0-9\-]')
 num_chars = re.compile('[0-9]')
 whitespace_chars = re.compile('[\s,]')
@@ -219,11 +219,14 @@ def _read_namespaced(ctx: ReaderContext, allowed_suffix: Optional[str] = None) -
             reader.next_token()
             if has_ns:
                 raise SyntaxError("Found '/'; expected word character")
-            has_ns = True
-            ns = name
-            name = []
-            if len(ns) == 0:
-                raise SyntaxError("Found ''; expected namespace")
+            elif len(name) == 0:
+                name.append('/')
+            else:
+                if '/' in name:
+                    raise SyntaxError("Found '/' after '/'")
+                has_ns = True
+                ns = name
+                name = []
         elif ns_name_chars.match(token):
             reader.next_token()
             name.append(token)
@@ -236,7 +239,17 @@ def _read_namespaced(ctx: ReaderContext, allowed_suffix: Optional[str] = None) -
         else:
             break
 
-    return None if not has_ns else ''.join(ns), ''.join(name)
+    ns_str = None if not has_ns else ''.join(ns)
+    name_str = ''.join(name)
+
+    # A small exception for the symbol '/ used for division
+    if ns_str is None:
+        if '/' in name_str and name_str != '/':
+            raise SyntaxError("'/' character disallowed in names")
+
+    assert ns_str is None or len(ns_str) > 0
+
+    return ns_str, name_str
 
 
 def _read_coll(ctx: ReaderContext, f: Callable[[Collection[Any]], Union[
@@ -398,7 +411,7 @@ def _read_map(ctx: ReaderContext) -> lmap.Map:
 
 def _read_num(ctx: ReaderContext) -> MaybeNumber:
     """Return a numeric (integer or float) from the input stream."""
-    chars = []
+    chars: List[str] = []
     reader = ctx.reader
     is_float = False
     while True:
@@ -407,6 +420,11 @@ def _read_num(ctx: ReaderContext) -> MaybeNumber:
             following_token = reader.next_token()
             if not begin_num_chars.match(following_token):
                 reader.pushback()
+                try:
+                    for _ in chars:
+                        reader.pushback()
+                except IndexError:
+                    raise SyntaxError("Requested to pushback too many characters onto StreamReader")
                 return _read_sym(ctx)
             chars.append(token)
             continue

tests/reader_test.py

@@ -142,28 +142,47 @@ def test_float():
 
 
 def test_kw():
-    assert read_str_first(":kw") == kw.keyword("kw")
-    assert read_str_first(":kebab-kw") == kw.keyword("kebab-kw")
-    assert read_str_first(":underscore_kw") == kw.keyword("underscore_kw")
-    assert read_str_first(":kw?") == kw.keyword("kw?")
-    assert read_str_first(":+") == kw.keyword("+")
-    assert read_str_first(":?") == kw.keyword("?")
-    assert read_str_first(":=") == kw.keyword("=")
-    assert read_str_first(":!") == kw.keyword("!")
-    assert read_str_first(":-") == kw.keyword("-")
-    assert read_str_first(":*") == kw.keyword("*")
-    assert read_str_first(":*muffs*") == kw.keyword("*muffs*")
-    assert read_str_first(":yay!") == kw.keyword("yay!")
-
-    assert read_str_first(":ns/kw") == kw.keyword("kw", ns="ns")
-    assert read_str_first(":qualified.ns/kw") == kw.keyword(
-        "kw", ns="qualified.ns")
-    assert read_str_first(":really.qualified.ns/kw") == kw.keyword(
-        "kw", ns="really.qualified.ns")
+    assert kw.keyword("kw") == read_str_first(":kw")
+    assert kw.keyword("kebab-kw") == read_str_first(":kebab-kw")
+    assert kw.keyword("underscore_kw") == read_str_first(":underscore_kw")
+    assert kw.keyword("kw?") == read_str_first(":kw?")
+    assert kw.keyword("+") == read_str_first(":+")
+    assert kw.keyword("?") == read_str_first(":?")
+    assert kw.keyword("=") == read_str_first(":=")
+    assert kw.keyword("!") == read_str_first(":!")
+    assert kw.keyword("-") == read_str_first(":-")
+    assert kw.keyword("*") == read_str_first(":*")
+    assert kw.keyword("/") == read_str_first(":/")
+    assert kw.keyword(">") == read_str_first(":>")
+    assert kw.keyword("->") == read_str_first(":->")
+    assert kw.keyword("->>") == read_str_first(":->>")
+    assert kw.keyword("-->") == read_str_first(":-->")
+    assert kw.keyword("--------------->") == read_str_first(":--------------->")
+    assert kw.keyword("<") == read_str_first(":<")
+    assert kw.keyword("<-") == read_str_first(":<-")
+    assert kw.keyword("<--") == read_str_first(":<--")
+    assert kw.keyword("<body>") == read_str_first(":<body>")
+    assert kw.keyword("*muffs*") == read_str_first(":*muffs*")
+    assert kw.keyword("yay!") == read_str_first(":yay!")
+
+    assert kw.keyword("kw", ns="ns") == read_str_first(":ns/kw")
+    assert kw.keyword("kw", ns="qualified.ns") == read_str_first(
+        ":qualified.ns/kw")
+    assert kw.keyword("kw", ns="really.qualified.ns") == read_str_first(
+        ":really.qualified.ns/kw")
+
+    with pytest.raises(reader.SyntaxError):
+        read_str_first("://")
 
     with pytest.raises(reader.SyntaxError):
         read_str_first(":ns//kw")
 
+    with pytest.raises(reader.SyntaxError):
+        read_str_first(":some/ns/sym")
+
+    with pytest.raises(reader.SyntaxError):
+        read_str_first(":ns/sym/")
+
     with pytest.raises(reader.SyntaxError):
         read_str_first(":/kw")
 
@@ -178,31 +197,56 @@ def test_literals():
 
 
 def test_symbol():
-    assert read_str_first("sym") == sym.symbol("sym")
-    assert read_str_first("kebab-sym") == sym.symbol("kebab-sym")
-    assert read_str_first("underscore_sym") == sym.symbol("underscore_sym")
-    assert read_str_first("sym?") == sym.symbol("sym?")
-    assert read_str_first("+") == sym.symbol("+")
-    assert read_str_first("?") == sym.symbol("?")
-    assert read_str_first("=") == sym.symbol("=")
-    assert read_str_first("!") == sym.symbol("!")
-    assert read_str_first("-") == sym.symbol("-")
-    assert read_str_first("*") == sym.symbol("*")
-    assert read_str_first("*muffs*") == sym.symbol("*muffs*")
-    assert read_str_first("yay!") == sym.symbol("yay!")
-
-    assert read_str_first("ns/sym") == sym.symbol("sym", ns="ns")
-    assert read_str_first("qualified.ns/sym") == sym.symbol(
-        "sym", ns="qualified.ns")
-    assert read_str_first("really.qualified.ns/sym") == sym.symbol(
-        "sym", ns="really.qualified.ns")
+    assert sym.symbol("sym") == read_str_first("sym")
+    assert sym.symbol("kebab-sym") == read_str_first("kebab-sym")
+    assert sym.symbol("underscore_sym") == read_str_first("underscore_sym")
+    assert sym.symbol("sym?") == read_str_first("sym?")
+    assert sym.symbol("+") == read_str_first("+")
+    assert sym.symbol("?") == read_str_first("?")
+    assert sym.symbol("=") == read_str_first("=")
+    assert sym.symbol("!") == read_str_first("!")
+    assert sym.symbol("-") == read_str_first("-")
+    assert sym.symbol("*") == read_str_first("*")
+    assert sym.symbol("/") == read_str_first("/")
+    assert sym.symbol(">") == read_str_first(">")
+    assert sym.symbol("->") == read_str_first("->")
+    assert sym.symbol("->>") == read_str_first("->>")
+    assert sym.symbol("-->") == read_str_first("-->")
+    assert sym.symbol("<") == read_str_first("<")
+    assert sym.symbol("<-") == read_str_first("<-")
+    assert sym.symbol("<--") == read_str_first("<--")
+    assert sym.symbol("<body>") == read_str_first("<body>")
+    assert sym.symbol("*muffs*") == read_str_first("*muffs*")
+    assert sym.symbol("yay!") == read_str_first("yay!")
+
+    assert sym.symbol("sym", ns="ns") == read_str_first("ns/sym")
+    assert sym.symbol(
+        "sym", ns="qualified.ns") == read_str_first("qualified.ns/sym")
+    assert sym.symbol(
+        "sym", ns="really.qualified.ns") == read_str_first("really.qualified.ns/sym")
+
+    with pytest.raises(reader.SyntaxError):
+        read_str_first("//")
 
     with pytest.raises(reader.SyntaxError):
         read_str_first("ns//sym")
 
+    with pytest.raises(reader.SyntaxError):
+        read_str_first("some/ns/sym")
+
+    with pytest.raises(reader.SyntaxError):
+        read_str_first("ns/sym/")
+
     with pytest.raises(reader.SyntaxError):
         read_str_first("/sym")
 
+    with pytest.raises(reader.SyntaxError):
+        # This will raise because the default pushback depth of the
+        # reader.StreamReader instance used by the reader is 5, so
+        # we are unable to pushback more - characters consumed by
+        # reader._read_num trying to parse a number.
+        read_str_first("------->")
+
 
 def test_str():
     assert read_str_first('""') == ''