neg 0.2.0 → 0.3.0

data/TODO.txt

@@ -2,13 +2,14 @@
 [o] unconsumed input!
 [o] ^ 0, 1, [ min, max ]
 [o] switch from ^ to * (how * is related to +)
+[o] _ (any)
+[o] chars
 [ ] lookahead present/absent
   ~ x --> present
   ! x --> absent
-[ ] any
-[ ] chars
 [ ] blankslate
-
+[ ] drop UnconsumedInput, replace with regular [ false, ... ] output
+[ ] x * '?' / x * '+' / x * '*' as shortcuts
 
   `x` + [.]
   `x` + [a-z]

data/lib/neg/parser.rb

@@ -29,9 +29,13 @@ require 'neg/input'
 module Neg
 
   class UnconsumedInputError < StandardError; end
+  class ParseError < StandardError; end
 
   class Parser
 
+    def self.`(s)      ; StringParser.new(s); end
+    def self._(c=nil)  ; CharacterParser.new(c); end
+
     def self.method_missing(m, *args)
 
       return super if args.any?
@@ -53,21 +57,11 @@ module Neg
 
       raise UnconsumedInputError.new(
         "remaining: #{i.remains.inspect}"
-      ) if result[1] && ( ! i.eoi?)
+      ) if result[2] && ( ! i.eoi?)
 
       result
     end
 
-    def self.`(s)
-
-      StringParser.new(s)
-    end
-
-    def self._(c=nil)
-
-      CharacterParser.new(c)
-    end
-
     def self.to_s
 
       s = [ "#{name}:" ]
@@ -96,36 +90,23 @@ module Neg
 
     class SubParser
 
-      def +(pa)
-
-        SequenceParser.new(self, pa)
-      end
-
-      def |(pa)
-
-        AlternativeParser.new(self, pa)
-      end
-
-      def [](name)
-
-        NonTerminalParser.new(name.to_s, self)
-      end
-
-      def *(range)
-
-        RepetitionParser.new(self, range)
-      end
+      def +(pa)     ; SequenceParser.new(self, pa); end
+      def |(pa)     ; AlternativeParser.new(self, pa); end
+      def [](name)  ; NonTerminalParser.new(name.to_s, self); end
+      def *(range)  ; RepetitionParser.new(self, range); end
+      def ~         ; LookaheadParser.new(self, true); end
+      def -@        ; LookaheadParser.new(self, false); end
 
       def parse(input_or_string)
 
         input = Neg::Input(input_or_string)
         start = input.position
 
-        success, result = do_parse(input)
+        success, result, children = do_parse(input)
 
         input.rewind(start) unless success
 
-        [ nil, success, start, result ]
+        [ nil, start, success, result, children ]
       end
     end
 
@@ -142,9 +123,34 @@ module Neg
         @child = pa
       end
 
+#      def reduce(children_results)
+#
+#        children_results.collect { |cr|
+#          if cr[0] && cr[0] != :digit
+#            false
+#          elsif cr[2]
+#            cr[3] ? cr[3] : reduce(cr[4])
+#          else
+#            nil
+#          end
+#        }.flatten.compact
+#      end
+
       def do_parse(i)
 
-        @child.do_parse(i)
+        raise ParseError.new("\"#{@name}\" is missing") if @child.nil?
+
+        r = @child.do_parse(i)
+
+        return r
+
+#        return r if r[0] == false
+#
+#        report = reduce(r[2])
+#
+#        return r if report.include?(false)
+#
+#        [ true, report.join, [] ]
       end
 
       def parse(input_or_string)
@@ -189,15 +195,15 @@ module Neg
 
         loop do
           r = @child.parse(i)
-          break if ! r[1] && rs.size >= @min && (@max.nil? || rs.size <= @max)
+          break if ! r[2] && rs.size >= @min && (@max.nil? || rs.size <= @max)
           rs << r
-          break if ! r[1]
+          break if ! r[2]
           break if rs.size == @max
         end
 
-        success = (rs.empty? || rs.last[1]) && (rs.size >= @min)
+        success = (rs.empty? || rs.last[2]) && (rs.size >= @min)
 
