rubypeg 0.0.2

data/README

@@ -0,0 +1,67 @@
+= RubyPeg
+
+RubyPeg helps you to create readable Parsing Expression Grammars (PEG) in ruby.
+
+This software is (c) 2010 Green on Black Ltd and distributed under the open source MIT[http://www.opensource.org/licenses/mit-license.php] licence. (See LICENCE for the wording).
+
+If you like this code, employ us: http://www.greenonblack.com
+
+= An example
+
+class Arithmetic < RubyPeg
+  
+  def root
+    arithmetic
+  end
+  
+  def arithmetic
+    node :arithmetic do
+      one_or_more { expression } && ignore { terminal(/\z/) }
+    end
+  end
+  
+  def expression
+    subtraction || addition || division || multiplication || brackets || number
+  end
+  
+  def brackets
+    node :brackets do
+      ignore { terminal("(") } && spacing && expression && spacing && ignore { terminal(")") }
+    end
+  end
+  
+  def multiplication
+    node :multiplication do
+      (brackets || number) && spacing && ignore { terminal("*") } && spacing && expression
+    end
+  end
+  
+  def division
+    node :division do
+      (brackets || number) && spacing && ignore { terminal("/") } && spacing && expression
+    end
+  end
+  
+  def addition
+    node :addition do
+      (brackets || number) && spacing && ignore { terminal("+") } && spacing && expression
+    end
+  end
+  
+  def subtraction
+    node :subtraction do
+      (brackets || number) && spacing && ignore { terminal("-") } && spacing && expression
+    end
+  end
+  
+  def number
+    terminal(/[-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?/)
+  end
+  
+  def spacing
+    ignore { terminal(/[ \t]*/) }
+  end
+  
+end
+
+Arithmetic.parse("(1+1)+2").to_ast # [:arithmetic,[:addition,[:brackets,[:addition,'1','1']],'2']]

data/bin/text-peg2ruby-peg

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+require 'textpeg2rubypeg'
+require 'textpeg'
+require 'rubypeg'
+
+if ARGV[0]
+  input = IO.readlines(ARGV[0]).join
+  ruby = TextPeg2RubyPeg.new
+  peg = TextPeg.parse(input)
+  peg.visit(ruby)
+  if ARGV[1]
+    File.open(ARGV[1],'w') { |f| f.puts ruby.to_ruby }
+  else
+    $stdout.puts ruby.to_ruby
+  end
+else
+  $stdout.puts "Usage:   text-peg2ruby-peg [text-peg-input-filename] [ruby-peg-output-filename]"
+  $stdout.puts "Help:    Compiles text format parsing expression grammars into a ruby parser."
+  $stdout.puts "         See http://github.com/tamc/ruby-peg for more information."
+  $stdout.puts "Version: 0.0.1"
+end

data/examples/arithmetic/arithmetic_peg.rb

@@ -0,0 +1,57 @@
+require 'rubypeg'
+
+class Arithmetic < RubyPeg
+  
+  def root
+    arithmetic
+  end
+  
+  def arithmetic
+    node :arithmetic do
+      one_or_more { expression } && ignore { terminal(/\z/) }
+    end
+  end
+  
+  def expression
+    subtraction || addition || division || multiplication || brackets || number
+  end
+  
+  def brackets
+    node :brackets do
+      ignore { terminal("(") } && spacing && expression && spacing && ignore { terminal(")") }
+    end
+  end
+  
+  def multiplication
+    node :multiplication do
+      (brackets || number) && spacing && ignore { terminal("*") } && spacing && expression
+    end
+  end
+  
+  def division
+    node :division do
+      (brackets || number) && spacing && ignore { terminal("/") } && spacing && expression
+    end
+  end
+  
+  def addition
+    node :addition do
+      (brackets || number) && spacing && ignore { terminal("+") } && spacing && expression
+    end
+  end
+  
+  def subtraction
+    node :subtraction do
+      (brackets || number) && spacing && ignore { terminal("-") } && spacing && expression
+    end
+  end
+  
+  def number
+    terminal(/[-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?/)
+  end
+  
+  def spacing
+    ignore { terminal(/[ \t]*/) }
+  end
+  
+end

data/examples/arithmetic/arithmetic_peg.txt

@@ -0,0 +1,9 @@
+arithmetic      := expression+ `/\z/
+expression       = subtraction | addition | division | multiplication | brackets | number
+brackets        := `"(" spacing expression spacing `")"
+multiplication  := (brackets | number ) spacing `'*' spacing expression
+division        := (brackets | number ) spacing `'/' spacing expression
+addition        := (brackets | number ) spacing `'+' spacing expression
+subtraction     := (brackets | number ) spacing `'-' spacing expression
+number           = /[-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?/
+spacing          = `/[ \t]*/

data/examples/arithmetic/arithmetic_peg_spec.rb

@@ -0,0 +1,49 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.])
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. .. lib])
+require 'rubypeg'
+require 'arithmetic_peg'
+
+describe Arithmetic do
+  
+  def check(text)
+    puts
+    e = Arithmetic.new
+    e.parse(text)
+    e.pretty_print_cache
+    puts
+  end
+  
+  it "parses decimal numbers, including those in scientific notation" do
+    Arithmetic.parse("1").to_ast.should == [:arithmetic,'1']
+    Arithmetic.parse("103.287").to_ast.should == [:arithmetic,'103.287']
+    Arithmetic.parse("-1.0E-27").to_ast.should == [:arithmetic,'-1.0E-27']
+  end
+  
+  it "parses sums of decimal numbers" do
+    Arithmetic.parse("1+1").to_ast.should == [:arithmetic,[:addition,'1','1']]
+  end
+  
+  it "parses series of sums" do
+    Arithmetic.parse("1+1+2").to_ast.should == [:arithmetic,[:addition,'1',[:addition,'1','2']]]
+  end
+  
+  it "parses a series of sums with brackets" do
+    Arithmetic.parse("(1+1)+2").to_ast.should == [:arithmetic,[:addition,[:brackets,[:addition,'1','1']],'2']]
+    Arithmetic.parse("1+(1+2)").to_ast.should == [:arithmetic,[:addition,'1',[:brackets,[:addition,'1','2']]]]
+    Arithmetic.parse("(1+1)+(1+2)").to_ast.should == [:arithmetic,[:addition,[:brackets,[:addition,'1','1']],[:brackets,[:addition,'1','2']]]]
+    Arithmetic.parse("((1+1)+(1+2))").to_ast.should == [:arithmetic,[:brackets,[:addition,[:brackets,[:addition,'1','1']],[:brackets,[:addition,'1','2']]]]]
+  end
+  
+  it "parses subtractions" do
+    Arithmetic.parse("1-1").to_ast.should == [:arithmetic,[:subtraction,'1','1']]
+  end
+  
+  it "parses multiplication" do
+    Arithmetic.parse("1*1").to_ast.should == [:arithmetic,[:multiplication,'1','1']]
+  end
+  
+  it "parses division" do
+    Arithmetic.parse("1/1").to_ast.should == [:arithmetic,[:division,'1','1']]
+  end
+
+end

data/examples/arithmetic/calculator.rb

@@ -0,0 +1,40 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. .. lib])
+$:.unshift File.join(File.dirname(__FILE__), *%w[.])
+require 'rubypeg'
+require 'arithmetic_peg'
+
+module TerminalNode
+  def build(builder)
+    self.to_f
+  end
+end
+
+class CalculationEngine
+  
+  def addition(left,right)
+    left.build(self) + right.build(self)
+  end
+  
+  def subtraction(left,right)
+    left.build(self) - right.build(self)
+  end
+  
+  def multiplication(left,right)
+    left.build(self) * right.build(self)
+  end
+  
+  def division(left,right)
+    left.build(self) / right.build(self)    
+  end
+  
+end
+
+class Calculator
+  
+  def self.calculate(sum)
+    ast = Arithmetic.parse(sum)
+    answer = ast.build(CalculationEngine.new)
+    answer
+  end
+  
+end

data/examples/arithmetic/calculator_spec.rb

@@ -0,0 +1,26 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.])
+require 'calculator'
+
+describe Calculator do
+
+  it "should know that 1 + 1 = 2.0" do
+    Calculator.calculate("1+1").should == 2.0
+  end
+  
+  it "should know that 5.0 - 1.3 = 3.7" do
+    Calculator.calculate("5.0 - 1.3").should == 3.7
+  end
+
+  it "should know that -12.3e-27 * 5 =  6.15e-26" do
+    Calculator.calculate("-12.3e-27*5").should == -6.15e-26
+  end
+
+  it "should know that 1000/10 =  100" do
+    Calculator.calculate("1000/10").should == 100
+  end
+  
+  it "should know that (1+3)*(8*2) = 64" do
+    Calculator.calculate("(1+3)*(8*2)").should == 64
+  end
+  
+end

data/examples/excel/excel_peg.txt

@@ -0,0 +1,35 @@
+formula                         := expression+
+expression                       = string_join | arithmetic | comparison | thing
+thing                            = function | brackets | string | any_reference | percentage | number | boolean | named_reference | prefix
+function                        := /[A-Z]+/ `'(' expression? (`',' expression)* `')'
+brackets                        := `'(' expression `')'
+string_join                     := thing (`"&" thing)+
+arithmetic                      := thing (operator thing)+
+comparison                      := thing comparator thing
+comparator                      := '>=' | '<=' | '<>' | '>' | '<' | '='
+string                          := `'"' /[^"]*/ `'"'
+any_reference                    =  table_reference | quoted_sheet_reference | sheet_reference | sheetless_reference
+percentage                      := /[-+]?[0-9]+\.?[0-9]*/ `'%'
+number                          := /[-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?/
+operator                        := '+' | '-' | '/' | '*' | '^'
+table_reference                  = qualified_table_reference | local_table_reference
+qualified_table_reference       := /[a-zA-Z0-9]+/ table_column
+local_table_reference           := table_column
+table_column                     = `'[' /[^\u005d]*/ `']'
+named_reference                 := /[a-zA-Z][\w_.]+/
+quoted_sheet_reference          := single_quoted_string `'!' sheetless_reference
+sheet_reference                 := /[a-zA-Z][\w_]+/ `'!' sheetless_reference
+single_quoted_string             = `"'" /[^']*/ `"'"
+sheetless_reference              = column_range | row_range | area | cell
+column_range                    := column `':' column
+row_range                       := row `':' row
+area                            := reference `':' reference
+cell                            := reference
+row                              = /\$?\d+/
+column                           = /\$?[A-Z]+/
+reference                        = /\$?[A-Z]+\$?[0-9]+/
+boolean                          = boolean_true | boolean_false
+boolean_true                    := `'TRUE'
+boolean_false                   := `'FALSE'
+prefix                          := /[-+]/
+

data/examples/excel/excel_peg_spec.rb

@@ -0,0 +1,139 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.])
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. .. lib])
+require 'textpeg2rubypeg'
+text_peg = IO.readlines(File.join(File.dirname(__FILE__),'excel_peg.txt')).join
+ast = TextPeg.parse(text_peg)
+# puts ast.to_ast
+# exit
+builder = TextPeg2RubyPeg.new
+ruby = ast.build(builder)
+Kernel.eval(ruby)
+
+describe Formula do
+  
+  def check(text)
+    puts
+    e = Formula.new
+    e.parse(text)
+    e.pretty_print_cache
+    puts
+  end
+  
+  it "returns formulas" do
+    Formula.parse('1+1').to_ast.first.should == :formula
+  end
+  
+  it "returns cells" do
+    Formula.parse('$A$1').to_ast.should == [:formula,[:cell,'$A$1']]
+    Formula.parse('A1').to_ast.should == [:formula,[:cell,'A1']]    
+    Formula.parse('$A1').to_ast.should == [:formula,[:cell,'$A1']]    
+    Formula.parse('A$1').to_ast.should == [:formula,[:cell,'A$1']]    
+    Formula.parse('AAA1123').to_ast.should == [:formula,[:cell,'AAA1123']]
+  end
+  
+  it "returns areas" do
+    Formula.parse('$A$1:$Z$1').to_ast.should == [:formula,[:area,'$A$1','$Z$1']]
+    Formula.parse('A1:$Z$1').to_ast.should == [:formula,[:area,'A1','$Z$1']]    
+  end
+  
+  it "returns row ranges" do
+    Formula.parse('$1:$1000').to_ast.should == [:formula,[:row_range,'$1','$1000']]
+    Formula.parse('1000:1').to_ast.should == [:formula,[:row_range,'1000','1']]    
+  end
+  
+  it "returns column ranges" do
+    Formula.parse('$C:$AZ').to_ast.should == [:formula,[:column_range,'$C','$AZ']]
+    Formula.parse('C:AZ').to_ast.should == [:formula,[:column_range,'C','AZ']]    
+  end
+  
+  it "returns references to other sheets" do
+    Formula.parse('sheet1!$A$1').to_ast.should == [:formula,[:sheet_reference,'sheet1',[:cell,'$A$1']]]    
+    Formula.parse('sheet1!$A$1:$Z$1').to_ast.should == [:formula,[:sheet_reference,'sheet1',[:area,'$A$1','$Z$1']]]
+    Formula.parse('sheet1!$1:$1000').to_ast.should == [:formula,[:sheet_reference,'sheet1',[:row_range,'$1','$1000']]]
+    Formula.parse('sheet1!$C:$AZ').to_ast.should == [:formula,[:sheet_reference,'sheet1',[:column_range,'$C','$AZ']]]
+  end
+  
+  it "returns references to other sheets with extended names" do
+    Formula.parse("'sheet 1'!$A$1").to_ast.should == [:formula,[:quoted_sheet_reference,'sheet 1',[:cell,'$A$1']]]    
+    Formula.parse("'sheet 1'!$A$1:$Z$1").to_ast.should == [:formula,[:quoted_sheet_reference,'sheet 1',[:area,'$A$1','$Z$1']]]
+    Formula.parse("'sheet 1'!$1:$1000").to_ast.should == [:formula,[:quoted_sheet_reference,'sheet 1',[:row_range,'$1','$1000']]]
+    Formula.parse("'sheet 1'!$C:$AZ").to_ast.should == [:formula,[:quoted_sheet_reference,'sheet 1',[:column_range,'$C','$AZ']]]
+  end
+  
+  it "returns numbers" do
+    Formula.parse("1").to_ast.should == [:formula,[:number,'1']]
+    Formula.parse("103.287").to_ast.should == [:formula,[:number,'103.287']]
+    Formula.parse("-1.0E-27").to_ast.should == [:formula,[:number,'-1.0E-27']]
+  end
+
+  it "returns percentages" do
+    Formula.parse("1%").to_ast.should == [:formula,[:percentage,'1']]
+    Formula.parse("103.287%").to_ast.should == [:formula,[:percentage,'103.287']]
+    Formula.parse("-1.0%").to_ast.should == [:formula,[:percentage,'-1.0']]
+  end
+  
+  it "returns strings" do
+    Formula.parse('"A handy string"').to_ast.should == [:formula,[:string,"A handy string"]]
+    Formula.parse('"$A$1"').to_ast.should == [:formula,[:string,"$A$1"]]  
+  end
+  
+  it "returns string joins" do
+    Formula.parse('"A handy string"&$A$1').to_ast.should == [:formula,[:string_join,[:string,"A handy string"],[:cell,'$A$1']]]
+    Formula.parse('$A$1&"A handy string"').to_ast.should == [:formula,[:string_join,[:cell,'$A$1'],[:string,"A handy string"]]]
+    Formula.parse('$A$1&"A handy string"&$A$1').to_ast.should == [:formula,[:string_join,[:cell,'$A$1'],[:string,"A handy string"],[:cell,'$A$1'],]]
+    Formula.parse('$A$1&$A$1&$A$1').to_ast.should == [:formula,[:string_join,[:cell,'$A$1'],[:cell,'$A$1'],[:cell,'$A$1'],]]
+    Formula.parse('"GW"&ISERR($AA$1)').to_ast.should == [:formula,[:string_join,[:string,'GW'],[:function,'ISERR',[:cell,'$AA$1']]]]
+  end
+  
+  it "returns numeric operations" do
+    Formula.parse('$A$1+$A$2+1').to_ast.should == [:formula,[:arithmetic,[:cell,'$A$1'],[:operator,"+"],[:cell,'$A$2'],[:operator,"+"],[:number,'1']]]
+    Formula.parse('$A$1-$A$2-1').to_ast.should == [:formula,[:arithmetic,[:cell,'$A$1'],[:operator,"-"],[:cell,'$A$2'],[:operator,"-"],[:number,'1']]]
+    Formula.parse('$A$1*$A$2*1').to_ast.should == [:formula,[:arithmetic,[:cell,'$A$1'],[:operator,"*"],[:cell,'$A$2'],[:operator,"*"],[:number,'1']]]
+    Formula.parse('$A$1/$A$2/1').to_ast.should == [:formula,[:arithmetic,[:cell,'$A$1'],[:operator,"/"],[:cell,'$A$2'],[:operator,"/"],[:number,'1']]            ]
+    Formula.parse('$A$1^$A$2^1').to_ast.should == [:formula,[:arithmetic,[:cell,'$A$1'],[:operator,"^"],[:cell,'$A$2'],[:operator,"^"],[:number,'1']]]
+  end
+  
+  it "returns expressions in brackets" do
+    Formula.parse('($A$1+$A$2)').to_ast.should == [:formula,[:brackets,[:arithmetic,[:cell,'$A$1'],[:operator,"+"],[:cell,'$A$2']]]]
+    Formula.parse('($A$1+$A$2)+2').to_ast.should == [:formula, [:arithmetic, [:brackets, [:arithmetic, [:cell,'$A$1'], [:operator,"+"], [:cell,'$A$2']]], [:operator,"+"], [:number,'2']]]
+    Formula.parse('($A$1+$A$2)+(2+(1*2))').to_ast.should == [:formula, [:arithmetic, [:brackets, [:arithmetic, [:cell,'$A$1'], [:operator,"+"], [:cell,'$A$2']]], [:operator,"+"], [:brackets, [:arithmetic, [:number,'2'], [:operator,'+'] ,[:brackets, [:arithmetic, [:number,'1'], [:operator,'*'], [:number,'2']]]]]]]  
+  end
+  
+  it "returns comparisons" do
+    Formula.parse('$A$1>$A$2').to_ast.should  == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,">"],[:cell,'$A$2']]]
+    Formula.parse('$A$1<$A$2').to_ast.should  == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,"<"],[:cell,'$A$2']]]
+    Formula.parse('$A$1=$A$2').to_ast.should  == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,"="],[:cell,'$A$2']]]
+    Formula.parse('$A$1>=$A$2').to_ast.should == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,">="],[:cell,'$A$2']]]
+    Formula.parse('$A$1<=$A$2').to_ast.should == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,"<="],[:cell,'$A$2']]]
+    Formula.parse('$A$1<>$A$2').to_ast.should == [:formula,[:comparison,[:cell,'$A$1'],[:comparator,"<>"],[:cell,'$A$2']]]
+  end
+  
+  it "returns functions" do
+    Formula.parse('PI()').to_ast.should  == [:formula,[:function,'PI']]
+    Formula.parse('ERR($A$1)').to_ast.should  == [:formula,[:function,'ERR',[:cell,'$A$1']]]
+    Formula.parse('SUM($A$1,sheet1!$1:$1000,1)').to_ast.should  == [:formula,[:function,'SUM',[:cell,'$A$1'],[:sheet_reference,'sheet1',[:row_range,'$1','$1000']],[:number,'1']]]
+  end
+  
+  it "returns fully qualified structured references (i.e., Table[column])" do
+    Formula.parse('DeptSales[Sale Amount]').to_ast.should  == [:formula,[:qualified_table_reference,'DeptSales','Sale Amount']]
+    #Formula.parse("DeptSales[Sale'] Amount]").to_ast.should  == [:formula,[:qualified_table_reference,'DeptSales','Sale Amount']]
+  end
+  
+  it "returns booleans" do
+    Formula.parse("TRUE*FALSE").to_ast.should == [:formula,[:arithmetic,[:boolean_true],[:operator,'*'],[:boolean_false]]]
+  end
+  
+  it "returns prefixes (+/-)" do
+    Formula.parse("-(3-1)").to_ast.should == [:formula,[:prefix,'-'],[:brackets,[:arithmetic,[:number,'3'],[:operator,'-'],[:number,'1']]]]
+  end
+  
+  it "returns local structured references (i.e., [column])" do
+    Formula.parse('[Sale Amount]').to_ast.should  == [:formula,[:local_table_reference,'Sale Amount']]
+    #Formula.parse("DeptSales[Sale'] Amount]").to_ast.should  == [:formula,[:qualified_table_reference,'DeptSales','Sale Amount']]
+  end
+  
+  it "returns named references" do
+    Formula.parse('EF.NaturalGas.N2O').to_ast.should == [:formula,[:named_reference,'EF.NaturalGas.N2O']]
+  end
+  
+end