whittle 0.0.1

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require "whittle"
+
+RSpec.configure do |config|
+end

data/spec/unit/parser/empty_rule_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe "a parser with an empty rule" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule(:expr) do |r|
+        r[].as                { "test" }
+        r["(", :expr, ")"].as { |_, expr, _| expr }
+      end
+
+      rule("(")
+      rule(")")
+
+      start(:expr)
+    end
+  end
+
+  it "injects the empty rule to allow matching the input" do
+    parser.new.parse("((()))").should == "test"
+  end
+end

data/spec/unit/parser/empty_string_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe "a parser matching the empty string" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule(:empty) do |r|
+        r[].as   { "bob" }
+      end
+
+      start(:empty)
+    end
+  end
+
+  it "always matches the empty string" do
+    parser.new.parse("").should == "bob"
+  end
+end

data/spec/unit/parser/error_reporting_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe "a parser encountering unexpected input" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule(:wsp) do |r|
+        r[/\s+/]
+      end
+
+      rule(:id) do |r|
+        r[/[a-z]+/].as(:value)
+      end
+
+      rule(",")
+      rule("-")
+
+      rule(:list) do |r|
+        r[:list, ",", :id].as { |list, _, id| list << id }
+        r[:id].as             { |id| Array(id) }
+      end
+
+      start(:list)
+    end
+  end
+
+  it "raises an exception of type ParseError" do
+    expect {
+      parser.new.parse("a, b - c")
+    }.to raise_error(Whittle::ParseError)
+  end
+
+  it "provides access to the line number" do
+    begin
+      parser.new.parse("a, \nb, \nc- \nd")
+    rescue Whittle::ParseError => e
+      e.line.should == 3
+    end
+  end
+
+  it "provides access to the expected tokens" do
+    begin
+      parser.new.parse("a, \nb, \nc- \nd")
+    rescue Whittle::ParseError => e
+      e.expected.should == [","]
+    end
+  end
+
+  it "provides access to the received token" do
+    begin
+      parser.new.parse("a, \nb, \nc- \nd")
+    rescue Whittle::ParseError => e
+      e.received.should == "-"
+    end
+  end
+end

data/spec/unit/parser/grouped_expr_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe "a parser with logical grouping" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule(:expr) do |r|
+        r["(", :expr, ")"].as   { |_, expr, _| expr }
+        r[:expr, "-", :expr].as { |a, _, b| a - b }
+        r[:int].as(:value)
+      end
+
+      rule(:int) do |r|
+        r[/[0-9]+/].as { |int| Integer(int) }
+      end
+
+      rule("(")
+      rule(")")
+      rule("-") % :left ^ 1
+
+      start(:expr)
+    end
+  end
+
+  it "parses the grouping first" do
+    parser.new.parse("2-(3-1)-1").should == -1
+  end
+end

data/spec/unit/parser/multiple_precedence_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe "a parser with multiple precedence levels" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule(:expr) do |r|
+        r["(", :expr, ")"].as   { |_, expr, _| expr }
+        r[:expr, "+", :expr].as { |a, _, b| a + b }
+        r[:expr, "-", :expr].as { |a, _, b| a - b }
+        r[:expr, "*", :expr].as { |a, _, b| a * b }
+        r[:expr, "/", :expr].as { |a, _, b| a / b }
+        r[:int].as(:value)
+      end
+
+      rule(:int) do |r|
+        r[/[0-9]+/].as { |int| Integer(int) }
+      end
+
+      rule("(")
+      rule(")")
+      rule("+") % :left ^ 1
+      rule("-") % :left ^ 1
+      rule("*") % :left ^ 2
+      rule("/") % :left ^ 2
+
+      start(:expr)
+    end
+  end
+
+  it "evaluates each precedence as it is encountered" do
+    parser.new.parse("4-2*3-(6/3)/2+1").should == -2
+  end
+end

data/spec/unit/parser/noop_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe "a noop parser" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule(:char) do |r|
+        r[/./].as(:value)
+      end
+
+      rule(:prog) do |r|
+        r[:char]
+      end
+
+      start(:prog)
+    end
+  end
+
+  it "returns nil for all inputs" do
+    ["a", "b"].each do |input|
+      parser.new.parse(input).should be_nil
+    end
+  end
+end

data/spec/unit/parser/pass_through_parser_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe "a pass-through parser" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule(:foo) do |r|
+        r["FOO"].as(:value)
+      end
+
+      start(:foo)
+    end
+  end
+
+  it "returns the input" do
+    parser.new.parse("FOO").should == "FOO"
+  end
+end

data/spec/unit/parser/precedence_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe "a parser depending on operator precedences" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule("+") % :left ^ 1
+      rule("*") % :left ^ 2
+
+      rule(:int) do |r|
+        r[/[0-9]+/].as { |i| Integer(i) }
+      end
+
+      rule(:expr) do |r|
+        r[:expr, "+", :expr].as { |a, _, b| a + b }
+        r[:expr, "*", :expr].as { |a, _, b| a * b }
+        r[:int].as(:value)
+      end
+
+      start(:expr)
+    end
+  end
+
+  it "resolves shift-reduce conflicts by precedence" do
+    parser.new.parse("1+2*3").should == 7
+  end
+end

