neg 0.2.0

data/lib/neg/version.rb

@@ -0,0 +1,30 @@
+#--
+# Copyright (c) 2012-2012, 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
+
+  VERSION = '0.2.0'
+end
+

data/neg.gemspec

@@ -0,0 +1,33 @@
+
+Gem::Specification.new do |s|
+
+  s.name = 'neg'
+
+  s.version = File.read(
+    File.expand_path('../lib/neg/version.rb', __FILE__)
+  ).match(/ VERSION *= *['"]([^'"]+)/)[1]
+
+  s.platform = Gem::Platform::RUBY
+  s.authors = [ 'John Mettraux' ]
+  s.email = [ 'jmettraux@gmail.com' ]
+  s.homepage = 'https://github.com/jmettraux/leg'
+  s.rubyforge_project = 'ruote'
+  s.summary = 'a neg narser'
+
+  s.description = %{
+not a peg parser, just a neg narser
+  }.strip
+
+  #s.files = `git ls-files`.split("\n")
+  s.files = Dir[
+    'Rakefile',
+    'lib/**/*.rb', 'spec/**/*.rb', 'test/**/*.rb',
+    '*.gemspec', '*.txt', '*.rdoc', '*.md'
+  ]
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '>= 2.9.0'
+
+  s.require_path = 'lib'
+end
+

data/spec/input_spec.rb

@@ -0,0 +1,75 @@
+
+require 'spec_helper'
+
+
+describe Neg::Input do
+
+  before(:each) do
+
+    @input = Neg::Input.new("the quick blue fox\n jumped the shark\n")
+  end
+
+  it 'starts at zero' do
+
+    @input.position.should == [ 0, 1, 1 ]
+  end
+
+  describe '#read' do
+
+    it "reads and moves" do
+
+      @input.read(5).should == 'the q'
+
+      @input.position.should == [ 5, 1, 6 ]
+    end
+
+    it "reads and moves (same line)" do
+
+      @input.read(9).should == 'the quick'
+
+      @input.position.should == [ 9, 1, 10 ]
+    end
+
+    it "reads and moves (new line)" do
+
+      @input.read(21).should == "the quick blue fox\n j"
+
+      @input.position.should == [ 21, 2, 2 ]
+    end
+  end
+
+  describe '#rewind' do
+
+    it 'rewinds' do
+
+      @input.read(21)
+      @input.rewind
+
+      @input.position.should == [ 0, 1, 1 ]
+    end
+
+    it 'rewinds with a [ off, line, col ]' do
+
+      @input.read(21)
+      @input.rewind([ 5, 1, 6 ])
+
+      @input.read(4).should == 'uick'
+    end
+  end
+
+  describe '#eoi?' do
+
+    it 'returns false if the end of input has not yet been reached' do
+
+      @input.eoi?.should == false
+    end
+
+    it 'returns true if the end of input has been reached' do
+
+      @input.read(37)
+
+      @input.eoi?.should == true
+    end
+  end
+end
+

data/spec/parser_alternative_spec.rb

@@ -0,0 +1,48 @@
+
+require 'spec_helper'
+
+
+describe Neg::Parser::AlternativeParser do
+
+  class AltParser < Neg::Parser
+    text == `x` | `y`
+  end
+
+  it 'parses' do
+
+    AltParser.parse('x').should ==
+      [ :text, true, [ 0, 1, 1 ], [
+        [ nil, true, [ 0, 1, 1 ], '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' ] ] ]
+  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"' ] ] ]
+  end
+
+  it 'goes beyond two elements' do
+
+    parser = Class.new(Neg::Parser) do
+      text == `x` | `y` | `z`
+    end
+
+    text = parser.text
+
+    text.class.should ==
+      Neg::Parser::NonTerminalParser
+    text.child.children.collect(&:class).should ==
+      [ Neg::Parser::StringParser ] * 3
+  end
+end
+

data/spec/parser_character_spec.rb

@@ -0,0 +1,72 @@
+
+require 'spec_helper'
+
+
+describe Neg::Parser::CharacterParser do
+
+  context '_ (any)' do
+
+    let(:parser) {
+      Class.new(Neg::Parser) do
+        text == `x` + _
+      end
+    }
+
+    it 'parses "xy"' do
+
+      parser.parse('xy').should ==
+        [ :text,
+          true,
+          [ 0, 1, 1 ],
+          [ [ nil, true, [ 0, 1, 1 ], "x" ],
+            [ nil, true, [ 1, 1, 2 ], "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" ] ] ]
+    end
+
+    it 'is rendered correctly via #to_s' do
+
+      parser.to_s.strip.should == %q{
+:
+  text == (`x` + _)
+  root: text
+      }.strip
+    end
+  end
+
+  context "_('0-9-') (ranges)" do
+
+    let(:parser) {
+      Class.new(Neg::Parser) do
+        text == `tel:` + _('0-9-') * 1
+      end
+    }
+
+    it 'parses "tel:0-99"' do
+
+      parser.parse('tel:0-99').should ==
+        [ :text,
+          true,
+          [ 0, 1, 1 ],
+          [ [ nil, true, [ 0, 1, 1 ], "tel:" ],
+            [ nil,
+              true,
+              [ 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" ] ] ] ] ]
+    end
+
+    it 'fails gracefully'
+  end
+end
+

data/spec/parser_non_terminal_spec.rb

@@ -0,0 +1,85 @@
+
+require 'spec_helper'
+
+
+describe Neg::Parser::NonTerminalParser do
+
+  context 'name == ...' do
+
+    it 'parses' do
+
+      parser = Class.new(Neg::Parser) do
+        text == x | z
+        x    == `x`
+        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
+    end
+
+    it 'sets its name in the result (as a Symbol)' do
+
+      parser = Class.new(Neg::Parser) do
+        x == `x` | `X` | `xx`
+      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" ] ] ]
+    end
+
+    it 'is rendered as x when on the right side' do
+
+      parser = Class.new(Neg::Parser) do
+        word  == car | bus
+        car   == `car`
+        bus   == `bus`
+      end
+
+      parser.to_s.strip.should == %q{
+:
+  bus == `bus`
+  car == `car`
+  word == (car | bus)
+  root: word
+      }.strip
+    end
+  end
+
+  context '...["name"]' do
+
+    let(:parser) {
+      Class.new(Neg::Parser) do
+        transportation ==
+          (`car` | `bus`)['vehicle'] +
+          `_` +
+          (`cluj` | `split`)['city']
+      end
+    }
+
+    it 'is rendered as []' do
+
+      parser.to_s.strip.should == %q{
+:
+  transportation == ((`car` | `bus`)["vehicle"] + `_` + (`cluj` | `split`)["city"])
+  root: transportation
+      }.strip
+    end
+
+    it 'sets the name (as a string) in the result' do
+
+      parser.parse('car_cluj').should ==
+        [ :transportation,
+          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' ] ] ] ] ]
+    end
+  end
+end
+

data/spec/parser_repetition_spec.rb

@@ -0,0 +1,142 @@
+
+require 'spec_helper'
+
+
+describe Neg::Parser::RepetitionParser do
+
+  context '`x` * -1 (maybe)' do
+
+    let(:parser) {
+      Class.new(Neg::Parser) do
+        text == `x` * -1
+      end
+    }
+
+    it 'parses the empty string' do
+
+      parser.parse('').should ==
+        [ :text, true, [ 0, 1, 1 ], [] ]
+    end
+
+    it 'fails gracefully' do
+
+      lambda {
+        parser.parse('xx')
+      }.should raise_error(
+        Neg::UnconsumedInputError,
+        'remaining: "x"')
+    end
+
+    it 'is rendered correctly via #to_s' do
+
+      parser.to_s.strip.should == %q{
+:
+  text == `x` * -1
+  root: text
+      }.strip
+    end
+  end
+
+  context '`x` * 0 (0 or more)' do
+
+    let(:parser) {
+      Class.new(Neg::Parser) do
+        text == `x` * 0
+      end
+    }
+
+    it 'parses the empty string' do
+
+      parser.parse('').should ==
+        [ :text, true, [ 0, 1, 1 ], [] ]
+    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' ] ] ]
+    end
+
+    it 'fails gracefully' do
+
+      lambda {
+        parser.parse('a')
+      }.should raise_error(
+        Neg::UnconsumedInputError,
+        'remaining: "a"')
+    end
+  end
+
+  context '`x` * 2 (at least 2)' do
+
+    let(:parser) {
+      Class.new(Neg::Parser) do
+        text == `x` * 2
+      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' ] ] ]
+    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 ""' ] ] ]
+    end
+  end
+
+  context '`x` * [ 3, 3 ] (at least 3, max 3)' do
+
+    let(:parser) {
+      Class.new(Neg::Parser) do
+        text == `x` * [ 3, 3 ]
+      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' ] ] ]
+    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 ""' ] ] ]
+    end
+
+    it 'fails gracefully (unconsumed input)' do
+
+      lambda {
+        parser.parse('xxxx')
+      }.should raise_error(Neg::UnconsumedInputError, 'remaining: "x"')
+    end
+
+    it 'is rendered correctly via #to_s' do
+
+      parser.to_s.strip.should == %q{
+:
+  text == `x` * [3, 3]
+  root: text
+      }.strip
+    end
+  end
+end
+