-        [ success, rs ]
+        [ success, nil, rs ]
       end
 
       def to_s(parent=nil)
@@ -216,9 +222,9 @@ module Neg
       def do_parse(i)
 
         if (s = i.read(@s.length)) == @s
-          [ true, @s ]
+          [ true, @s, [] ]
         else
-          [ false, "expected #{@s.inspect}, got #{s.inspect}" ]
+          [ false, "expected #{@s.inspect}, got #{s.inspect}", [] ]
         end
       end
 
@@ -239,9 +245,9 @@ module Neg
       def do_parse(i)
 
         if (s = i.read(1)).match(@r)
-          [ true, s ]
+          [ true, s, [] ]
         else
-          [ false, "#{s.inspect} doesn't match #{@c.inspect}" ]
+          [ false, "#{s.inspect} doesn't match #{@c.inspect}", [] ]
         end
       end
 
@@ -275,10 +281,10 @@ module Neg
         @children.each do |c|
 
           results << c.parse(i)
-          break unless results.last[1]
+          break unless results.last[2]
         end
 
-        [ results.last[1], results ]
+        [ results.last[2], nil, results ]
       end
 
       def to_s(parent=nil)
@@ -298,14 +304,14 @@ module Neg
 
       def do_parse(i)
 
-        result = []
+        results = []
 
         @children.each { |c|
-          result << c.parse(i)
-          break if result.last[1]
+          results << c.parse(i)
+          break if results.last[2]
         }
 
-        [ result.last[1], result ]
+        [ results.last[2], nil, results ]
       end
 
       def to_s(parent=nil)
@@ -313,6 +319,41 @@ module Neg
         "(#{@children.collect { |c| c.to_s(self) }.join(' | ')})"
       end
     end
+
+    class LookaheadParser < SubParser
+
+      def initialize(child, presence)
+
+        @child = child
+        @presence = presence
+      end
+
+      def do_parse(i)
+
+        start = i.position
+
+        r = @child.parse(i)
+        i.rewind(start)
+
+        success = r[2]
+        success = ! success if ! @presence
+
+        result = if success
+          nil
+        else
+          [
+            @child.to_s(nil), 'is not', @presence ? 'present' : 'absent'
+          ].join(' ')
+        end
+
+        [ success, result, [ r ] ]
+      end
+
+      def to_s(parent=nil)
+
+        "#{@presence ? '~' : '-'}#{@child.to_s(self)}"
+      end
+    end
   end
 end
 

data/lib/neg/version.rb

@@ -25,6 +25,6 @@
 
 module Neg
 
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end
 

data/spec/parser_alternative_spec.rb

@@ -11,24 +11,24 @@ describe Neg::Parser::AlternativeParser do
   it 'parses' do
 
     AltParser.parse('x').should ==
-      [ :text, true, [ 0, 1, 1 ], [
-        [ nil, true, [ 0, 1, 1 ], 'x' ] ] ]
+      [ :text, [ 0, 1, 1 ], true, nil, [
+        [ nil, [ 0, 1, 1 ], true, 'x', [] ] ] ]
   end
 
   it 'parses (2nd alternative succeeds)' do
 
     AltParser.parse('y').should ==
-      [ :text, true, [ 0, 1, 1 ], [
-        [ nil, false, [ 0, 1, 1 ], 'expected "x", got "y"' ],
-        [ nil, true, [ 0, 1, 1 ], 'y' ] ] ]
+      [ :text, [ 0, 1, 1 ], true, nil, [
+        [ nil, [ 0, 1, 1 ], false, 'expected "x", got "y"', [] ],
+        [ nil, [ 0, 1, 1 ], true, 'y', [] ] ] ]
   end
 
   it 'fails gracefully' do
 
     AltParser.parse('z').should ==
-      [ :text, false, [ 0, 1, 1 ], [
-        [ nil, false, [ 0, 1, 1 ], 'expected "x", got "z"' ],
-        [ nil, false, [ 0, 1, 1 ], 'expected "y", got "z"' ] ] ]
+      [ :text, [ 0, 1, 1 ], false, nil, [
+        [ nil, [ 0, 1, 1 ], false, 'expected "x", got "z"', [] ],
+        [ nil, [ 0, 1, 1 ], false, 'expected "y", got "z"', [] ] ] ]
   end
 
   it 'goes beyond two elements' do

