formula_dsl 0.1.1 → 0.2.0

data/Gemfile

@@ -1,6 +1,9 @@
 source "http://rubygems.org"
 
 gem 'parslet', '~> 1.3.0'
-gem 'jeweler', '~> 1.8.3'
-gem 'rake', '~> 0.9.2'
-gem 'rspec', '~> 2.9.0'
+
+group :development, :test do
+  gem 'rspec', '~> 2.9.0'
+  gem 'jeweler', '~> 1.8.3'
+  gem 'rake', '> 0.9.2'
+end

data/Gemfile.lock

@@ -12,7 +12,7 @@ GEM
     json (1.6.5)
     parslet (1.3.0)
       blankslate (~> 2.0)
-    rake (0.9.2)
+    rake (0.9.2.2)
     rdoc (3.12)
       json (~> 1.4)
     rspec (2.9.0)
@@ -30,5 +30,5 @@ PLATFORMS
 DEPENDENCIES
   jeweler (~> 1.8.3)
   parslet (~> 1.3.0)
-  rake (~> 0.9.2)
+  rake (> 0.9.2)
   rspec (~> 2.9.0)

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/formula_dsl.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "formula_dsl"
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sergio Junior"]
-  s.date = "2012-03-22"
+  s.date = "2012-04-03"
   s.description = " External DSL to express math operations like you do in MSExcel formula bar. The parser generate a AST (Hash) for a given expression. "
   s.email = "sergior.jr@gmail.com"
   s.extra_rdoc_files = [
@@ -28,14 +28,26 @@ Gem::Specification.new do |s|
     "VERSION",
     "formula_dsl.gemspec",
     "lib/formula_dsl.rb",
-    "lib/formula_dsl/formula_parser.rb",
-    "spec/formula_dsl/formula_parser_spec.rb",
+    "lib/formula_dsl/binary_expression.rb",
+    "lib/formula_dsl/binary_expression_factory.rb",
+    "lib/formula_dsl/binary_operations.rb",
+    "lib/formula_dsl/function_expression.rb",
+    "lib/formula_dsl/function_expression_factory.rb",
+    "lib/formula_dsl/functions.rb",
+    "lib/formula_dsl/parser.rb",
+    "lib/formula_dsl/transformer.rb",
+    "spec/formula_dsl/binary_expression_factory_spec.rb",
+    "spec/formula_dsl/binary_expression_spec.rb",
+    "spec/formula_dsl/function_expression_factory_spec.rb",
+    "spec/formula_dsl/function_expression_spec.rb",
+    "spec/formula_dsl/parser_spec.rb",
+    "spec/formula_dsl/transformer_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/sergiojunior/formula_dsl"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.17"
+  s.rubygems_version = "1.8.21"
   s.summary = "External DSL that creates AST representation (Hash) for a given mathematical expression."
 
   if s.respond_to? :specification_version then
@@ -43,20 +55,20 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<parslet>, ["~> 1.3.0"])
-      s.add_runtime_dependency(%q<jeweler>, ["~> 1.8.3"])
-      s.add_runtime_dependency(%q<rake>, ["~> 0.9.2"])
-      s.add_runtime_dependency(%q<rspec>, ["~> 2.9.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.9.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<rake>, ["> 0.9.2"])
     else
       s.add_dependency(%q<parslet>, ["~> 1.3.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
-      s.add_dependency(%q<rake>, ["~> 0.9.2"])
       s.add_dependency(%q<rspec>, ["~> 2.9.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<rake>, ["> 0.9.2"])
     end
   else
     s.add_dependency(%q<parslet>, ["~> 1.3.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
-    s.add_dependency(%q<rake>, ["~> 0.9.2"])
     s.add_dependency(%q<rspec>, ["~> 2.9.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<rake>, ["> 0.9.2"])
   end
 end
 

data/lib/formula_dsl/binary_expression.rb

@@ -0,0 +1,26 @@
+#encoding: utf-8
+module FormulaDSL
+
+  class BinaryExpression
+    attr_reader :operator, :left_term, :right_term
+
+    def initialize(operator, left_term, right_term)
+      @operator = operator
+      @left_term = left_term
+      @right_term = right_term
+    end
+
+    def apply
+      @left_term = @left_term.apply if @left_term.respond_to? :apply
+      @right_term = @right_term.apply if @right_term.respond_to? :apply
+      operation = BinaryExpressionFactory.new(@operator)
+
+      operation.call(@left_term, @right_term)
+    end
+
+    def == (other)
+      @operator == other.operator && @left_term == other.left_term && @right_term == other.right_term
+    end
+  end
+
+end

data/lib/formula_dsl/binary_expression_factory.rb

@@ -0,0 +1,22 @@
+#encoding: utf-8
+
+module FormulaDSL
+  class MissingBinaryOperationError < RuntimeError
+  end
+
+  module BinaryExpressionFactory
+
+    def self.new(operator)
+      operation = case operator
+                  when :+ then ::FormulaDSL::BinaryOperations::ADDITION
+                  when :- then ::FormulaDSL::BinaryOperations::SUBTRACTION
+                  when :* then ::FormulaDSL::BinaryOperations::MULTIPLICATION
+                  when :/ then ::FormulaDSL::BinaryOperations::DIVISION
+                  else raise MissingBinaryOperationError, "Sorry, but we don't have a implementation for the operator ( #{operator} )."
+                  end
+
+      operation
+    end
+
+  end
+end

data/lib/formula_dsl/binary_operations.rb

@@ -0,0 +1,12 @@
+#encoding: utf-8
+
+module FormulaDSL
+  module BinaryOperations
+
+    ADDITION       = Proc.new{|left_term, right_term| "#{left_term} + #{right_term}" }
+    SUBTRACTION    = Proc.new{|left_term, right_term| "#{left_term} - #{right_term}" }
+    DIVISION       = Proc.new{|left_term, right_term| "#{left_term} / #{right_term}" }
+    MULTIPLICATION = Proc.new{|left_term, right_term| "#{left_term} * #{right_term}" }
+
+  end
+end

data/lib/formula_dsl/function_expression.rb

@@ -0,0 +1,22 @@
+#encoding: utf-8
+module FormulaDSL
+
+  class FunctionExpression
+    attr_reader :name, :args
+    def initialize(name, *args)
+      @name = name
+      @args = args
+    end
+
+    def apply
+      function = FunctionExpressionFactory.new(@name)
+
+      function.call(@args)
+    end
+
+    def == (other)
+      @name == other.name && @args == other.args
+    end
+  end
+
+end

data/lib/formula_dsl/function_expression_factory.rb

@@ -0,0 +1,31 @@
+#encoding: utf-8
+
+module FormulaDSL
+  class MissingFunctionError < RuntimeError
+  end
+
+  module FunctionExpressionFactory
+
+    def self.new(function_name)
+      begin
+        function = constantize("FormulaDSL::Functions::#{function_name.upcase}")
+
+        function
+      rescue(NameError)
+        raise MissingFunctionError, "If you want to use the function #{function_name} you must implement that as a proc named FormulaDSL::Functions::#{function_name.upcase}"
+      end
+    end
+
+    private
+      def self.constantize( string )
+        module_names = string.split('::')
+        constant = Module.const_get( module_names.first.to_sym )
+
+        module_names = module_names.drop(1)
+        module_names.each{ |name| constant = constant.const_get( name.to_sym ) }
+
+        constant
+      end
+
+  end
+end

data/lib/formula_dsl/functions.rb

@@ -0,0 +1,9 @@
+#encoding: utf-8
+module FormulaDSL
+  module Functions
+
+    MONTH = Proc.new{|args| "this.#{args.first}.getMonth() + 1" }
+    YEAR  = Proc.new{|args| "this.#{args.first}.getYear()" }
+
+  end
+end

data/lib/formula_dsl/parser.rb

@@ -0,0 +1,92 @@
+#encoding: utf-8
+module FormulaDSL
+  class Parser < Parslet::Parser
+
+    # Single char rules
+    rule(:lparen) { str('(') >> space? }
+    rule(:rparen) { str(')') >> space? }
+    rule(:comma)  { str(',') >> space? }
+
+    # non significant character's
+    rule(:space)  { match('\s').repeat(1) }
+    rule(:space?) { space.maybe }
+
+    # Literal's
+    rule(:number)     { match('\d').repeat(1) }
+    rule(:quote)      { match('"') }
+    rule(:string)     { quote >> space? >> match('.') >> space? >> quote}
+    rule(:identifier) { match['\w'].repeat(1) }
+
+    # Argument
+    rule (:argument) { identifier | number }
+    rule (:arglist)  { (argument >> comma.maybe).repeat }
+
+    # Operators
+    rule(:add_operator ) { match(['+']) }
+    rule(:sub_operator ) { match('-') }
+    rule(:mult_operator) { match(['*']) }
+    rule(:div_operator ) { match(['/']) }
+
+    rule :operator do
+      add_operator | sub_operator | mult_operator | div_operator
+    end
+
+    #binary operations + - / *
+    rule :addition do
+      ( number.as(:left) >> space? >> add_operator >> space? >> ( number ).as(:right) ).as(:+)
+    end
+
+    rule :subtraction do
+      ( number.as(:left) >> space? >> sub_operator >> space? >> ( number ).as(:right) ).as(:-)
+    end
+
+    rule :multiplication do
+      ( number.as(:left) >> space? >> mult_operator >> space? >> ( number ).as(:right) ).as(:*)
+    end
+
+    rule :division do
+      ( number.as(:left) >> space? >> div_operator >> space? >> ( number ).as(:right) ).as(:/)
+    end
+
+    rule :function do
+      (identifier.as(:name) >> lparen >> arglist.as(:args) >> rparen).as(:function)
+    end
+
+    rule :string_concat do
+      ( string.as(:left) >> space? >> add_operator >> space? >> ( string ).as(:right) ).as(:+)
+    end
+
+    rule :single_expression do
+       function | addition | subtraction | multiplication | division | string_concat | number | string
+    end
+
+    # expression with other expression (compose expression)
+    # Ex: expression >> some_op >> number === [ Mont(data) - 1 ]
+    rule :subtraction_expression do
+      (single_expression.as(:left) >> space? >> sub_operator >> space? >> (single_expression | number).as(:right) ).as(:-)
+    end
+
+    rule :addition_expression do
+      (single_expression.as(:left) >> space? >> add_operator >> space? >> ( expression_list | number ).as(:right) ).as(:+)
+    end
+
+    rule :multiplication_expression do
+      (single_expression.as(:left) >> space? >> mult_operator >> space? >> (single_expression | number).as(:right) ).as(:*)
+    end
+
+    rule :division_expression do
+      (single_expression.as(:left) >> space? >> div_operator >> space? >> (single_expression | number).as(:right) ).as(:/)
+    end
+
+    rule :string_concat_expression do
+      (single_expression.as(:left) >> space? >> add_operator >> space? >> ( expression_list | string ).as(:right) ).as(:+)
+    end
+
+    rule :expression_list do
+      addition_expression | subtraction_expression | multiplication_expression | division_expression | string_concat_expression | single_expression
+    end
+
+    # Entry Point rule
+    root :expression_list
+  end
+end

data/lib/formula_dsl/transformer.rb

@@ -0,0 +1,65 @@
+#encoding: utf-8
+module FormulaDSL
+  class Transformer
+
+    def apply( ast )
+      expression = parse(ast)
+
+      expression
+    end
+
+  private
+    def parse( hash )
+      if hash.keys.size == 1
+        parse_single_key_hash( hash )
+      else
+        puts "como faz o parse de um hash com mais de 1 chave???"
+      end
+    end
+
+    def parse_single_key_hash( hash )
+      key = hash.keys.first
+      if is_operator? key
+        parse_operation key, hash[key]
+      elsif is_function? key
+        parse_function hash[key]
+      else
+        puts "como faz o parse de um hash com chave = #{key}???"
+      end
+    end
+
+    def is_operator?( key )
+      [:+, :-, :*, :/].include?(key)
+    end
+
+    def is_function?(key)
+      :function == key
+    end
+
+    def parse_operation(operator, values={left: '', right: ''})
+      left_side  = extract_operation_side(values[:left])
+      right_side = extract_operation_side(values[:right])
+
+      BinaryExpression.new(operator, left_side, right_side)
+    end
+
+    def parse_function( hash = {name:'', args:''} )
+      FunctionExpression.new(hash[:name].to_str, hash[:args].to_str)
+    end
+
+    def extract_operation_side( side )
+      if side.respond_to?(:keys)
+        parse( side )
+      else
+        if (/"(?<value>.)"/ =~ side.to_str)
+          "'#{value}'"
+        elsif (/(?<value>\d+)/ =~ side.str)
+          value.to_i
+        else
+          side.to_str
+        end
+      end
+    end
+
+  end
+end

data/lib/formula_dsl.rb

@@ -4,4 +4,11 @@ require "bundler/setup"
 Bundler.require(:default)
 
 require 'parslet'
-require 'formula_dsl/formula_parser'
+require 'formula_dsl/parser'
+require 'formula_dsl/transformer'
+require 'formula_dsl/functions'
+require 'formula_dsl/binary_operations'
+require 'formula_dsl/function_expression_factory'
+require 'formula_dsl/binary_expression_factory'
+require 'formula_dsl/binary_expression'
+require 'formula_dsl/function_expression'

data/spec/formula_dsl/binary_expression_factory_spec.rb

@@ -0,0 +1,31 @@
+#encoding: utf-8
+require 'spec_helper'
+
+module FormulaDSL
+  describe BinaryExpressionFactory do
+    subject{ BinaryExpressionFactory }
+
+    specify { should respond_to(:new) }
+
+    it "should be return a ADDITON Proc to + operator " do
+      subject.new(:+).should be == FormulaDSL::BinaryOperations::ADDITION
+    end
+
+    it "should be return a SUBTRACTION Proc to - operator " do
+      subject.new(:-).should be == FormulaDSL::BinaryOperations::SUBTRACTION
+    end
+
+    it "should be return a MULTIPLICATON Proc to * operator " do
+      subject.new(:*).should be == FormulaDSL::BinaryOperations::MULTIPLICATION
+    end
+
+    it "should be return a DIVISION Proc to / operator " do
+      subject.new(:/).should be == FormulaDSL::BinaryOperations::DIVISION
+    end
+
+    it "should raise FormulaDSL::MissingBinaryOperation for a unknown operator " do
+      lambda{ subject.new('abc') }.should raise_error(MissingBinaryOperationError)
+    end
+
+  end
+end

data/spec/formula_dsl/binary_expression_spec.rb

@@ -0,0 +1,18 @@
+#encoding: utf-8
+require 'spec_helper'
+
+module FormulaDSL
+  describe BinaryExpression do
+    subject{ BinaryExpression.new(:+, 3, 2) }
+
+    specify { should respond_to(:operator) }
+    specify { should respond_to(:left_term) }
+    specify { should respond_to(:right_term) }
+    specify { should respond_to(:apply) }
+
+    it "should be considered equal to a another BinaryExpression if that function contains same data" do
+      subject.should == BinaryExpression.new(:+, 3, 2)
+    end
+
+  end
+end

data/spec/formula_dsl/function_expression_factory_spec.rb

@@ -0,0 +1,28 @@
+#encoding: utf-8
+require 'spec_helper'
+
+module FormulaDSL
+  describe FunctionExpressionFactory do
+    subject{ FunctionExpressionFactory }
+
+    specify { should respond_to(:new) }
+
+    it "should return a correct function implementation for a given function name" do
+      constant = subject.new("month")
+      constant.should be FormulaDSL::Functions::MONTH
+    end
+
+    it "should raise MissingFunctionError for a not implemented function" do
+      lambda{ subject.new("sqrt") }.should raise_error(MissingFunctionError)
+    end
+
+
+    context "with private method #constantize" do
+      it "should receive a string with a full qualified function name and return the correspondent Constant" do
+        constant = subject.send(:constantize, "FormulaDSL::Functions::MONTH")
+        constant.should be FormulaDSL::Functions::MONTH
+      end
+    end
+
+  end
+end

data/spec/formula_dsl/function_expression_spec.rb

@@ -0,0 +1,17 @@
+#encoding: utf-8
+require 'spec_helper'
+
+module FormulaDSL
+  describe FunctionExpression do
+    subject{ FunctionExpression.new('SQRT', 4) }
+
+    specify { should respond_to(:name) }
+    specify { should respond_to(:args) }
+    specify { should respond_to(:apply) }
+
+    it "should be considered equal to a another Function if that function contains same data" do
+      subject.should == FunctionExpression.new('SQRT', 4)
+    end
+
+  end
+end

data/spec/formula_dsl/parser_spec.rb

@@ -0,0 +1,87 @@
+#encoding: utf-8
+require 'spec_helper'
+
+module FormulaDSL
+  describe Parser do
+
+    let(:parser){ subject }
+
+    context "Single Expression's" do
+
+      it "should recognize expression '2 + 1' " do
+        ast = parser.parse('2 + 1')
+        ast.to_s.should == %Q({:+=>{:left=>"2"@0, :right=>"1"@4}})
+      end
+
+      it "should recognize expression '2 + 1 + 3' " do
+        ast = parser.parse('2 + 1 + 3')
+        ast.to_s.should == %Q({:+=>{:left=>{:+=>{:left=>"2"@0, :right=>"1"@4}}, :right=>"3"@8}})
+      end
+
+      it "should recognize expression '2 - 1" do
+        ast = parser.parse('2 - 1')
+        ast.to_s.should == %Q({:-=>{:left=>"2"@0, :right=>"1"@4}})
+      end
+
+      it "should recognize expression '2 * 1" do
+        ast = parser.parse('2 * 1')
+        ast.to_s.should == %Q({:*=>{:left=>"2"@0, :right=>"1"@4}})
+      end
+
+      it "should recognize expression '2 / 2" do
+        ast = parser.parse('2 / 2')
+        ast.to_s.should == %Q({:/=>{:left=>"2"@0, :right=>"2"@4}})
+      end
+    end
+
+    context "Composed expression's " do
+      it "should recognize a function like 'Month(data)' " do
+        ast = parser.parse('Month(data)')
+        ast.to_s.should == %Q({:function=>{:name=>"Month"@0, :args=>"data"@6}})
+      end
+
+      it "should recognize the expression 'Month(data) - 1' " do
+        ast = parser.parse('Month(data) - 1')
+        ast.to_s.should == %Q({:-=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>"1"@14}})
+      end
+
+      it "should recognize the expression 'Month(data) * 1' " do
+        ast = parser.parse('Month(data) * 1')
+        ast.to_s.should == %Q({:*=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>"1"@14}})
+      end
+
+      it "should recognize the expression 'Month(data) / 1' " do
+        ast = parser.parse('Month(data) / 1')
+        ast.to_s.should == %Q({:/=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>"1"@14}})
+      end
+
+      it " should recognize expression with 2 functions 'Month(data) + Year(data)'" do
+        ast = parser.parse('Month(data) + Year(data)')
+        ast.to_s.should == %Q({:+=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>{:function=>{:name=>"Year"@14, :args=>"data"@19}}}})
+      end
+    end
+
+    context "Expressions with string concatenation" do
+      it " should recognize expression with string concat \"A\" + \"B\"'" do
+        ast = parser.parse('"A" + "B"')
+        ast.to_s.should == %Q({:+=>{:left=>"\\\"A\\\""@0, :right=>"\\\"B\\\""@6}})
+      end
+
+      it " should recognize expression with string concat '\"A\" + \"B\" + \"C\" ' " do
+        ast = parser.parse('"A" + "B" + "C"')
+        ast.to_s.should == %Q({:+=>{:left=>{:+=>{:left=>"\\\"A\\\""@0, :right=>"\\\"B\\\""@6}}, :right=>"\\\"C\\\""@12}})
+      end
+
+      it " should recognize expression with string concat 'Month(data) + \"/\"'" do
+        ast = parser.parse('Month(data) + "/"')
+        ast.to_s.should == %Q({:+=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>"\\\"/\\\""@14}})
+      end
+
+      it " should recognize expression with string concat 'Month(data) + \"/\" + Year(data)'" do
+        ast = parser.parse('Month(data) + "/" + Year(data)')
+        ast.to_s.should == %Q({:+=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>{:+=>{:left=>"\\\"/\\\""@14, :right=>{:function=>{:name=>"Year"@20, :args=>"data"@25}}}}}})
+      end
+    end
+
+  end
+end

data/spec/formula_dsl/transformer_spec.rb

@@ -0,0 +1,60 @@
+#encoding: utf-8
+require 'spec_helper'
+
+module FormulaDSL
+  describe Transformer do
+
+    let(:parser){ Parser.new }
+    let(:resolver){ subject }
+
+    context "Resolving Expression's" do
+
+      it "should resolve ast '2 + 1' as BinaryExpression" do
+        ast = parser.parse('2 + 1')
+        expression = resolver.apply( ast )
+        expression.should be_a_kind_of BinaryExpression
+        expression.operator.should   == :+
+        expression.left_term.should  == 2
+        expression.right_term.should == 1
+      end
+
+      it "should resolve ast '2 + 1 - 4' as BinaryExpression with contains antoher BinaryExpression" do
+        ast = parser.parse('2 + 1 - 4')
+        expression = resolver.apply( ast )
+        expression.should be_a_kind_of BinaryExpression
+        expression.left_term.should be_a_kind_of BinaryExpression
+        expression.left_term.should be == BinaryExpression.new(:+,2,1)
+        expression.right_term.should == 4
+        expression.operator.should == :-
+      end
+
+      it "should resolve ast 'Month(data) as FunctionExpression" do
+        ast = parser.parse('Month(data)')
+        expression = resolver.apply( ast )
+        expression.should be_a_kind_of FunctionExpression
+        expression.name.should == 'Month'
+        expression.args.should == ['data']
+      end
+
+      it "should resolve ast 'Month(data) + Year(data) as Binary operation wich conatins 2 FunctionExpression as left and right terms" do
+        ast = parser.parse('Month(data) + Year(data)')
+        expression = resolver.apply( ast )
+        expression.should be_a_kind_of BinaryExpression
+        expression.operator.should      == :+
+        expression.left_term.should be  == FunctionExpression.new('Month','data')
+        expression.right_term.should be == FunctionExpression.new('Year','data')
+      end
+
+      it "should resolve 'Month(data) + \"/\" + Year(data)' as BinaryExpression wich contains FunctionExpression and another BinaryExpression" do
+        ast = parser.parse('Month(data) + "/" + Year(data)')
+        expression = resolver.apply( ast )
+        expression.should be_a_kind_of BinaryExpression
+        expression.operator.should   == :+
+        expression.left_term.should  == FunctionExpression.new('Month','data')
+        expression.right_term.should == BinaryExpression.new(:+,"'/'",FunctionExpression.new('Year','data'))
+      end
+
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -1 +1,2 @@
+require 'rubygems'
 require './lib/formula_dsl'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: formula_dsl
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-22 00:00:00.000000000 Z
+date: 2012-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
-  requirement: &70351729396520 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,40 +21,60 @@ dependencies:
         version: 1.3.0
   type: :runtime
   prerelease: false
-  version_requirements: *70351729396520
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.9.0
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &70351729395540 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.8.3
-  type: :runtime
+  type: :development
   prerelease: false
-  version_requirements: *70351729395540
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70351729394860 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>'
       - !ruby/object:Gem::Version
         version: 0.9.2
-  type: :runtime
+  type: :development
   prerelease: false
-  version_requirements: *70351729394860
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &70351729393780 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>'
       - !ruby/object:Gem::Version
-        version: 2.9.0
-  type: :runtime
-  prerelease: false
-  version_requirements: *70351729393780
+        version: 0.9.2
 description: ! ' External DSL to express math operations like you do in MSExcel formula
   bar. The parser generate a AST (Hash) for a given expression. '
 email: sergior.jr@gmail.com
@@ -75,8 +95,20 @@ files:
 - VERSION
 - formula_dsl.gemspec
 - lib/formula_dsl.rb
-- lib/formula_dsl/formula_parser.rb
-- spec/formula_dsl/formula_parser_spec.rb
+- lib/formula_dsl/binary_expression.rb
+- lib/formula_dsl/binary_expression_factory.rb
+- lib/formula_dsl/binary_operations.rb
+- lib/formula_dsl/function_expression.rb
+- lib/formula_dsl/function_expression_factory.rb
+- lib/formula_dsl/functions.rb
+- lib/formula_dsl/parser.rb
+- lib/formula_dsl/transformer.rb
+- spec/formula_dsl/binary_expression_factory_spec.rb
+- spec/formula_dsl/binary_expression_spec.rb
+- spec/formula_dsl/function_expression_factory_spec.rb
+- spec/formula_dsl/function_expression_spec.rb
+- spec/formula_dsl/parser_spec.rb
+- spec/formula_dsl/transformer_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/sergiojunior/formula_dsl
 licenses:
@@ -93,7 +125,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 348571483194901991
+      hash: 2530953314598159526
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -102,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: External DSL that creates AST representation (Hash) for a given mathematical

data/lib/formula_dsl/formula_parser.rb

@@ -1,90 +0,0 @@
-#encoding: utf-8
-class FormulaParser < Parslet::Parser
-
-  # Single char rules
-  rule(:lparen) { str('(') >> space? }
-  rule(:rparen) { str(')') >> space? }
-  rule(:comma)  { str(',') >> space? }
-
-  # non significant character's
-  rule(:space)  { match('\s').repeat(1) }
-  rule(:space?) { space.maybe }
-
-  # Literal's
-  rule(:number)     { match('\d').repeat(1) }
-  rule(:quote)      { match('"') }
-  rule(:string)     { quote >> space? >> match('.') >> space? >> quote}
-  rule(:identifier) { match['\w'].repeat(1) }
-
-  # Argument
-  rule (:argument) { identifier | number }
-  rule (:arglist)  { (argument >> comma.maybe).repeat }
-
-  # Operators
-  rule(:add_operator ) { match(['+']) }
-  rule(:sub_operator ) { match('-') }
-  rule(:mult_operator) { match(['*']) }
-  rule(:div_operator ) { match(['/']) }
-
-  rule :operator do
-    add_operator | sub_operator | mult_operator | div_operator
-  end
-
-  #binary operations + - / *
-  rule :addition do
-    ( number.as(:left) >> space? >> add_operator >> space? >> ( number ).as(:right) ).as(:+)
-  end
-
-  rule :subtraction do
-    ( number.as(:left) >> space? >> sub_operator >> space? >> ( number ).as(:right) ).as(:-)
-  end
-
-  rule :multiplication do
-    ( number.as(:left) >> space? >> mult_operator >> space? >> ( number ).as(:right) ).as(:*)
-  end
-
-  rule :division do
-    ( number.as(:left) >> space? >> div_operator >> space? >> ( number ).as(:right) ).as(:/)
-  end
-
-  rule :function do
-    (identifier.as(:name) >> lparen >> arglist.as(:args) >> rparen).as(:function)
-  end
-
-  rule :string_concat do
-    ( string.as(:left) >> space? >> add_operator >> space? >> ( string ).as(:right) ).as(:concat)
-  end
-
-  rule :single_expression do
-     function | addition | subtraction | multiplication | division | string_concat | number | string
-  end
-
-  # expression with other expression (compose expression)
-  # Ex: expression >> some_op >> number === [ Mont(data) - 1 ]
-  rule :subtraction_expression do
-    (single_expression.as(:left) >> space? >> sub_operator >> space? >> (single_expression | number).as(:right) ).as(:-)
-  end
-
-  rule :addition_expression do
-    (single_expression.as(:left) >> space? >> add_operator >> space? >> (single_expression | number).as(:right) ).as(:+)
-  end
-
-  rule :multiplication_expression do
-    (single_expression.as(:left) >> space? >> mult_operator >> space? >> (single_expression | number).as(:right) ).as(:*)
-  end
-
-  rule :division_expression do
-    (single_expression.as(:left) >> space? >> div_operator >> space? >> (single_expression | number).as(:right) ).as(:/)
-  end
-
-  rule :string_concat_expression do
-    (single_expression.as(:left) >> space? >> add_operator >> space? >> ( expression_list | string ).as(:right) ).as(:concat)
-  end
-
-  rule :expression_list do
-    string_concat_expression | addition_expression | subtraction_expression | multiplication_expression | division_expression | single_expression
-  end
-
-  # Entry Point rule
-  root :expression_list
-end

data/spec/formula_dsl/formula_parser_spec.rb

@@ -1,80 +0,0 @@
-#encoding: utf-8
-require 'spec_helper'
-
-describe FormulaParser do
-
-  let(:parser){ subject }
-
-  context "Single Expression's" do
-
-    it "should recognize expression '2 + 1' " do
-      ast = parser.parse('2 + 1')
-      ast.to_s.should == %Q({:+=>{:left=>"2"@0, :right=>"1"@4}})
-    end
-
-    it "should recognize expression '2 - 1" do
-      ast = parser.parse('2 - 1')
-      ast.to_s.should == %Q({:-=>{:left=>"2"@0, :right=>"1"@4}})
-    end
-
-    it "should recognize expression '2 * 1" do
-      ast = parser.parse('2 * 1')
-      ast.to_s.should == %Q({:*=>{:left=>"2"@0, :right=>"1"@4}})
-    end
-
-    it "should recognize expression '2 / 2" do
-      ast = parser.parse('2 / 2')
-      ast.to_s.should == %Q({:/=>{:left=>"2"@0, :right=>"2"@4}})
-    end
-  end
-
-  context "Composed expression's " do
-    it "should recognize a function like 'Month(data)' " do
-      ast = parser.parse('Month(data)')
-      ast.to_s.should == %Q({:function=>{:name=>"Month"@0, :args=>"data"@6}})
-    end
-
-    it "should recognize the expression 'Month(data) - 1' " do
-      ast = parser.parse('Month(data) - 1')
-      ast.to_s.should == %Q({:-=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>"1"@14}})
-    end
-
-    it "should recognize the expression 'Month(data) * 1' " do
-      ast = parser.parse('Month(data) * 1')
-      ast.to_s.should == %Q({:*=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>"1"@14}})
-    end
-
-    it "should recognize the expression 'Month(data) / 1' " do
-      ast = parser.parse('Month(data) / 1')
-      ast.to_s.should == %Q({:/=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>"1"@14}})
-    end
-
-    it " should recognize expression with 2 functions 'Month(data) + Year(data)'" do
-      ast = parser.parse('Month(data) + Year(data)')
-      ast.to_s.should == %Q({:concat=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>{:function=>{:name=>"Year"@14, :args=>"data"@19}}}})
-    end
-  end
-
-  context "Expressions with string concatenation" do
-    it " should recognize expression with string concat \"A\" + \"B\"'" do
-      ast = parser.parse('"A" + "B"')
-      ast.to_s.should == %Q({:concat=>{:left=>"\\\"A\\\""@0, :right=>"\\\"B\\\""@6}})
-    end
-
-    it " should recognize expression with string concat '\"A\" + \"B\" + \"C\" ' " do
-      ast = parser.parse('"A" + "B" + "C"')
-      ast.to_s.should == %Q({:concat=>{:left=>{:concat=>{:left=>"\\\"A\\\""@0, :right=>"\\\"B\\\""@6}}, :right=>"\\\"C\\\""@12}})
-    end
-
-    it " should recognize expression with string concat 'Month(data) + \"/\"'" do
-      ast = parser.parse('Month(data) + "/"')
-      ast.to_s.should == %Q({:concat=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>"\\\"/\\\""@14}})
-    end
-
-    it " should recognize expression with string concat 'Month(data) + \"/\" + Year(data)'" do
-      ast = parser.parse('Month(data) + "/" + Year(data)')
-      ast.to_s.should == %Q({:concat=>{:left=>{:function=>{:name=>"Month"@0, :args=>"data"@6}}, :right=>{:concat=>{:left=>"\\\"/\\\""@14, :right=>{:function=>{:name=>"Year"@20, :args=>"data"@25}}}}}})
-    end
-  end
-
-end