sexpr 0.2.0 → 0.3.0

data/spec/grammar/test_sexpr.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+module Sexpr
+  describe Grammar, "sexpr" do
+
+    def sexpr(expr, opts = {})
+      @sexpr = Sexpr.load(:parser => parser).sexpr(expr, opts)
+    end
+
+    after{
+      @sexpr.should be_a(Sexpr) if @sexpr
+    }
+
+    context 'when no parser is set' do
+      let(:parser){ nil }
+
+      it 'silently returns a sexpr array' do
+        sexpr([:sexpr, "world"]).should eq([:sexpr, "world"])
+      end
+
+      it 'raises an error when parser is needed' do
+        lambda{
+          sexpr("Hello world")
+        }.should raise_error(NoParserError)
+      end
+
+    end
+
+    context 'when a parser is set' do
+      let(:parser){
+        Object.new.extend Module.new{
+          include Parser
+          def sexpr(s, options = {})
+            [options[:root] || :parsed, s]
+          end
+        }
+      }
+
+      it 'silently returns a sexpr array' do
+        sexpr([:sexpr, "world"]).should eq([:sexpr, "world"])
+      end
+
+      it 'delegates the call to the parser' do
+        sexpr("Hello world").should eq([:parsed, "Hello world"])
+      end
+
+      it 'passes options' do
+        sexpr("world", :root => :hello).should eq([:hello, "world"])
+      end
+
+    end # when a parser is set
+
+  end
+end

data/spec/{alternative → matcher/alternative}/test_eat.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Alternative, "eat" do
 
     let(:alt1){ Terminal.new(nil)            }

data/spec/{alternative → matcher/alternative}/test_match_q.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Alternative, "match?" do
 
     let(:alt1){ Terminal.new(nil)            }

data/spec/{many → matcher/many}/test_eat.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Many, "eat" do
 
     let(:term){ Terminal.new(/^[a-z]+$/)   }

data/spec/{many → matcher/many}/test_initialize.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Many, "initialize" do
 
     it 'understands a single min' do

data/spec/{many → matcher/many}/test_match_q.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Many do
 
     let(:term){ Terminal.new(/^[a-z]+$/) }

data/spec/{reference → matcher/reference}/test_eat.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Reference, "eat" do
 
     let(:grammar){ {:hello => Terminal.new(/^[a-z]+$/)} }

data/spec/{reference → matcher/reference}/test_match_q.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Reference, "match?" do
 
     let(:grammar){ {:hello => Terminal.new(/^[a-z]+$/)} }

data/spec/{rule → matcher/rule}/test_eat.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Rule, "eat" do
 
     let(:defn){ Sequence.new [Terminal.new(/^[a-z]+$/)] }

data/spec/{rule → matcher/rule}/test_match_q.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Rule, 'match?' do
 
     let(:defn){ Sequence.new [Terminal.new(/^[a-z]+$/)] }

data/spec/{sequence → matcher/sequence}/test_eat.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Sequence, "eat" do
 
     let(:alt1){ Terminal.new(nil)          }

data/spec/{sequence → matcher/sequence}/test_match_q.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Sequence, 'match?' do
 
     let(:alt1){ Terminal.new(nil)          }

data/spec/{terminal → matcher/terminal}/test_eat.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Terminal, "eat" do
 
     let(:rule){ Terminal.new(/^[a-z]+$/) }

data/spec/{terminal → matcher/terminal}/test_match_q.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Terminal, "match?" do
 
     let(:rule){ Terminal.new(arg) }

data/spec/{terminal → matcher/terminal}/test_terminal_match.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-module Sexpr
+module Sexpr::Matcher
   describe Terminal, "terminal_match?" do
 
     before do

data/spec/node/test_sexpr_body.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Sexpr
+  describe Node, "sexpr_body" do
+
+    it 'returns the head' do
+      sexpr([:lit, true]).sexpr_body.should eq([true])
+    end
+
+    it 'returns an empty array if no body' do
+      sexpr([:lit]).sexpr_body.should eq([])
+    end
+
+    it 'is aliased as sexp_body' do
+      sexpr([:lit, true]).sexp_body.should eq([true])
+    end
+
+  end
+end

data/spec/node/test_sexpr_type.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Sexpr
+  describe Node, "sexpr_type" do
+
+    it 'returns the head' do
+      sexpr([:lit, true]).sexpr_type.should eq(:lit)
+    end
+
+    it 'is aliased as sexp_type' do
+      sexpr([:lit, true]).sexp_type.should eq(:lit)
+    end
+
+  end
+end

data/spec/parser/citrus/test_new.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Sexpr::Parser
+  describe Citrus, "new" do
+
+    it 'factors a Parser instance when a Citrus::Grammar' do
+      p = Citrus.new(bool_expr_parser)
+      p.should be_a(Citrus)
+      p.parser.should eq(bool_expr_parser)
+    end
+
+    it 'factors a Parser instance when a Path to a .citrus file' do
+      p = Citrus.new(fixtures_path/"bool_expr.citrus")
+      p.should be_a(Citrus)
+      p.parser.should eq(bool_expr_parser)
+    end
+
+    it 'factors a Parser instance when a Path to a .citrus file' do
+      p = Citrus.new (fixtures_path/"bool_expr.citrus").to_s
+      p.should be_a(Citrus)
+      p.parser.should eq(bool_expr_parser)
+    end
+
+    it 'passes the options' do
+      Citrus.new(bool_expr_parser, {:hello => "World"}).options[:hello].should eq("World")
+    end
+
+  end
+end

data/spec/parser/citrus/test_parse.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Sexpr::Parser
+  describe Citrus, "parse" do
+
+    let(:parser){ Citrus.new(bool_expr_parser) }
+
+    it 'delegates the call to the Citrus parser' do
+      parser.parse("true").should be_a(::Citrus::Match)
+    end
+
+    it 'raises a Citrus::ParserError when parsing fails' do
+      lambda{
+        parser.parse("bl and or")
+      }.should raise_error(::Citrus::ParseError)
+    end
+
+    it 'recognizes the :root option' do
+      parser.parse("true", :root => :bool_lit).should be_a(::Citrus::Match)
+      parser.parse("x", :root => :var_ref).should be_a(::Citrus::Match)
+      lambda{
+        parser.parse("x", :root => :bool_lit)
+      }.should raise_error(::Citrus::ParseError)
+    end
+
+    it 'recognizes the :consume option' do
+      lambda{
+        parser.parse("true or")
+      }.should raise_error(::Citrus::ParseError)
+      parser.parse("true or", :consume => false).should eq("true")
+    end
+
+    it 'can parse from a Path' do
+      Path.tmpfile do |tmp|
+        tmp.write "x and y"
+        parser.parse(tmp).should be_a(::Citrus::Match)
+      end
+    end
+
+  end
+end

data/spec/parser/citrus/test_recognize.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Sexpr::Parser
+  describe Citrus, "recognize?" do
+
+    it 'returns true on Citrus parsers' do
+      Citrus.should be_recognize(bool_expr_parser)
+    end
+
+    it 'returns true on a Citrus Path' do
+      Citrus.should be_recognize(fixtures_path/"bool_expr.citrus")
+    end
+
+    it 'returns false when not recognized' do
+      (Citrus.recognizes?(self)).should be_false
+    end
+
+  end
+end

data/spec/parser/citrus/test_registration.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Sexpr::Parser
+  describe Citrus do
+
+    it 'should be registered' do
+      Sexpr::Parser.find_parser_class(bool_expr_parser).should eq(Citrus)
+    end
+
+    it 'should be served for a Citrus grammar' do
+      Sexpr::Parser.factor(bool_expr_parser).should be_a(Citrus)
+    end
+
+    it 'should accept factor options, defaulting to defaults' do
+      cit = Sexpr::Parser.factor(bool_expr_parser, {:hello => "World"})
+      cit.options[:hello].should eq("World")
+      cit.options.should have_key(:from_match_to_sexpr)
+    end
+
+  end
+end

data/spec/parser/citrus/test_to_sexpr.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Sexpr::Parser
+  describe Citrus, "sexpr" do
+
+    it 'calls value by default' do
+      parser = Citrus.new(bool_expr_parser)
+      parser.sexpr("true").should eq([:bool_lit, true])
+    end
+
+    it 'delegates to from_match_to_sexpr if specified' do
+      parser = Citrus.new(bool_expr_parser, :from_match_to_sexpr => lambda{|x| 12})
+      parser.sexpr("true").should eq(12)
+    end
+
+  end
+end

data/spec/parser/test_factor.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Sexpr
+  describe Parser, "factor" do
+
+    it 'silently returns when given a Parser' do
+      p = Object.new.extend(Parser)
+      Parser.factor(p).should eq(p)
+    end
+
+    it 'raises a UnrecognizedParserError when no class can be found' do
+      lambda{
+        Parser.factor(self)
+      }.should raise_error(UnrecognizedParserError)
+    end
+
+  end
+end

data/spec/parser/test_input_text.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Sexpr
+  describe Parser, "input_text" do
+    include Parser
+
+    it 'recognizes a string' do
+      input_text("Hello world").should eq("Hello world")
+    end
+
+    it 'accepts a path' do
+      input_text(Path.here).should eq(File.read(__FILE__))
+    end
+
+    it 'accepts an IO' do
+      File.open(__FILE__, 'r') do |io|
+        input_text(io).should eq(File.read(__FILE__))
+      end
+    end
+
+    it 'raises a InvalidParseSourceError when invalid source' do
+      lambda{
+        input_text(self)
+      }.should raise_error(InvalidParseSourceError)
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,20 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'epath'
+root = Path.backfind('.[lib]')
+
+require 'citrus'
+
+$LOAD_PATH.unshift (root/"lib").to_s
 require 'sexpr'
+require (root/"examples/bool_expr/bool_expr").to_s
+
+def fixtures_path
+  Path.dir/"../examples/bool_expr"
+end
+
+def bool_expr_parser
+  BoolExpr.parser.parser
+end
+
+def sexpr(*args)
+  Sexpr.sexpr(*args)
+end

data/spec/test_load.rb

@@ -2,31 +2,58 @@ require 'spec_helper'
 module Sexpr
   describe Sexpr, "load" do
 
-      let(:grammar){ Sexpr.load(arg) }
+      subject{ Sexpr.load(arg) }
 
-      context "on grammar.yml" do
-        let(:arg){ Path.dir/"grammar.yml" }
+      after do
+        subject.should be_a(Grammar)
+        subject[:bool_expr].should be_a(Matcher::Alternative)
+      end
+
+      context "on a YAML path" do
+        let(:arg){ fixtures_path/"bool_expr.sexp.yml" }
+
+        it 'sets the path on the grammar' do
+          subject.path.should eq(arg)
+        end
+
+        it 'finds the parser with the relative path' do
+          subject.parser.should be_a(Parser::Citrus)
+        end
 
-        it 'returns a Grammar' do
-          grammar.should be_a(Grammar)
+      end # grammar.yml
+
+      context "on a YAML path as a String" do
+        let(:arg){ (fixtures_path/"bool_expr.sexp.yml").to_s }
+
+        it 'sets the path on the grammar' do
+          subject.path.should eq(arg)
+        end
+
+        it 'finds the parser with the relative path' do
+          subject.parser.should be_a(Parser::Citrus)
         end
 
       end # grammar.yml
 
-      context 'with a Hash' do
-        let(:arg){ {:hello => /[a-z]+/} }
+      context 'with an explicit Hash' do
+        let(:arg){ {:rules => {:bool_expr => [true, false]}} }
 
-        it 'returns a Grammar' do
-          grammar.should be_a(Grammar)
+        it 'does not set a path' do
+          subject.path.should be_nil
         end
 
       end
 
       context 'with a String' do
-        let(:arg){ "hello: true" }
-
-        it 'returns a Grammar' do
-          grammar.should be_a(Grammar)
+        let(:arg){
+          <<-YAML
+            rules:
+              bool_expr: [true, false]
+          YAML
+        }
+
+        it 'does not set a path' do
+          subject.path.should be_nil
         end
 
       end