data/spec/parser_character_spec.rb

@@ -16,20 +16,22 @@ describe Neg::Parser::CharacterParser do
 
       parser.parse('xy').should ==
         [ :text,
-          true,
           [ 0, 1, 1 ],
-          [ [ nil, true, [ 0, 1, 1 ], "x" ],
-            [ nil, true, [ 1, 1, 2 ], "y" ] ] ]
+          true,
+          nil,
+          [ [ nil, [ 0, 1, 1 ], true, "x", [] ],
+            [ nil, [ 1, 1, 2 ], true, "y", [] ] ] ]
     end
 
     it 'fails gracefully' do
 
       parser.parse('x').should ==
         [ :text,
-          false,
           [ 0, 1, 1],
-          [ [ nil, true, [ 0, 1, 1 ], "x" ],
-            [ nil, false, [ 1, 1, 2 ], "\"\" doesn't match nil" ] ] ]
+          false,
+          nil,
+          [ [ nil, [ 0, 1, 1 ], true, "x", [] ],
+            [ nil, [ 1, 1, 2 ], false, "\"\" doesn't match nil", [] ] ] ]
     end
 
     it 'is rendered correctly via #to_s' do
@@ -54,19 +56,43 @@ describe Neg::Parser::CharacterParser do
 
       parser.parse('tel:0-99').should ==
         [ :text,
-          true,
           [ 0, 1, 1 ],
-          [ [ nil, true, [ 0, 1, 1 ], "tel:" ],
+          true,
+          nil,
+          [ [ nil, [ 0, 1, 1 ], true, "tel:", [] ],
             [ nil,
+              [ 4, 1, 5 ],
               true,
+              nil,
+              [ [ nil, [ 4, 1, 5 ], true, "0", [] ],
+                [ nil, [ 5, 1, 6 ], true, "-", [] ],
+                [ nil, [ 6, 1, 7 ], true, "9", [] ],
+                [ nil, [ 7, 1, 8 ], true, "9", [] ] ] ] ] ]
+    end
+
+    it 'fails gracefully' do
+
+      parser.parse('tel:a-bc').should ==
+        [ :text,
+          [ 0, 1, 1 ],
+          false,
+          nil,
+          [ [ nil, [ 0, 1, 1 ], true, "tel:", [] ],
+            [ nil,
               [ 4, 1, 5 ],
-              [ [ nil, true, [ 4, 1, 5 ], "0" ],
-                [ nil, true, [ 5, 1, 6 ], "-" ],
-                [ nil, true, [ 6, 1, 7 ], "9" ],
-                [ nil, true, [ 7, 1, 8 ], "9" ] ] ] ] ]
+              false,
+              nil,
+              [ [ nil, [ 4, 1, 5 ], false, "\"a\" doesn't match \"0-9-\"", [] ] ] ] ] ]
     end
 
-    it 'fails gracefully'
+    it 'is rendered correctly via #to_s' do
+
+      parser.to_s.strip.should == %q{
+:
+  text == (`tel:` + _("0-9-") * 1)
+  root: text
+      }.strip
+    end
   end
 end
 

data/spec/parser_lookahead_parser_spec.rb

