rly 0.1.0 → 0.2.0

data/spec/parse/lr_table_spec.rb

@@ -0,0 +1,212 @@
+require "rly"
+require "rly/parse/grammar"
+require "rly/parse/lr_table"
+
+describe Rly::LRTable do
+  before :each do
+    g = Rly::Grammar.new([:NUMBER])
+
+    g.set_precedence('+', :left, 1)
+    g.set_precedence('-', :left, 1)
+
+    g.add_production(:statement, [:expression])
+    g.add_production(:expression, [:expression, '+', :expression])
+    g.add_production(:expression, [:expression, '-', :expression])
+    g.add_production(:expression, [:NUMBER])
+
+    g.set_start
+
+    g.build_lritems
+
+    @t = Rly::LRTable.new(g)
+  end
+
+  it "computes the LR(0) closure operation on I, where I is a set of LR(0) items" do
+    @t.instance_eval do
+      lr0_c = lr0_closure([@grammar.productions[0].lr_next])
+
+      lr0_c.length.should == 5
+      lr0_c.length.times do |i|
+        lr0_c[i].should == @grammar.productions[i].lr_next
+      end
+    end
+  end
+
+  it "computes the LR(0) goto function goto(I,X) where I is a set of LR(0) items and X is a grammar symbol" do
+    @t.instance_eval do
+      lr0_c = lr0_closure([@grammar.productions[0].lr_next])
+
+      lr0_g = lr0_goto(lr0_c, :statement)
+
+      lr0_g.length.should == 1
+      lr0_g[0].name.should == :"S'"
+      lr0_g[0].prod.should == [:statement, :'.']
+
+      lr0_g = lr0_goto(lr0_c, :expression)
+
+      lr0_g.length.should == 3
+      lr0_g[0].name.should == :statement
+      lr0_g[0].prod.should == [:expression, :'.']
+      lr0_g[1].name.should == :expression
+      lr0_g[1].prod.should == [:expression, :'.', '+', :expression]
+      lr0_g[2].name.should == :expression
+      lr0_g[2].prod.should == [:expression, :'.', '-', :expression]
+    end
+  end
+
+  it "computes the LR(0) sets of item function" do
+    @t.instance_eval do
+      lr0_i = lr0_items
+
+      reflist = Set.new(["S' -> . statement|statement -> . expression|expression -> . expression + expression|expression -> . expression - expression|expression -> . NUMBER",
+        "S' -> statement .",
+        "statement -> expression .|expression -> expression . + expression|expression -> expression . - expression",
+        "expression -> NUMBER .",
+        "expression -> expression + . expression|expression -> . expression + expression|expression -> . expression - expression|expression -> . NUMBER",
+        "expression -> expression - . expression|expression -> . expression + expression|expression -> . expression - expression|expression -> . NUMBER",
+        "expression -> expression + expression .|expression -> expression . + expression|expression -> expression . - expression",
+        "expression -> expression - expression .|expression -> expression . + expression|expression -> expression . - expression"])
+
+      lr0_i.length.should == reflist.length
+      Set.new(lr0_i.map { |a| a.map { |k| k.to_s } .join('|') }).inspect .should == reflist.inspect
+    end
+  end
+
+  it "creates a dictionary containing all of the non-terminals that might produce an empty production." do
+    # TODO: write a better spec
+    @t.instance_eval do
+      compute_nullable_nonterminals.should == {}
+    end
+  end
+
+  it "finds all of the non-terminal transitions" do
+    @t.instance_eval do
+      find_nonterminal_transitions(lr0_items).should == [[0, :statement], [0, :expression], [4, :expression], [5, :expression]]
+    end
+  end
+
+  it "computes the DR(p,A) relationships for non-terminal transitions" do
+    @t.instance_eval do
+      lr0_i = lr0_items
+      nullable = compute_nullable_nonterminals
+      trans = find_nonterminal_transitions(lr0_i)
+
+      dr_relation(lr0_i, trans[0], nullable).should == [:'$end']
+      dr_relation(lr0_i, trans[1], nullable).should == ['+', '-']
+    end
+  end
+
+  it "computes the READS() relation (p,A) READS (t,C)" do
+    # TODO: write a better spec
+    @t.instance_eval do
+      lr0_i = lr0_items
+      nullable = compute_nullable_nonterminals
+      trans = find_nonterminal_transitions(lr0_i)
+
+      reads_relation(lr0_i, trans[0], nullable).should == []
+      reads_relation(lr0_i, trans[1], nullable).should == []
+    end
+  end
+
+  it "computes the read sets given a set of LR(0) items" do
+    @t.instance_eval do
+      lr0_i = lr0_items
+      nullable = compute_nullable_nonterminals
+      trans = find_nonterminal_transitions(lr0_i)
+
+      compute_read_sets(lr0_i, trans, nullable).should == {
+        [0, :statement]  => [:'$end'],
+        [5, :expression] => ['+', '-'],
+        [4, :expression] => ['+', '-'],
+        [0, :expression] => ['+', '-']
+      }
+    end
+  end
+
+  it "determines the lookback and includes relations" do
+    @t.instance_eval do
+      lr0_i = lr0_items
+      nullable = compute_nullable_nonterminals
+      trans = find_nonterminal_transitions(lr0_i)
+
+      lookd, included = compute_lookback_includes(lr0_i, trans, nullable)
+
+      included.should == {
+        [5, :expression] => [ [0, :expression], [4, :expression], [5, :expression], [5, :expression] ],
+        [4, :expression] => [ [0, :expression], [4, :expression], [4, :expression], [5, :expression] ],
+        [0, :expression] => [ [0, :statement] ]
+      }
+
+      lookd = lookd.each_with_object({}) { |(k, v), h| h[k] = v.map { |n,i| [n, i.to_s] } }
+      
+      # NOTE: this one goes not map 1-1 to pry as we have differencies in lr0_items order. Looks valid though.
+      expected = {
+        [0, :statement] => [ [2, "statement -> expression ."] ],
+        [0, :expression]=> [
+          [6, "expression -> expression + expression ."],
+          [6, "expression -> expression . + expression"],
+          [6, "expression -> expression . - expression"],
+          [7, "expression -> expression - expression ."],
+          [7, "expression -> expression . + expression"],
+          [7, "expression -> expression . - expression"],
+          [3, "expression -> NUMBER ."]
+        ],
+        [4, :expression] => [
+        [6, "expression -> expression + expression ."],
+          [6, "expression -> expression . + expression"],
+          [6, "expression -> expression . - expression"],
+          [7, "expression -> expression - expression ."],
+          [7, "expression -> expression . + expression"],
+          [7, "expression -> expression . - expression"],
+          [3, "expression -> NUMBER ."]
+        ],
+        [5, :expression] => [
+          [6, "expression -> expression + expression ."],
+          [6, "expression -> expression . + expression"],
+          [6, "expression -> expression . - expression"],
+          [7, "expression -> expression - expression ."],
+          [7, "expression -> expression . + expression"],
+          [7, "expression -> expression . - expression"],
+          [3, "expression -> NUMBER ."]
+        ]}
+
+      lookd.should == expected
+
+    end
+  end
+
+  it "computes the follow sets given a set of LR(0) items, a set of non-terminal transitions, a readset, and an include set" do
+    @t.instance_eval do
+      lr0_i = lr0_items
+      nullable = compute_nullable_nonterminals
+      trans = find_nonterminal_transitions(lr0_i)
+      readsets = compute_read_sets(lr0_i, trans, nullable)
+      lookd, included = compute_lookback_includes(lr0_i, trans, nullable)
+
+      compute_follow_sets(trans, readsets, included).should == {
+        [0, :statement] => [:'$end'],
+        [5, :expression] => ['+', '-', :'$end'],
+        [4, :expression] => ['+', '-', :'$end'],
+        [0, :expression] => ['+', '-', :'$end']
+      }
+    end
+  end
+
+  it "attaches the lookahead symbols to grammar rules" do
+    pending "verify that values in LRItem#lookaheads are meaningful"
+    @t.instance_eval do
+      lr0_i = lr0_items
+      nullable = compute_nullable_nonterminals
+      trans = find_nonterminal_transitions(lr0_i)
+      readsets = compute_read_sets(lr0_i, trans, nullable)
+      lookd, included = compute_lookback_includes(lr0_i, trans, nullable)
+      followsets = compute_follow_sets(trans, readsets, included)
+
+      add_lookaheads(lookd, followsets)
+    end
+  end
+
+  it "parses the table" do
+    expect { @t.parse_table } .not_to raise_error
+  end
+end

data/spec/parse/production_spec.rb

@@ -0,0 +1,18 @@
+require "rly/parse/production"
+
+describe Rly::Production do
+  it "has a length same as length of its symbols" do
+    p = Rly::Production.new(1, 'test', ['test', '+', 'test'])
+    p.length.should == 3
+  end
+
+  it "converts to_s as source -> symbols" do
+    p = Rly::Production.new(1, 'test', ['test', '+', 'test'])
+    p.to_s.should == 'test -> test + test'
+  end
+
+  it "builds a list of unique symbols" do
+    p = Rly::Production.new(1, 'test', ['test', '+', 'test'])
+    p.usyms.should == ['test', '+']
+  end
+end

data/spec/parse/rule_parser_spec.rb

@@ -0,0 +1,20 @@
+require "rly"
+require "rly/parse/rule_parser"
+
+describe Rly::RuleParser do
+  it "parses a simple rule string" do
+    s = 'expression : expression "+" expression
+                    | expression "-" expression
+                    | expression "*" expression
+                    | expression "/" expression'
+    p = Rly::RuleParser.new
+
+    productions = p.parse(s)
+
+    productions.length.should == 4
+    productions[0].should == [:expression, [:expression, '+', :expression]]
+    productions[1].should == [:expression, [:expression, '-', :expression]]
+    productions[2].should == [:expression, [:expression, '*', :expression]]
+    productions[3].should == [:expression, [:expression, '/', :expression]]
+  end
+end

data/spec/parse/yacc_spec.rb

@@ -0,0 +1,57 @@
+require "rly"
+require "rly/parse/grammar"
+
+describe Rly::Yacc do
+  it "acceps a set of rules" do
+    expect {
+      Class.new(Rly::Yacc) do
+        rule 'statement : expression' do |e|
+          @val = e
+        end
+      end
+      } .not_to raise_error
+  end
+
+  it "accepts an instance of lexer as an argument" do
+    testParser = Class.new(Rly::Yacc) do
+      rule 'statement : VALUE' do |v|
+        @val = v
+      end
+    end
+    
+    testLexer = Class.new(Rly::Lex) do
+      token :VALUE, /[a-z]+/
+    end
+    m = testLexer.new
+
+    expect {
+      p = testParser.new(m)
+      p.lex.should == m
+    } .not_to raise_error
+  end
+
+  it "can use built in lexer if one is defined" do
+    testParser = Class.new(Rly::Yacc) do
+      lexer do
+        token :VALUE, /[a-z]+/
+      end
+
+      rule 'statement : VALUE' do |v|
+        @val = v
+      end
+    end
+
+    p = testParser.new
+    p.lex.should be_kind_of(Rly::Lex)
+  end
+
+  it "raises error if no lexer is built in and no given" do
+    testParser = Class.new(Rly::Yacc) do
+      rule 'statement : VALUE' do |v|
+        @val = v
+      end
+    end
+
+    expect { testParser.new } .to raise_error(ArgumentError)
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,10 @@
 require "rubygems"
 require "bundler/setup"
+begin
+  require "pry-nav"
+rescue LoadError
+  #
+end
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rly
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-09 00:00:00.000000000 Z
+date: 2012-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -41,12 +41,28 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- assets/ply_dump.erb
 - lib/rly.rb
 - lib/rly/lex.rb
 - lib/rly/lex_token.rb
+- lib/rly/parse/grammar.rb
+- lib/rly/parse/lr_item.rb
+- lib/rly/parse/lr_table.rb
+- lib/rly/parse/ply_dump.rb
+- lib/rly/parse/production.rb
+- lib/rly/parse/rule_parser.rb
+- lib/rly/parse/yacc_production.rb
+- lib/rly/parse/yacc_symbol.rb
 - lib/rly/version.rb
+- lib/rly/yacc.rb
 - rly.gemspec
-- spec/lex/lexer_spec.rb
+- spec/lex/lex_spec.rb
+- spec/parse/calc_spec.rb
+- spec/parse/grammar_spec.rb
+- spec/parse/lr_table_spec.rb
+- spec/parse/production_spec.rb
+- spec/parse/rule_parser_spec.rb
+- spec/parse/yacc_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses: []
@@ -73,6 +89,12 @@ signing_key:
 specification_version: 3
 summary: A simple ruby implementation of lex and yacc, based on Python's ply
 test_files:
-- spec/lex/lexer_spec.rb
+- spec/lex/lex_spec.rb
+- spec/parse/calc_spec.rb
+- spec/parse/grammar_spec.rb
+- spec/parse/lr_table_spec.rb
+- spec/parse/production_spec.rb
+- spec/parse/rule_parser_spec.rb
+- spec/parse/yacc_spec.rb
 - spec/spec_helper.rb
 has_rdoc: