sexpr 0.2.0 → 0.3.0

data/lib/sexpr/reference.rb

@@ -1,30 +0,0 @@
-module Sexpr
-  class Reference
-    include Element
-
-    attr_reader :rule_name
-    attr_reader :grammar
-
-    def initialize(rule_name, grammar)
-      @rule_name = rule_name
-      @grammar   = grammar
-    end
-
-    def rule
-      @rule ||= @grammar[@rule_name]
-    end
-
-    def match?(sexp)
-      rule && rule.match?(sexp)
-    end
-
-    def eat(sexp)
-      rule && rule.eat(sexp)
-    end
-
-    def inspect
-      "(ref #{rule_name}, #{rule.inspect})"
-    end
-
-  end # class Reference
-end # module Sexpr

data/lib/sexpr/rule.rb

@@ -1,29 +0,0 @@
-module Sexpr
-  class Rule
-    include Element
-
-    attr_reader :name
-    attr_reader :defn
-
-    def initialize(name, defn)
-      @name = name
-      @defn = defn
-    end
-
-    def match?(sexp)
-      return nil unless sexp.is_a?(Array)
-      return false unless sexp.first && (sexp.first == name)
-      defn.match?(sexp[1..-1])
-    end
-
-    def eat(sexp)
-      return nil unless match?(sexp.first)
-      sexp[1..-1]
-    end
-
-    def inspect
-      "(rule #{name}, #{defn.inspect})"
-    end
-
-  end # class Rule
-end # module Sexpr

data/lib/sexpr/sequence.rb

@@ -1,28 +0,0 @@
-module Sexpr
-  class Sequence
-    include Element
-
-    attr_reader :terms
-
-    def initialize(terms)
-      @terms = terms
-    end
-
-    def match?(sexp)
-      return nil unless sexp.is_a?(Array)
-      eat = eat(sexp)
-      eat && eat.empty?
-    end
-
-    def eat(sexp)
-      @terms.inject sexp do |rest,rule|
-        rest && rule.eat(rest)
-      end
-    end
-
-    def inspect
-      "(seq #{terms.inspect})"
-    end
-
-  end # class Sequence
-end # module Sexpr

data/lib/sexpr/terminal.rb

@@ -1,35 +0,0 @@
-module Sexpr
-  class Terminal
-    include Element
-
-    attr_reader :value
-
-    def initialize(value)
-      @value = value
-    end
-
-    def inspect
-      "(terminal #{value.inspect})"
-    end
-
-    def match?(sexp)
-      terminal_match?(sexp)
-    end
-
-    def eat(sexp)
-      match?(sexp.first) ? sexp[1..-1] : nil
-    end
-
-    private
-
-    def terminal_match?(term)
-      case @value
-      when Regexp
-        @value === term rescue false
-      when TrueClass, FalseClass, NilClass
-        @value == term
-      end
-    end
-
-  end # class Terminal
-end # module Sexpr

data/spec/bool_expr.yml

@@ -1,19 +0,0 @@
-bool_expr:
-  - bool_and
-  - bool_or
-  - bool_not
-  - var_ref
-  - bool_lit
-bool_and:
-  - [ bool_expr+ ]
-bool_or:
-  - [ bool_expr+ ]
-bool_not:
-  - [ bool_expr ]
-var_ref:
-  - [ var_name ]
-var_name:
-  !ruby/regexp /^[a-z]+$/
-bool_lit:
-  - true
-  - false

data/spec/grammar/test_compile_rule.rb

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

data/spec/grammar/test_compile_rule_defn.rb

@@ -1,98 +0,0 @@
-require 'spec_helper'
-module Sexpr
-  class Grammar; public :compile_rule_defn; end
-  describe Grammar, "compile_rule_defn" do
-
-    let(:grammar){ Grammar.new }
-    subject{ grammar.compile_rule_defn(arg) }
-
-    context 'with an Element' do
-      let(:arg){ 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(Terminal)
-        subject.value.should eq(true)
-      end
-    end
-
-    context "with false" do
-      let(:arg){ false }
-      it 'gives it false' do
-        subject.should be_a(Terminal)
-        subject.value.should eq(false)
-      end
-    end
-
-    context "with nil" do
-      let(:arg){ nil }
-      it 'gives it nil' do
-        subject.should be_a(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(Alternative)
-      end
-      it 'compiles its elements' do
-        subject.terms.size.should eq(3)
-        subject.terms.all?{|x| x.is_a?(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(Sequence)
-      end
-      it 'compiles its elements' do
-        subject.terms.size.should eq(3)
-        subject.terms.all?{|x| x.is_a?(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(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(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(Many)
-      end
-      it 'refers to the appropriate rule' do
-        subject.term.should be_a(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

data/spec/grammar/test_fetch.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Sexpr
-  describe Grammar, "fetch" do
-
-    let(:grammar){
-      Sexpr.load(:terminal => /[a-z]+/)
-    }
-
-    it 'returns the rule when it exists' do
-      grammar[:terminal].should be_a(Terminal)
-    end
-
-    it 'returns nil otherwise' do
-      grammar[:nosuchone].should be_nil
-    end
-
-  end
-end # module Sexpr

data/spec/grammar/test_root.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Sexpr
-  describe Grammar, "root" do
-
-    let(:rules){ {:t => /[a-z]+/, :nt => true} }
-
-    def grammar(options = {})
-      Sexpr.load(rules, options)
-    end
-
-    it 'is the first key by default' do
-      grammar.root.value.should eq(/[a-z]+/)
-    end
-
-    it 'is the specified rule when specified' do
-      grammar(:root => :nt).root.value.should eq(true)
-    end
-
-  end
-end

data/spec/test_bool_expr.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-module Sexpr
-  describe "the bool_expr grammar" do
-
-    let(:g){ Sexpr.load(Path.dir/"bool_expr.yml") }
-
-    it "allows checking validy of specific nodes" do
-      (g[:bool_lit] === true).should be_true
-      (g[:var_ref]  === [:var_ref, "x"]).should be_true
-      (g[:bool_and] === [:bool_and, true, false]).should be_true
-      (g[:bool_and] === [:bool_or, true, false]).should be_false
-    end
-
-    it 'allows checking the validity against the root rule' do
-      (g === true).should be_true
-      (g === false).should be_true
-      (g === [:bool_not, true]).should be_true
-      (g === [:var_ref, "x"]).should be_true
-      (g === [:bool_not, [:var_ref, "x"]]).should be_true
-    end
-
-    it 'detects wrong matches' do
-      (g === [:bool_not, [:something_else, "x"]]).should be_false
-    end
-
-  end
-end