data/spec/unit/parser/self_referential_expr_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe "a parser with a self-referential rule" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule("(")
+      rule(")")
+      rule("+")
+
+      rule(:int) do |r|
+        r[/[0-9]+/].as { |int| Integer(int) }
+      end
+
+      rule(:expr) do |r|
+        r[:expr, "+", :expr].as { |a, _, b| a + b }
+        r[:int].as(:value)
+      end
+
+      start(:expr)
+    end
+  end
+
+  it "handles the recursion gracefully" do
+    parser.new.parse("2+3+1").should == 6
+  end
+end

data/spec/unit/parser/skipped_tokens_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe "a parser that skips tokens" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule(:wsp) do |r|
+        r[/\s+/]
+      end
+
+      rule("-") % :left
+
+      rule(:int) do |r|
+        r[/[0-9]+/].as { |int| Integer(int) }
+      end
+
+      rule(:expr) do |r|
+        r[:expr, "-", :expr].as { |a, _, b| a - b }
+        r[:int].as(:value)
+      end
+
+      start(:expr)
+    end
+  end
+
+  it "reads the input excluding the skipped tokens" do
+    parser.new.parse("6 - 3 - 1").should == 2
+  end
+end

data/spec/unit/parser/sum_parser_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe "a parser returning the sum of two integers" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule("+")
+
+      rule(:int) do |r|
+        r[/[0-9]+/].as { |int| Integer(int) }
+      end
+
+      rule(:sum) do |r|
+        r[:int, "+", :int].as { |a, _, b| a + b }
+      end
+
+      start(:sum)
+    end
+  end
+
+  it "returns the sum of the operands" do
+    parser.new.parse("10+20").should == 30
+  end
+end

data/spec/unit/parser/typecast_parser_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe "a type-casting parser" do
+  let(:parser) do
+    Class.new(Whittle::Parser) do
+      rule(:int) do |r|
+        r[/[0-9]+/].as { |int| Integer(int) }
+      end
+
+      start(:int)
+    end
+  end
+
+  it "returns the input passed through the callback" do
+    parser.new.parse("123").should == 123
+  end
+end

data/whittle.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "whittle/version"
+
+Gem::Specification.new do |s|
+  s.name        = "whittle"
+  s.version     = Whittle::VERSION
+  s.authors     = ["d11wtq"]
+  s.email       = ["chris@w3style.co.uk"]
+  s.homepage    = "https://github.com/d11wtq/whittle"
+  s.summary     = %q{An efficient, easy to use, LALR parser for Ruby}
+  s.description = %q{Write powerful parsers by defining a series of very simple rules
+                     and operations to perform as those rules are matched.  Whittle
+                     parsers are written in pure ruby and as such are extremely flexible.
+                     Anybody familiar with parsers like yacc should find Whittle intuitive.
+                     Those unfamiliar with parsers shouldn't find it difficult to
+                     understand.}
+
+  s.rubyforge_project = "whittle"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", "~> 2.6"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: whittle
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- d11wtq
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70265816010420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *70265816010420
+description: ! "Write powerful parsers by defining a series of very simple rules\n
+  \                    and operations to perform as those rules are matched.  Whittle\n
+  \                    parsers are written in pure ruby and as such are extremely
+  flexible.\n                     Anybody familiar with parsers like yacc should find
+  Whittle intuitive.\n                     Those unfamiliar with parsers shouldn't
+  find it difficult to\n                     understand."
+email:
+- chris@w3style.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/whittle.rb
+- lib/whittle/error.rb
+- lib/whittle/errors/grammar_error.rb
+- lib/whittle/errors/parse_error.rb
+- lib/whittle/errors/unconsumed_input_error.rb
+- lib/whittle/parser.rb
+- lib/whittle/rule.rb
+- lib/whittle/rule_set.rb
+- lib/whittle/version.rb
+- spec/spec_helper.rb
+- spec/unit/parser/empty_rule_spec.rb
+- spec/unit/parser/empty_string_spec.rb
+- spec/unit/parser/error_reporting_spec.rb
+- spec/unit/parser/grouped_expr_spec.rb
+- spec/unit/parser/multiple_precedence_spec.rb
+- spec/unit/parser/noop_spec.rb
+- spec/unit/parser/pass_through_parser_spec.rb
+- spec/unit/parser/precedence_spec.rb
+- spec/unit/parser/self_referential_expr_spec.rb
+- spec/unit/parser/skipped_tokens_spec.rb
+- spec/unit/parser/sum_parser_spec.rb
+- spec/unit/parser/typecast_parser_spec.rb
+- whittle.gemspec
+homepage: https://github.com/d11wtq/whittle
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: whittle
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: An efficient, easy to use, LALR parser for Ruby
+test_files:
+- spec/spec_helper.rb
+- spec/unit/parser/empty_rule_spec.rb
+- spec/unit/parser/empty_string_spec.rb
+- spec/unit/parser/error_reporting_spec.rb
+- spec/unit/parser/grouped_expr_spec.rb
+- spec/unit/parser/multiple_precedence_spec.rb
+- spec/unit/parser/noop_spec.rb
+- spec/unit/parser/pass_through_parser_spec.rb
+- spec/unit/parser/precedence_spec.rb
+- spec/unit/parser/self_referential_expr_spec.rb
+- spec/unit/parser/skipped_tokens_spec.rb
+- spec/unit/parser/sum_parser_spec.rb
+- spec/unit/parser/typecast_parser_spec.rb
+has_rdoc: