neg 0.3.0 → 1.0.0

data/lib/neg/translator.rb

@@ -0,0 +1,76 @@
+#--
+# Copyright (c) 2012-2013, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Neg
+
+  class Translator
+
+    def self.on(node_name, &block)
+
+      @rules ||=
+        { nil => lambda { |n| n.results.empty? ? throw(nil) : n.results } }
+          #
+          # the default rule for anonymous nodes...
+
+      @rules[node_name] = block
+    end
+
+    def self.translate(parse_tree)
+
+      results =
+        parse_tree[4].each_with_object([]) { |node, a|
+          catch(nil) { a << translate(node) }
+        }
+
+      apply(parse_tree, results)
+    end
+
+    def self.apply(parse_tree, results)
+
+      rule = (@rules || {})[parse_tree[0]]
+
+      rule ? rule.call(Node.new(parse_tree, results)) : results
+    end
+
+    class Node
+
+      attr_reader :parse_tree, :results
+
+      def initialize(parse_tree, results)
+
+        @parse_tree = parse_tree
+        @results = results
+      end
+
+      def position;  @parse_tree[1]; end
+      def offset;    @parse_tree[1][0]; end
+      def line;      @parse_tree[1][1]; end
+      def column;    @parse_tree[1][2]; end
+
+      def result;    @parse_tree[3]; end
+    end
+  end
+end
+

data/lib/neg/version.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2012-2012, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2012-2013, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -25,6 +25,6 @@
 
 module Neg
 
-  VERSION = '0.3.0'
+  VERSION = '1.0.0'
 end
 

data/spec/parser_alternative_spec.rb

@@ -11,14 +11,19 @@ describe Neg::Parser::AlternativeParser do
   it 'parses' do
 
     AltParser.parse('x').should ==
-      [ :text, [ 0, 1, 1 ], true, nil, [
-        [ nil, [ 0, 1, 1 ], true, 'x', [] ] ] ]
+      [ :text, [ 0, 1, 1 ], true, 'x', [] ]
   end
 
   it 'parses (2nd alternative succeeds)' do
 
     AltParser.parse('y').should ==
-      [ :text, [ 0, 1, 1 ], true, nil, [
+      [ :text, [ 0, 1, 1 ], true, 'y', [] ]
+  end
+
+  it 'parses (2nd alternative succeeds) :noreduce => true' do
+
+    AltParser.parse('y', :noreduce => true).should ==
+      [ :text, [ 0, 1, 1 ], true, 'y', [
         [ nil, [ 0, 1, 1 ], false, 'expected "x", got "y"', [] ],
         [ nil, [ 0, 1, 1 ], true, 'y', [] ] ] ]
   end

data/spec/parser_character_spec.rb

@@ -15,12 +15,7 @@ describe Neg::Parser::CharacterParser do
     it 'parses "xy"' do
 
       parser.parse('xy').should ==
-        [ :text,
-          [ 0, 1, 1 ],
-          true,
-          nil,
-          [ [ nil, [ 0, 1, 1 ], true, "x", [] ],
-            [ nil, [ 1, 1, 2 ], true, "y", [] ] ] ]
+        [ :text, [ 0, 1, 1 ], true, 'xy', [] ]
     end
 
     it 'fails gracefully' do
@@ -55,19 +50,7 @@ describe Neg::Parser::CharacterParser do
     it 'parses "tel:0-99"' do
 
       parser.parse('tel:0-99').should ==
-        [ :text,
-          [ 0, 1, 1 ],
-          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", [] ] ] ] ] ]
+        [ :text, [ 0, 1, 1 ], true, 'tel:0-99', [] ]
     end
 
     it 'fails gracefully' do

data/spec/parser_lookahead_parser_spec.rb

@@ -17,6 +17,17 @@ describe Neg::Parser::LookaheadParser do
     it 'parses' do
 
       parser.parse('xz').should ==
+        [ :root,
+          [ 0, 1, 1 ],
+          true,
+          nil,
+          [ [ :x, [ 0, 1, 1 ], true, 'x', [] ],
+            [ :z, [ 1, 1, 2 ], true, 'z', [] ] ] ]
+    end
+
+    it 'parses (:noreduce => true)' do
+
+      parser.parse('xz', :noreduce => true).should ==
         [ :root,
           [ 0, 1, 1 ],
           true,
@@ -24,11 +35,11 @@ describe Neg::Parser::LookaheadParser do
           [ [ :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", [] ] ] ]
+              'x',
+              [ [ nil, [ 0, 1, 1 ], true, 'x', [] ],
+                [ nil, [ 1, 1, 2 ], true, '', [
+                  [ nil, [ 1, 1, 2 ], true, 'z', [] ] ] ] ] ],
+            [ :z, [ 1, 1, 2 ], true, 'z', [] ] ] ]
     end
 
     it 'fails gracefully' do
@@ -79,17 +90,8 @@ describe Neg::Parser::LookaheadParser do
           [ 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", [] ] ] ]
+          [ [ :x, [ 0, 1, 1 ], true, 'x', [] ],
+            [ :z, [ 1, 1, 2 ], true, 'z', [] ] ] ]
     end
 
     it 'fails gracefully' do

data/spec/parser_non_terminal_spec.rb

@@ -27,9 +27,7 @@ describe Neg::Parser::NonTerminalParser do
       end
 
       parser.parse('X').should ==
-        [ :x, [ 0, 1, 1 ], true, nil, [
-          [ nil, [ 0, 1, 1 ], false, "expected \"x\", got \"X\"", [] ],
-          [ nil, [ 0, 1, 1 ], true, "X", [] ] ] ]
+        [ :x, [ 0, 1, 1 ], true, 'X', [] ]
     end
 
     it 'is rendered as x when on the right side' do
@@ -49,14 +47,15 @@ describe Neg::Parser::NonTerminalParser do
       }.strip
     end
 
-    it 'flips burgers' do
+    it 'does not bind if the name starts with _' do
 
       parser = Class.new(Neg::Parser) do
-        sentence == (word + ` `) * 1
-        word  == _("a-z") * 1
+        sentence == (_word + ` `) * 1
+        _word  == _("a-z") * 1
       end
 
-      pp parser.parse("ab cd ")
+      parser.parse("ab cd ").should ==
+        [ :sentence, [ 0, 1, 1 ], true, 'ab cd ', [] ]
     end
   end
 
@@ -87,11 +86,9 @@ describe Neg::Parser::NonTerminalParser do
           [ 0, 1, 1 ],
           true,
           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', [] ] ] ] ] ]
+          [ [ 'vehicle', [ 0, 1, 1 ], true, 'car', [] ],
+            [ nil, [ 3, 1, 4 ], true, '_', [] ],
+            [ 'city', [ 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, [ 0, 1, 1 ], true, nil, [] ]
+        [ :text, [ 0, 1, 1 ], true, '', [] ]
     end
 
     it 'fails gracefully' do
@@ -48,16 +48,13 @@ describe Neg::Parser::RepetitionParser do
     it 'parses the empty string' do
 
       parser.parse('').should ==
-        [ :text, [ 0, 1, 1 ], true, nil, [] ]
+        [ :text, [ 0, 1, 1 ], true, '', [] ]
     end
 
     it 'parses' do
 
       parser.parse('xxx').should ==
-        [ :text, [ 0, 1, 1 ], true, nil, [
-          [ nil, [ 0, 1, 1 ], true, 'x', [] ],
-          [ nil, [ 1, 1, 2 ], true, 'x', [] ],
-          [ nil, [ 2, 1, 3 ], true, 'x', [] ] ] ]
+        [ :text, [ 0, 1, 1 ], true, 'xxx', [] ]
     end
 
     it 'fails gracefully' do
@@ -81,10 +78,7 @@ describe Neg::Parser::RepetitionParser do
     it 'parses' do
 
       parser.parse('xxx').should ==
-        [ :text, [ 0, 1, 1 ], true, nil, [
-          [ nil, [ 0, 1, 1 ], true, 'x', [] ],
-          [ nil, [ 1, 1, 2 ], true, 'x', [] ],
-          [ nil, [ 2, 1, 3 ], true, 'x', [] ] ] ]
+        [ :text, [ 0, 1, 1 ], true, 'xxx', [] ]
     end
 
     it 'fails gracefully' do
@@ -107,10 +101,7 @@ describe Neg::Parser::RepetitionParser do
     it 'parses' do
 
       parser.parse('xxx').should ==
-        [ :text, [ 0, 1, 1 ], true, nil, [
-          [ nil, [ 0, 1, 1 ], true, 'x', [] ],
-          [ nil, [ 1, 1, 2 ], true, 'x', [] ],
-          [ nil, [ 2, 1, 3 ], true, 'x', [] ] ] ]
+        [ :text, [ 0, 1, 1 ], true, 'xxx', [] ]
     end
 
     it 'fails gracefully' do

data/spec/parser_sequence_spec.rb

@@ -11,9 +11,7 @@ describe Neg::Parser::SequenceParser do
   it 'parses' do
 
     SeqParser.parse('xy').should ==
-      [ :text, [ 0, 1, 1 ], true, nil, [
-        [ nil, [ 0, 1, 1 ], true, 'x', [] ],
-        [ nil, [ 1, 1, 2 ], true, 'y', [] ] ] ]
+      [ :text, [ 0, 1, 1 ], true, 'xy', [] ]
   end
 
   it 'fails gracefully' do
@@ -51,18 +49,7 @@ describe Neg::Parser::SequenceParser do
         [ 0, 1, 1 ],
         true,
         nil,
-        [ [ :poodle,
-            [ 0, 1, 1 ],
-            false,
-            nil,
-            [ [ nil, [ 0, 1, 1 ], true, "poo", [] ],
-              [ nil, [ 3, 1, 4 ], false, "expected \"dle\", got \"l\"", [] ] ] ],
-          [ :pool,
-            [ 0, 1, 1 ],
-            true,
-            nil,
-            [ [ nil, [ 0, 1, 1 ], true, "poo", [] ],
-              [ nil, [ 3, 1, 4 ], true, "l", [] ] ] ] ] ]
+        [ [ :pool, [ 0, 1, 1 ], true, "pool", [] ] ] ]
   end
 end
 

data/spec/parser_spec.rb

@@ -18,6 +18,21 @@ describe 'Neg::Parser' do
     end
   end
 
+#  describe 'the blankslate' do
+#
+#    it 'lets through node names like "send"' do
+#
+#      parser =
+#        Class.new(Neg::Parser) do
+#          send == `x`
+#        end
+#
+#      parser.parse("x").should == [ :send, [ 0, 1, 1 ], true, 'x', [] ]
+#    end
+#  end
+  #
+  # not worth the pain for now
+
   describe '.parse' do
 
     let(:parser) {

data/spec/parser_string_spec.rb

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

data/spec/sample_arith_spec.rb

@@ -0,0 +1,90 @@
+
+require 'spec_helper'
+
+
+describe 'sample math parser' do
+
+  class ArithParser < Neg::Parser
+
+    expression  == operation
+
+    operator    == `+` | `-` | `*` | `/`
+    operation   == value + (operator + value) * 0
+    value       == parenthese | number
+    parenthese  == `(` + expression + `)`
+    number      == `-` * -1 + _('0-9') * 1
+  end
+
+  class ArithTranslator < Neg::Translator
+
+    on(:number)    { |n| n.result.to_i }
+    on(:operator)  { |n| n.result }
+    on(:value)     { |n| n.results.first }
+
+    on(:expression) { |n|
+      results = n.results.flatten(2)
+      results.size == 1 ? results.first : results
+    }
+  end
+
+  def parse(s, opts={})
+
+    r = ArithParser.parse(s, opts)
+
+    if ENV['DEBUG'] == 'true' # /!\ not $DEBUG
+      puts "--#{s.inspect}-->"
+      pp r
+    end
+
+    r[2]
+  end
+
+  def translate(s)
+
+    ArithTranslator.translate(ArithParser.parse(s))
+  end
+
+  it 'parses numbers' do
+
+    parse("0").should == true
+    parse("-0").should == true
+    parse("12").should == true
+    parse("-3").should == true
+    parse("-12").should == true
+  end
+
+  it 'parses parentheses' do
+
+    parse("(1)").should == true
+    parse("((1))").should == true
+  end
+
+  it 'parses operations' do
+
+    parse("1+1").should == true
+    parse("1+-1").should == true
+  end
+
+  it 'parses at large' do
+
+    parse("1+(1+1)").should == true
+    parse("12+(34-(56/78))").should == true
+  end
+
+  it 'translates numbers' do
+
+    translate("0").should == 0
+    translate("101").should == 101
+  end
+
+  it 'translates parentheses' do
+
+    translate("(12)").should == 12
+  end
+
+  it 'translates operations' do
+
+    translate("1+2+3").should == [ 1, '+', 2, '+', 3 ]
+  end
+end
+