sexpr 0.2.0 → 0.3.0

data/lib/sexpr/parser/citrus.rb

@@ -0,0 +1,67 @@
+module Sexpr
+  module Parser
+    class Citrus
+      include Parser
+
+      class << self
+
+        def recognizes?(arg)
+          looks_a_citrus_grammar?(arg) or
+          looks_a_citrus_file?(arg)
+        end
+
+        def looks_a_citrus_file?(arg)
+          arg = arg.to_path if arg.respond_to?(:to_path)
+          arg.is_a?(String) && File.exists?(arg) && (File.extname(arg) == ".citrus")
+        end
+
+        def looks_a_citrus_grammar?(arg)
+          defined?(::Citrus::Grammar) && arg.is_a?(Module) && arg.include?(::Citrus::Grammar)
+        end
+
+      end # class << self
+
+      attr_reader :options
+
+      def initialize(parser, options = {})
+        @parser  = parser
+        @options = default_options.merge(options)
+      end
+
+      def default_options
+        {:from_match_to_sexpr => lambda{|match| match.value}}
+      end
+
+      def parser
+        @citrus_parser ||= begin
+          if self.class.looks_a_citrus_grammar?(@parser)
+            @parser
+          elsif self.class.looks_a_citrus_file?(@parser)
+            @parser = @parser.to_path if @parser.respond_to?(:to_path)
+            @parser = @parser[0...-(".citrus".length)]
+            ::Citrus.load(@parser).last
+          else
+            raise UnrecognizedParserError, "Not a citrus parser #{@parser}"
+          end
+        end
+      end
+
+      def parse(input, options = {})
+        input = input_text(input)
+        parser.parse(input, options)
+      end
+
+      def sexpr(input, parse_options = {})
+        from_match_to_sexpr parse(input, parse_options)
+      end
+
+      private
+
+      def from_match_to_sexpr(match)
+        options[:from_match_to_sexpr].call(match)
+      end
+
+      Sexpr::Parser.register self
+    end # class Citrus
+  end # module Parser
+end # module Sexpr

data/lib/sexpr/version.rb

@@ -2,7 +2,7 @@ module Sexpr
   module Version
 
     MAJOR = 0
-    MINOR = 2
+    MINOR = 3
     TINY  = 0
 
     def self.to_s
@@ -11,4 +11,4 @@ module Sexpr
 
   end
   VERSION = Version.to_s
-end
+end

data/sexpr.gemspec

@@ -124,6 +124,7 @@ Gem::Specification.new do |s|
   # for each development dependency. These gems are required for developers
   #
   s.add_development_dependency("epath", "~> 0.0.1")
+  s.add_development_dependency("citrus", "~> 2.4")
   s.add_development_dependency("rake", "~> 0.9.2")
   s.add_development_dependency("rspec", "~> 2.8.0")
   s.add_development_dependency("wlang", "~> 0.10.2")

data/sexpr.noespec

@@ -9,7 +9,7 @@ variables:
   upper:
     Sexpr
   version:
-    0.2.0
+    0.3.0
   summary: |-
     A compilation framework around s-expressions
   description: |-
@@ -20,6 +20,7 @@ variables:
     - https://github.com/blambeau/sexp
   dependencies:
     - {name: epath,     version: "~> 0.0.1",  groups: [development]}
+    - {name: citrus,    version: "~> 2.4",    groups: [development]}
     - {name: rake,      version: "~> 0.9.2",  groups: [development]}
     - {name: rspec,     version: "~> 2.8.0",  groups: [development]}
     - {name: wlang,     version: "~> 0.10.2", groups: [development]}

data/spec/grammar/matching/test_compile_rule.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+module Sexpr
+  module Grammar
+    describe Matching, "compile_rule" do
+      include Matching
+
+      it 'keep alternatives unchanged' do
+        compile_rule(:hello, Matcher::Alternative.new([]) ).should be_a(Matcher::Alternative)
+      end
+
+      it 'keep terminals unchanged' do
+        compile_rule(:hello, Matcher::Terminal.new(true) ).should be_a(Matcher::Terminal)
+      end
+
+      it 'keep creates a Rule englobing sequences' do
+        compiled = compile_rule(:hello, Matcher::Sequence.new([]) )
+        compiled.should be_a(Matcher::Rule)
+        compiled.name.should eq(:hello)
+      end
+
+    end
+  end
+end

data/spec/grammar/matching/test_compile_rule_defn.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+module Sexpr
+  module Grammar
+    describe Matching, "compile_rule_defn" do
+      include Matching
+
+      subject{ compile_rule_defn(arg, :grammar) }
+
+      def rules
+        {:a_rule => "hello"}
+      end
+
+      context 'with an Element' do
+        let(:arg){ Matcher::Terminal.new(//) }
+        it 'returns arg itself' do
+          subject.should eq(arg)
+        end
+      end
+
+      context "with true" do
+        let(:arg){ true }
+        it 'gives it true' do
+          subject.should be_a(Matcher::Terminal)
+          subject.value.should eq(true)
+        end
+      end
+
+      context "with false" do
+        let(:arg){ false }
+        it 'gives it false' do
+          subject.should be_a(Matcher::Terminal)
+          subject.value.should eq(false)
+        end
+      end
+
+      context "with nil" do
+        let(:arg){ nil }
+        it 'gives it nil' do
+          subject.should be_a(Matcher::Terminal)
+          subject.value.should eq(nil)
+        end
+      end
+
+      context 'with an alternative array' do
+        let(:arg){ [true, false, nil] }
+        it 'factors an Alternative' do
+          subject.should be_a(Matcher::Alternative)
+        end
+        it 'compiles its elements' do
+          subject.terms.size.should eq(3)
+          subject.terms.all?{|x| x.is_a?(Matcher::Terminal)}.should be_true
+        end
+      end
+
+      context 'with a sequence array' do
+        let(:arg){ [[true, false, nil]] }
+        it 'factors a Sequence' do
+          subject.should be_a(Matcher::Sequence)
+        end
+        it 'compiles its elements' do
+          subject.terms.size.should eq(3)
+          subject.terms.all?{|x| x.is_a?(Matcher::Terminal)}.should be_true
+        end
+      end
+
+      context 'with subalternatives' do
+        let(:arg){ [ ["a_rule", [false, true, nil] ]] }
+        it 'compiles the last as an Alternative' do
+          subject.terms.last.should be_a(Matcher::Alternative)
+        end
+      end
+
+      context 'with a reference to a non-terminal' do
+        let(:arg){ "a_rule" }
+        it 'factors a Reference' do
+          subject.should be_a(Matcher::Reference)
+        end
+        it 'refers to the appropriate rule name' do
+          subject.rule_name.should eq(:a_rule)
+        end
+        it 'refers to the appropriate grammar' do
+          subject.grammar.should eq(:grammar)
+        end
+      end
+
+      context 'with a stared non-terminal' do
+        let(:arg){ "a_rule+" }
+        it 'factors a Many' do
+          subject.should be_a(Matcher::Many)
+        end
+        it 'refers to the appropriate rule' do
+          subject.term.should be_a(Matcher::Reference)
+          subject.term.rule_name.should eq(:a_rule)
+        end
+        it 'refers to the appropriate multiplicities' do
+          subject.min.should eq(1)
+          subject.max.should be_nil
+        end
+      end
+
+    end
+  end
+end

data/spec/grammar/options/test_install_parser.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Sexpr
+  describe Grammar::Options, "install_parser" do
+    include Grammar::Options
+
+    it 'is nil by default' do
+      h = {}
+      install_options h do
+        parser.should be_nil
+      end
+    end
+
+    it 'can be specified through a :parser option' do
+      h = {:parser => bool_expr_parser}
+      install_options h do
+        parser.should be_a(Parser::Citrus)
+      end
+    end
+
+    it 'can be specified as a Path' do
+      h = {:parser => fixtures_path/"bool_expr.citrus"}
+      install_options h do
+        parser.should be_a(Parser::Citrus)
+      end
+    end
+
+    it 'can be specified as relative Path' do
+      h = {:path => fixtures_path/"bool_expr.sexp.yml",
+           :parser => "bool_expr.citrus"}
+      install_options h do
+        parser.should be_a(Parser::Citrus)
+      end
+    end
+
+  end
+end

data/spec/grammar/options/test_install_path.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Sexpr
+  describe Grammar::Options, "install_path" do
+    include Grammar::Options
+
+    it 'is nil by default' do
+      install_options({}) do
+        path.should be_nil
+      end
+    end
+
+    it 'keeps the specified value if any' do
+      install_options :path => "blah" do
+        path.should eq("blah")
+      end
+    end
+
+  end
+end

data/spec/grammar/options/test_install_root.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Sexpr
+  describe Grammar::Options, "install_root" do
+    include Grammar::Options
+
+    let(:rules){ {:t => /[a-z]+/, :nt => true} }
+
+    it 'is the first key by default' do
+      install_options :rules => rules do
+        root.should eq(:t)
+      end
+    end
+
+    it 'is the specified rule when specified' do
+      install_options :rules => rules, :root => :nt do
+        root.should eq(:nt)
+      end
+    end
+
+    it 'is converted to a Symbol is a String' do
+      install_options :root => "nt" do
+        root.should eq(:nt)
+      end
+    end
+
+  end
+end

data/spec/grammar/tagging/test_looks_a_sexpr.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Sexpr::Grammar
+  describe Tagging, "looks_a_sexpr" do
+    include Tagging
+
+    it 'recognizes s-expressions' do
+      looks_a_sexpr?([:lit]).should be_true
+    end
+
+    it 'does not recognize empty arrays' do
+      looks_a_sexpr?([]).should be_false
+    end
+
+    it 'does not recognize others' do
+      looks_a_sexpr?(nil).should be_false
+      looks_a_sexpr?(:lit).should be_false
+    end
+
+  end
+end

data/spec/grammar/tagging/test_mod2rulename.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Sexpr::Grammar
+  describe Tagging, "mod2rulename" do
+    include Tagging
+
+    it 'work on simple module name' do
+      mod2rulename(:Test).should eq(:test)
+    end
+
+    it 'work on complex module name' do
+      mod2rulename(:ThisIsATest).should eq(:this_is_a_test)
+    end
+
+    it 'works with a module' do
+      mod2rulename(::Sexpr::Grammar).should eq(:grammar)
+    end
+
+  end
+end

data/spec/grammar/tagging/test_rule2modname.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Sexpr::Grammar
+  describe Tagging, "rule2modname" do
+    include Tagging
+
+    it 'work on simple rule name' do
+      rule2modname(:test).should eq(:Test)
+    end
+
+    it 'works when underscores are present' do
+      rule2modname(:a_rule_name).should eq(:ARuleName)
+    end
+
+    it 'works with a string' do
+      rule2modname("a_rule_name").should eq(:ARuleName)
+    end
+
+  end
+end

data/spec/grammar/tagging/test_tag_sexpr.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Sexpr::Grammar
+  describe Tagging, "tag_sexpr" do
+    include Tagging
+
+    module TaggingReference
+      module Not; end
+      module Lit; end
+    end
+
+    def tag(x)
+      res = tag_sexpr(x, TaggingReference)
+      res.should eq(x)
+      res
+    end
+
+    it 'tags a sexpr at first level' do
+      tag([:lit]).should be_a(TaggingReference::Lit)
+    end
+
+    it 'tags sexpr recursively' do
+      res = tag([:not, [:lit, true]])
+      res.should be_a(TaggingReference::Not)
+      res.last.should be_a(TaggingReference::Lit)
+    end
+
+  end
+end

data/spec/grammar/test_new.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Sexpr
+  describe Grammar, "new" do
+
+    subject{ Grammar.new }
+
+    it 'factors a module' do
+      subject.should be_a(Grammar)
+      subject.should be_a(Grammar::Options)
+      subject.should be_a(Grammar::Matching)
+      subject.should be_a(Grammar::Parsing)
+    end
+
+  end
+end

data/spec/grammar/test_parse.rb

@@ -2,31 +2,40 @@ require 'spec_helper'
 module Sexpr
   describe Grammar, "parse" do
 
-    def parser
-      Object.new.tap{|x|
-        def x.parse(s)
-          Struct.new(:value).new([:parsed, s])
-        end
-      }
+    def grammar
+      Sexpr.load(:parser => parser)
     end
 
-    def grammar(options = {})
-      Sexpr.load({}, {:parser => parser})
-    end
+    context 'when no parser is set' do
+      let(:parser){ nil }
 
-    it 'it accepts a string' do
-      grammar.parse("Hello world").should eq([:parsed, "Hello world"])
-    end
+      it 'raises an error' do
+        lambda{
+          grammar.parse("Hello world")
+        }.should raise_error(NoParserError)
+      end
 
-    it 'it accepts a path' do
-      grammar.parse(Path.here).should eq([:parsed, File.read(__FILE__)])
     end
 
-    it 'it accepts an IO' do
-      File.open(__FILE__, 'r') do |io|
-        grammar.parse(io).should eq([:parsed, File.read(__FILE__)])
+    context 'when a parser is set' do
+      let(:parser){
+        Object.new.extend Module.new{
+          include Parser
+          def parse(s, options = {})
+            [options[:root] || :parsed, input_text(s)]
+          end
+        }
+      }
+
+      it 'delegates the call to the parser' do
+        grammar.parse("Hello world").should eq([:parsed, "Hello world"])
       end
-    end
+
+      it 'passes options' do
+        grammar.parse("world", :root => :hello).should eq([:hello, "world"])
+      end
+
+    end # when a parser is set
 
   end
 end