@@ -0,0 +1,126 @@
+
+require 'spec_helper'
+
+
+describe Neg::Parser::LookaheadParser do
+
+  context '~x (presence)' do
+
+    let(:parser) {
+      Class.new(Neg::Parser) do
+        root == x + z
+        x == `x` + ~`z`
+        z == `z`
+      end
+    }
+
+    it 'parses' do
+
+      parser.parse('xz').should ==
+        [ :root,
+          [ 0, 1, 1 ],
+          true,
+          nil,
+          [ [ :x,
+              [ 0, 1, 1 ],
+              true,
+              nil,
+              [ [ nil, [ 0, 1, 1 ], true, "x", [] ],
+                [ nil, [ 1, 1, 2 ], true, nil, [
+                  [ nil, [ 1, 1, 2 ], true, "z", [] ] ] ] ] ],
+            [ :z, [ 1, 1, 2 ], true, "z", [] ] ] ]
+    end
+
+    it 'fails gracefully' do
+
+      parser.parse('xx').should ==
+        [:root,
+         [0, 1, 1],
+         false,
+         nil,
+         [[:x,
+           [0, 1, 1],
+           false,
+           nil,
+           [[nil, [0, 1, 1], true, "x", []],
+            [nil,
+             [1, 1, 2],
+             false,
+             "`z` is not present",
+             [[nil, [1, 1, 2], false, "expected \"z\", got \"x\"", []]]]]]]]
+    end
+
+    it 'is rendered correctly via #to_s' do
+
+      parser.to_s.strip.should == %q{
+:
+  root == (x + z)
+  x == (`x` + ~`z`)
+  z == `z`
+  root: root
+      }.strip
+    end
+  end
+
+  context '-x (absence)' do
+
+    let(:parser) {
+      Class.new(Neg::Parser) do
+        root == x + z
+        x == `x` + -`y`
+        z == `z`
+      end
+    }
+
+    it 'parses' do
+
+      parser.parse('xz').should ==
+        [ :root,
+          [ 0, 1, 1 ],
+          true,
+          nil,
+          [ [ :x,
+              [ 0, 1, 1 ],
+              true,
+              nil,
+              [ [ nil, [ 0, 1, 1 ], true, "x", [] ],
+                [ nil,
+                  [ 1, 1, 2 ],
+                  true,
+                  nil,
+                  [ [ nil, [ 1, 1, 2 ], false, "expected \"y\", got \"z\"", [] ] ] ] ] ],
+            [ :z, [ 1, 1, 2 ], true, "z", [] ] ] ]
+    end
+
+    it 'fails gracefully' do
+
+      parser.parse('xy').should ==
+        [:root,
+         [0, 1, 1],
+         false,
+         nil,
+         [[:x,
+           [0, 1, 1],
+           false,
+           nil,
+           [[nil, [0, 1, 1], true, "x", []],
+            [nil,
+             [1, 1, 2],
+             false,
+             "`y` is not absent",
+             [[nil, [1, 1, 2], true, "y", []]]]]]]]
+    end
+
+    it 'is rendered correctly via #to_s' do
+
+      parser.to_s.strip.should == %q{
+:
+  root == (x + z)
+  x == (`x` + -`y`)
+  z == `z`
+  root: root
+      }.strip
+    end
+  end
+end
+

data/spec/parser_non_terminal_spec.rb

@@ -14,10 +14,10 @@ describe Neg::Parser::NonTerminalParser do
         z    == `zz` | `z`
       end
 
-      parser.parse('x')[1].should == true
-      parser.parse('z')[1].should == true
-      parser.parse('zz')[1].should == true
-      parser.parse('y')[1].should == false
+      parser.parse('x')[2].should == true
+      parser.parse('z')[2].should == true
+      parser.parse('zz')[2].should == true
+      parser.parse('y')[2].should == false
     end
 
     it 'sets its name in the result (as a Symbol)' do
@@ -27,9 +27,9 @@ describe Neg::Parser::NonTerminalParser do
       end
 
       parser.parse('X').should ==
-        [ :x, true, [ 0, 1, 1 ], [
-          [ nil, false, [ 0, 1, 1 ], "expected \"x\", got \"X\"" ],
-          [ nil, true, [ 0, 1, 1 ], "X" ] ] ]
+        [ :x, [ 0, 1, 1 ], true, nil, [
+          [ nil, [ 0, 1, 1 ], false, "expected \"x\", got \"X\"", [] ],
+          [ nil, [ 0, 1, 1 ], true, "X", [] ] ] ]
     end
 
     it 'is rendered as x when on the right side' do
@@ -48,6 +48,16 @@ describe Neg::Parser::NonTerminalParser do
   root: word
       }.strip
     end
+
+    it 'flips burgers' do
+
+      parser = Class.new(Neg::Parser) do
+        sentence == (word + ` `) * 1
+        word  == _("a-z") * 1
+      end
+
+      pp parser.parse("ab cd ")
+    end
   end
 
   context '...["name"]' do
@@ -74,11 +84,14 @@ describe Neg::Parser::NonTerminalParser do
 
       parser.parse('car_cluj').should ==
         [ :transportation,
+          [ 0, 1, 1 ],
           true,
-          [ 0, 1, 1],
-          [ [ 'vehicle', true, [ 0, 1, 1 ], [ [ nil, true, [ 0, 1, 1 ], 'car' ] ] ],
-          [ nil, true, [ 3, 1, 4 ], '_'],
-          [ 'city', true, [ 4, 1, 5 ], [ [ nil, true, [ 4, 1, 5 ], 'cluj' ] ] ] ] ]
+          nil,
+          [ [ 'vehicle', [ 0, 1, 1 ], true, nil, [
+            [ nil, [ 0, 1, 1 ], true, 'car', [] ] ] ],
+          [ nil, [ 3, 1, 4 ], true, '_', [] ],
+          [ 'city', [ 4, 1, 5 ], true, nil, [
+            [ nil, [ 4, 1, 5 ], true, 'cluj', [] ] ] ] ] ]
     end
   end
 end

data/spec/parser_repetition_spec.rb

@@ -15,7 +15,7 @@ describe Neg::Parser::RepetitionParser do
     it 'parses the empty string' do
 
       parser.parse('').should ==
-        [ :text, true, [ 0, 1, 1 ], [] ]
+        [ :text, [ 0, 1, 1 ], true, nil, [] ]
     end
 
     it 'fails gracefully' do
@@ -48,16 +48,16 @@ describe Neg::Parser::RepetitionParser do
     it 'parses the empty string' do
 
       parser.parse('').should ==
-        [ :text, true, [ 0, 1, 1 ], [] ]
+        [ :text, [ 0, 1, 1 ], true, nil, [] ]
     end
 
     it 'parses' do
 
       parser.parse('xxx').should ==
-        [ :text, true, [ 0, 1, 1 ], [
-          [ nil, true, [ 0, 1, 1 ], 'x' ],
-          [ nil, true, [ 1, 1, 2 ], 'x' ],
-          [ nil, true, [ 2, 1, 3 ], 'x' ] ] ]
+        [ :text, [ 0, 1, 1 ], true, nil, [
+          [ nil, [ 0, 1, 1 ], true, 'x', [] ],
+          [ nil, [ 1, 1, 2 ], true, 'x', [] ],
+          [ nil, [ 2, 1, 3 ], true, 'x', [] ] ] ]
     end
 
     it 'fails gracefully' do
@@ -81,18 +81,18 @@ describe Neg::Parser::RepetitionParser do
     it 'parses' do
 
       parser.parse('xxx').should ==
-        [ :text, true, [ 0, 1, 1 ], [
-          [ nil, true, [ 0, 1, 1 ], 'x' ],
-          [ nil, true, [ 1, 1, 2 ], 'x' ],
-          [ nil, true, [ 2, 1, 3 ], 'x' ] ] ]
+        [ :text, [ 0, 1, 1 ], true, nil, [
+          [ nil, [ 0, 1, 1 ], true, 'x', [] ],
+          [ nil, [ 1, 1, 2 ], true, 'x', [] ],
+          [ nil, [ 2, 1, 3 ], true, 'x', [] ] ] ]
     end
 
     it 'fails gracefully' do
 
       parser.parse('x').should ==
-        [ :text, false, [ 0, 1, 1 ], [
-          [ nil, true, [ 0, 1, 1 ], 'x' ],
-          [ nil, false, [ 1, 1, 2 ], 'expected "x", got ""' ] ] ]
+        [ :text, [ 0, 1, 1 ], false, nil, [
+          [ nil, [ 0, 1, 1 ], true, 'x', [] ],
+          [ nil, [ 1, 1, 2 ], false, 'expected "x", got ""', [] ] ] ]
     end
   end
 
@@ -107,19 +107,19 @@ describe Neg::Parser::RepetitionParser do
     it 'parses' do
 
       parser.parse('xxx').should ==
-        [ :text, true, [ 0, 1, 1 ], [
-          [ nil, true, [ 0, 1, 1 ], 'x' ],
-          [ nil, true, [ 1, 1, 2 ], 'x' ],
-          [ nil, true, [ 2, 1, 3 ], 'x' ] ] ]
+        [ :text, [ 0, 1, 1 ], true, nil, [
+          [ nil, [ 0, 1, 1 ], true, 'x', [] ],
+          [ nil, [ 1, 1, 2 ], true, 'x', [] ],
+          [ nil, [ 2, 1, 3 ], true, 'x', [] ] ] ]
     end
 
     it 'fails gracefully' do
 
       parser.parse('xx').should ==
-        [ :text, false, [ 0, 1, 1 ], [
-          [ nil, true, [ 0, 1, 1 ], 'x' ],
-          [ nil, true, [ 1, 1, 2 ], 'x' ],
-          [ nil, false, [ 2, 1, 3 ], 'expected "x", got ""' ] ] ]
+        [ :text, [ 0, 1, 1 ], false, nil, [
+          [ nil, [ 0, 1, 1 ], true, 'x', [] ],
+          [ nil, [ 1, 1, 2 ], true, 'x', [] ],
+          [ nil, [ 2, 1, 3 ], false, 'expected "x", got ""', [] ] ] ]
     end
 
     it 'fails gracefully (unconsumed input)' do

data/spec/parser_sequence_spec.rb

@@ -11,17 +11,17 @@ describe Neg::Parser::SequenceParser do
   it 'parses' do
 
     SeqParser.parse('xy').should ==
-      [ :text, true, [ 0, 1, 1 ], [
-        [ nil, true, [ 0, 1, 1 ], 'x' ],
-        [ nil, true, [ 1, 1, 2 ], 'y' ] ] ]
+      [ :text, [ 0, 1, 1 ], true, nil, [
+        [ nil, [ 0, 1, 1 ], true, 'x', [] ],
+        [ nil, [ 1, 1, 2 ], true, 'y', [] ] ] ]
   end
 
   it 'fails gracefully' do
 
     SeqParser.parse('xx').should ==
-      [ :text, false, [ 0, 1, 1 ], [
-        [ nil, true, [ 0, 1, 1 ], 'x' ],
-        [ nil, false, [ 1, 1, 2 ], 'expected "y", got "x"' ] ] ]
+      [ :text, [ 0, 1, 1 ], false, nil, [
+        [ nil, [ 0, 1, 1 ], true, 'x', [] ],
+        [ nil, [ 1, 1, 2 ], false, 'expected "y", got "x"', [] ] ] ]
   end
 
   it 'goes beyond two elements' do
@@ -48,18 +48,21 @@ describe Neg::Parser::SequenceParser do
 
     parser.parse('pool').should ==
       [ :word,
-        true,
         [ 0, 1, 1 ],
+        true,
+        nil,
         [ [ :poodle,
-            false,
             [ 0, 1, 1 ],
-            [ [ nil, true, [ 0, 1, 1 ], "poo" ],
-              [ nil, false, [ 3, 1, 4 ], "expected \"dle\", got \"l\"" ] ] ],
+            false,
+            nil,
+            [ [ nil, [ 0, 1, 1 ], true, "poo", [] ],
+              [ nil, [ 3, 1, 4 ], false, "expected \"dle\", got \"l\"", [] ] ] ],
           [ :pool,
+            [ 0, 1, 1 ],
             true,
-            [ 0, 1, 1],
-            [ [ nil, true, [ 0, 1, 1 ], "poo" ],
-              [ nil, true, [ 3, 1, 4 ], "l" ] ] ] ] ]
+            nil,
+            [ [ nil, [ 0, 1, 1 ], true, "poo", [] ],
+              [ nil, [ 3, 1, 4 ], true, "l", [] ] ] ] ] ]
   end
 end
 

data/spec/parser_string_spec.rb

@@ -11,7 +11,7 @@ describe Neg::Parser::StringParser do
       parser = Neg::Parser::StringParser.new('xxx')
 
       parser.parse('xxx').should ==
-        [ nil, true, [ 0, 1, 1 ], 'xxx' ]
+        [ nil, [ 0, 1, 1 ], true, 'xxx', [] ]
     end
 
     it 'fails gracefully' do
@@ -19,7 +19,7 @@ describe Neg::Parser::StringParser do
       parser = Neg::Parser::StringParser.new('xxx')
 
       parser.parse('yyy').should ==
-        [ nil, false, [ 0, 1, 1 ], 'expected "xxx", got "yyy"' ]
+        [ nil, [ 0, 1, 1 ], false, 'expected "xxx", got "yyy"', [] ]
     end
   end
 
@@ -34,7 +34,7 @@ describe Neg::Parser::StringParser do
     it 'parses an exact string' do
 
       parser.parse('x').should ==
-        [ :root, true, [ 0, 1, 1 ], 'x' ]
+        [ :root, [ 0, 1, 1 ], true, 'x', [] ]
     end
   end
 end

data/spec/sample_json_parser_spec.rb

@@ -6,23 +6,7 @@ describe 'sample JSON parser' do
 
   class JsonParser < Neg::Parser
 
-    #rule(:spaces) { match('\s').repeat(1) }
-    #rule(:spaces?) { spaces.maybe }
-
     #rule(:comma) { spaces? >> str(',') >> spaces? }
-    #rule(:digit) { match('[0-9]') }
-
-    #rule(:number) {
-    #  (
-    #    str('-').maybe >> (
-    #      str('0') | (match('[1-9]') >> digit.repeat)
-    #    ) >> (
-    #      str('.') >> digit.repeat(1)
-    #    ).maybe >> (
-    #      match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
-    #    ).maybe
-    #  ).as(:number)
-    #}
 
     #rule(:array) {
     #  str('[') >> spaces? >>
@@ -46,31 +30,32 @@ describe 'sample JSON parser' do
 
     #rule(:attribute) { (entry | value).as(:attribute) }
 
-    json == spaces? + value + spaces?
-
-    value == string | number | object | array | btrue | bfalse | null
-
-    btrue == `true`
-    bfalse == `false`
-    null == `null`
-
-    # TODO: continue here with "string"
-
     #rule(:string) {
     #  str('"') >> (
-    #    str('\\') >> any | str('"').absent? >> any
+    #    #str('\\') >> any | str('"').absent? >> any
+    #    #(str('\\') | str('"').absent?) >> any
+    #    (str('\\') >> any | match('[^"]')
     #  ).repeat.as(:string) >> str('"')
     #}
 
-    #rule(:value) {
-    #  string | number |
-    #  object | array |
-    #  str('true').as(:true) | str('false').as(:false) |
-    #  str('null').as(:null)
-    #}
+    json == spaces? + value + spaces?
+
+    spaces? == _(" \t") * 0
 
-    #rule(:top) { spaces? >> value >> spaces? }
-    #root(:top)
+    #value == string | number | object | array | btrue | bfalse | null
+    value == number | btrue | bfalse | null
+
+    digit == _("0-9")
+
+    number ==
+      `-` * -1 +
+      (`0` | (_("1-9") + digit * 0)) +
+      (`.` + digit * 1) * -1 +
+      (_("eE") + _("+-") * -1 + digit * 1) * -1
+
+    btrue == `true`
+    bfalse == `false`
+    null == `null`
   end
 
   it 'flips burgers' do
@@ -79,5 +64,23 @@ describe 'sample JSON parser' do
     puts JsonParser
     puts '-' * 80
   end
+
+  it 'parses "false"' do
+
+    pp JsonParser.parse("false")
+    JsonParser.parse("false")[2].should == true
+  end
+
+  it 'parses "13"' do
+
+    pp JsonParser.parse("13")
+    JsonParser.parse("13")[2].should == true
+  end
+
+  it 'parses "-12"' do
+
+    pp JsonParser.parse("-12")
+    JsonParser.parse("-12")[2].should == true
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: neg
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-16 00:00:00.000000000 Z
+date: 2012-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -58,6 +58,7 @@ files:
 - spec/input_spec.rb
 - spec/parser_alternative_spec.rb
 - spec/parser_character_spec.rb
+- spec/parser_lookahead_parser_spec.rb
 - spec/parser_non_terminal_spec.rb
 - spec/parser_repetition_spec.rb
 - spec/parser_sequence_spec.rb