sexpr 0.5.1 → 0.6.0

data/lib/sexpr/rewriter.rb

@@ -2,14 +2,6 @@ module Sexpr
   class Rewriter < Processor
     helper SexprCoercions
 
-    def self.grammar(sexpr_grammar)
-      @sexpr_grammar = sexpr_grammar
-    end
-
-    def sexpr_grammar
-      (self.class.instance_variable_get(:"@sexpr_grammar") || super) rescue Sexpr
-    end
-
     def copy_and_apply(sexpr)
       sexpr.sexpr_copy do |copy, child|
         copy << (Sexpr===child ? apply(child) : child)

data/lib/sexpr/version.rb

@@ -2,8 +2,8 @@ module Sexpr
   module Version
 
     MAJOR = 0
-    MINOR = 5
-    TINY  = 1
+    MINOR = 6
+    TINY  = 0
 
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')
@@ -11,4 +11,4 @@ module Sexpr
 
   end
   VERSION = Version.to_s
-end
+end

data/sexpr.gemspec

@@ -123,10 +123,10 @@ Gem::Specification.new do |s|
   # One call to add_development_dependency('gem_name', 'gem version requirement')
   # for each development dependency. These gems are required for developers
   #
-  s.add_development_dependency("epath", "~> 0.0.1")
+  s.add_development_dependency("path", "~> 1.3")
   s.add_development_dependency("citrus", "~> 2.4")
-  s.add_development_dependency("rake", "~> 0.9.2")
-  s.add_development_dependency("rspec", "~> 2.8")
+  s.add_development_dependency("rake", "~> 10.0")
+  s.add_development_dependency("rspec", "~> 2.10")
   s.add_development_dependency("wlang", "~> 0.10.2")
   
 

data/sexpr.noespec

@@ -1,15 +1,22 @@
 template-info:
-  name: "ruby"
-  version: 1.7.3
+  name: "rubygem.noe"
+  version: 2.0.1
   links:
     source: https://github.com/blambeau/noe
+  manifest:
+    tasks/unit_test.rake:
+      ignore: true
+      safe_override: false
+    tasks/spec_test.rake:
+      ignore: true
+      safe_override: false
 variables:
   lower:
     sexpr
   upper:
     Sexpr
   version:
-    0.5.1
+    0.6.0
   summary: |-
     A compilation framework around s-expressions
   description: |-
@@ -19,8 +26,8 @@ variables:
   links:
     - https://github.com/blambeau/sexp
   dependencies:
-    - {name: epath,     version: "~> 0.0.1",  groups: [development]}
+    - {name: path,      version: "~> 1.3",    groups: [development]}
     - {name: citrus,    version: "~> 2.4",    groups: [development]}
-    - {name: rake,      version: "~> 0.9.2",  groups: [development]}
-    - {name: rspec,     version: "~> 2.8",    groups: [development]}
+    - {name: rake,      version: "~> 10.0",   groups: [development]}
+    - {name: rspec,     version: "~> 2.10",   groups: [development]}
     - {name: wlang,     version: "~> 0.10.2", groups: [development]}

data/spec/integration/bool_expr/test_not_push.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+describe BoolExpr::NotPushProcessor do
+  subject{ BoolExpr }
+
+  def _(expr)
+    BoolExpr.sexpr(expr)
+  end
+
+  def rw(expr)
+    BoolExpr::NotPushProcessor.new.call(expr)
+  end
+
+  it 'does nothing on variable references' do
+    rw("not x").should eq([:bool_not, [:var_ref, "x"]])
+  end
+
+  it 'rewrites literals through negating them' do
+    rw("not true").should  eq(_ "false")
+    rw("not false").should eq(_ "true")
+  end
+
+  it 'rewrites not through removing them' do
+    rw("not not true").should eq(_ "true")
+  end
+
+  it 'rewrites or through and of negated terms' do
+    rw("not(x or y)").should eq(_ "not(x) and not(y)")
+  end
+
+  it 'rewrites and through or of negated terms' do
+    rw("not(x and y)").should eq(_ "not(x) or not(y)")
+  end
+
+  it 'rewrites recursively' do
+    rw("not(x and not(y))").should eq(_ "not(x) or y")
+  end
+
+end

data/spec/integration/bool_expr/test_parsing.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+describe BoolExpr, "the parsing feature" do
+  subject{ BoolExpr }
+
+  it 'parses boolean expressions without error' do
+    subject.parse("x and y").should be_a(Citrus::Match)
+    subject.parse("not(y)").should be_a(Citrus::Match)
+    subject.parse("not(true)").should be_a(Citrus::Match)
+  end
+
+  it 'provides a shortcut to get s-expressions directly' do
+    subject.sexpr("x and y").should eq([:bool_and, [:var_ref, "x"], [:var_ref, "y"]])
+  end
+
+end

data/spec/integration/bool_expr/test_tagging.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+describe BoolExpr, "the tagging feature" do
+  subject{ BoolExpr }
+
+  it 'tags parsing results with the Sexpr module' do
+    sexpr = subject.sexpr("x and y")
+    sexpr.should be_a(Sexpr)
+    sexpr.sexpr_type.should eq(:bool_and)
+    sexpr.sexpr_body.should eq([[:var_ref, "x"], [:var_ref, "y"]])
+  end
+
+  it 'tags parsing results with user modules' do
+    subject.sexpr("x and y").should be_a(BoolExpr::And)
+  end
+
+  it 'allows tagging manually' do
+    subject.sexpr([:bool_lit, true]).should be_a(BoolExpr::Lit)
+  end
+
+  it 'applies tagging recursively' do
+    sexpr = subject.sexpr([:bool_not, [:bool_lit, true]])
+    sexpr.last.should be_a(BoolExpr::Lit)
+  end
+
+end

data/spec/integration/bool_expr/test_validation.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+describe BoolExpr, 'the validation feature' do
+  subject{ BoolExpr }
+
+  it 'validates s-expressions' do
+    subject.match?([:bool_lit, true]).should be_true
+    subject.match?([:bool_lit, "x"]).should be_false
+  end
+
+  it 'validates s-expressions against specific rules' do
+    subject[:bool_lit].match?([:bool_lit, true]).should be_true
+    subject[:bool_and].match?([:bool_lit, true]).should be_false
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-require 'epath'
+require 'path'
 root = Path.backfind('.[lib]')
 
 require 'citrus'

data/spec/unit/grammar/matching/test_compile_rule.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+module Sexpr
+  module Grammar
+    describe Matching, "compile_rule" do
+      include Matching
+
+      subject{ compile_rule(:hello, defn) }
+
+      shared_examples_for 'a terminal rule' do
+        it{ should be_a(Matcher::Rule) }
+
+        it 'should have the expected defn' do
+          subject.defn.should be(defn)
+        end
+
+        it 'should have the correct name' do
+          subject.name.should eq(:hello)
+        end
+      end
+
+      shared_examples_for 'a non-terminal rule' do
+        it{ should be_a(Matcher::Rule) }
+
+        it 'should have the expected non-terminal' do
+          subject.defn.should be_a(Matcher::NonTerminal)
+          subject.defn.name.should eq(:hello)
+          subject.defn.defn.should be(defn)
+        end
+
+        it 'should have the correct name' do
+          subject.name.should eq(:hello)
+        end
+      end
+
+      context 'on Alternative' do
+        let(:defn){ Matcher::Alternative.new([]) }
+
+        it_should_behave_like "a terminal rule"
+      end
+
+      context 'on Terminal' do
+        let(:defn){ Matcher::Terminal.new(true) }
+
+        it_should_behave_like "a terminal rule"
+      end
+
+      context 'on Sequence' do
+        let(:defn){ Matcher::Sequence.new([]) }
+
+        it_should_behave_like "a non-terminal rule"
+      end
+
+    end
+  end
+end

data/spec/unit/grammar/matching/test_compile_rules.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Sexpr
+  module Grammar
+    describe Matching, "compile_rules" do
+      include Matching
+
+      let(:yaml){
+        <<-YAML
+          bool_and:
+            - [ bool_lit, bool_lit ]
+          bool_lit:
+            - true
+            - false
+          var_name:
+            !ruby/regexp /^[a-z]+$/
+        YAML
+      }
+
+      let(:rules){
+        YAML.load(yaml)
+      }
+
+      subject{ compile_rules(rules) }
+
+      it{ should be_a(Hash) }
+
+      it 'has expected keys' do
+        subject.keys.should eq([:bool_and, :bool_lit, :var_name])
+      end
+
+      it 'has expected values' do
+        subject.values.each do |val|
+          val.should be_a(Matcher::Rule)
+        end
+      end
+
+      it 'has expected defn' do
+        subject[:bool_and].defn.should be_a(Matcher::NonTerminal)
+        subject[:bool_lit].defn.should be_a(Matcher::Alternative)
+        subject[:var_name].defn.should be_a(Matcher::Terminal)
+      end
+
+    end
+  end
+end

data/spec/unit/grammar/tagging/test_tagging_module_for.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+module Sexpr::Grammar
+  describe Tagging, "tagging_module_for" do
+    include Tagging
+
+    module TaggingReference
+      module Node; end
+      module Not; end
+      module Lit; end
+    end
+
+    subject{ tagging_module_for(rulename) }
+
+    context 'when there is a tagging reference and a default tagging module' do
+
+      def tagging_reference
+        TaggingReference
+      end
+
+      def default_tagging_module
+        TaggingReference::Node
+      end
+
+      context 'when the module exists' do
+        let(:rulename){ :not }
+
+        it{ should be(TaggingReference::Not) }
+      end
+
+      context 'when the module does not exists' do
+        let(:rulename){ :blah }
+
+        it{ should be(TaggingReference::Node) }
+      end
+    end
+
+    context 'when there is a no tagging reference but default tagging module' do
+
+      def default_tagging_module
+        TaggingReference::Node
+      end
+
+      let(:rulename){ :not }
+
+      it{ should be(TaggingReference::Node) }
+    end
+
+    context 'when there is a a tagging reference and no default tagging module' do
+
+      def tagging_reference
+        TaggingReference
+      end
+
+      def default_tagging_module
+        nil
+      end
+
+      context 'when the module exists' do
+        let(:rulename){ :not }
+
+        it{ should be(TaggingReference::Not) }
+      end
+
+      context 'when the module does not exists' do
+        let(:rulename){ :blah }
+
+        it{ should be_nil }
+      end
+    end
+
+  end
+end

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

@@ -17,4 +17,4 @@ module Sexpr::Matcher
     end
 
   end
-end
+end

data/spec/unit/matcher/non_terminal/test_eat.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Sexpr::Matcher
+  describe NonTerminal, "eat" do
+
+    let(:defn){ Sequence.new [Terminal.new(/^[a-z]+$/)]  }
+    let(:rule){ NonTerminal.new :hello, defn             }
+
+    subject{ rule.eat(sexpr) }
+
+    context 'when match' do
+      let(:sexpr){ [[:hello, "world"], "!"] }
+
+      it{ should eq(["!"]) }
+    end
+
+    [
+      [:hello, "world"],
+      [:hello],
+      [],
+      [[]],
+      [nil],
+    ].each do |example|
+      context "when no match, e.g. #{example.inspect}" do
+        let(:sexpr){ example }
+
+        it{ should be_nil }
+      end
+    end
+
+  end
+end

data/spec/unit/matcher/non_terminal/test_match_q.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Sexpr::Matcher
+  describe NonTerminal, "match?" do
+
+    let(:defn){ Sequence.new [Terminal.new(/^[a-z]+$/)]  }
+    let(:rule){ NonTerminal.new :hello, defn             }
+
+    subject{ rule.match?(sexpr) }
+
+    context 'when match' do
+      let(:sexpr){ [:hello, "world"] }
+
+      it{ should be_true }
+    end
+
+    [
+      [[:hello, "world"]],
+      [:hello],
+      [],
+      [[]],
+      [nil],
+      nil
+    ].each do |example|
+      context "when no match, e.g. #{example.inspect}" do
+        let(:sexpr){ example }
+
+        it{ should be_false }
+      end
+    end
+
+  end
+end