dentaku 0.2.10 → 0.2.11

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - "1.9.3"

data/README.md

@@ -1,6 +1,10 @@
 Dentaku
 =======
 
+[![Gem Version](https://badge.fury.io/rb/dentaku.png)](http://badge.fury.io/rb/dentaku)
+[![Build Status](https://travis-ci.org/rubysolo/dentaku.png?branch=master)](https://travis-ci.org/rubysolo/dentaku)
+[![Code Climate](https://codeclimate.com/github/rubysolo/dentaku.png)](https://codeclimate.com/github/rubysolo/dentaku)
+
 http://github.com/rubysolo/dentaku
 
 DESCRIPTION
@@ -72,7 +76,7 @@ SUPPORTED OPERATORS AND FUNCTIONS
 ---------------------------------
 
 Math: `+ - * /`  
-Logic: `< > <= >= <> != = AND OR`  
+Logic: `< > <= >= <> != = AND OR NOT`  
 Functions: `IF ROUND`
 
 THANKS

data/lib/dentaku/binary_operation.rb

@@ -0,0 +1,31 @@
+module Dentaku
+  class BinaryOperation
+    attr_reader :left, :right
+
+    def initialize(left, right)
+      @left = left
+      @right = right
+    end
+
+    def pow;      [:numeric, left ** right]; end
+    def add;      [:numeric, left + right];  end
+    def subtract; [:numeric, left - right];  end
+    def multiply; [:numeric, left * right];  end
+
+    def divide
+      quotient, remainder = left.divmod(right)
+      return [:numeric, quotient] if remainder == 0
+      [:numeric, left.to_f / right.to_f]
+    end
+
+    def le;       [:logical, left <= right]; end
+    def ge;       [:logical, left >= right]; end
+    def lt;       [:logical, left <  right]; end
+    def gt;       [:logical, left >  right]; end
+    def ne;       [:logical, left != right]; end
+    def eq;       [:logical, left == right]; end
+
+    def and;      [:logical, left && right]; end
+    def or;       [:logical, left || right]; end
+  end
+end

data/lib/dentaku/calculator.rb

@@ -31,7 +31,7 @@ module Dentaku
         @memory[key_or_hash.to_sym] = value
       else
         key_or_hash.each do |key, value|
-          @memory[key.to_sym] = value if value
+          @memory[key.to_sym] = value
         end
       end
 
@@ -69,7 +69,11 @@ module Dentaku
     end
 
     def type_for_value(value)
-      value.is_a?(String) ? :string : :numeric
+      case value
+      when String then :string
+      when TrueClass, FalseClass then :logical
+      else :numeric
+      end
     end
   end
 end

data/lib/dentaku/evaluator.rb

@@ -1,85 +1,15 @@
-require 'dentaku/token'
-require 'dentaku/token_matcher'
+require 'dentaku/rules'
+require 'dentaku/binary_operation'
 
 module Dentaku
   class Evaluator
-    # tokens
-    T_NUMERIC    = TokenMatcher.new(:numeric)
-    T_STRING     = TokenMatcher.new(:string)
-    T_ADDSUB     = TokenMatcher.new(:operator, [:add, :subtract])
-    T_MULDIV     = TokenMatcher.new(:operator, [:multiply, :divide])
-    T_POW        = TokenMatcher.new(:operator, :pow)
-    T_COMPARATOR = TokenMatcher.new(:comparator)
-    T_COMP_GT    = TokenMatcher.new(:comparator, [:gt, :ge])
-    T_COMP_LT    = TokenMatcher.new(:comparator, [:lt, :le])
-    T_OPEN       = TokenMatcher.new(:grouping, :open)
-    T_CLOSE      = TokenMatcher.new(:grouping, :close)
-    T_COMMA      = TokenMatcher.new(:grouping, :comma)
-    T_NON_GROUP  = TokenMatcher.new(:grouping).invert
-    T_LOGICAL    = TokenMatcher.new(:logical)
-    T_COMBINATOR = TokenMatcher.new(:combinator)
-    T_IF         = TokenMatcher.new(:function, :if)
-    T_ROUND      = TokenMatcher.new(:function, :round)
-    T_ROUNDUP    = TokenMatcher.new(:function, :roundup)
-    T_ROUNDDOWN  = TokenMatcher.new(:function, :rounddown)
-    T_NOT        = TokenMatcher.new(:function, :not)
-
-    T_NON_GROUP_STAR = TokenMatcher.new(:grouping).invert.star
-
-    # patterns
-    P_GROUP      = [T_OPEN,    T_NON_GROUP_STAR, T_CLOSE]
-    P_MATH_ADD   = [T_NUMERIC, T_ADDSUB,         T_NUMERIC]
-    P_MATH_MUL   = [T_NUMERIC, T_MULDIV,         T_NUMERIC]
-    P_MATH_POW   = [T_NUMERIC, T_POW,            T_NUMERIC]
-    P_RANGE_ASC  = [T_NUMERIC, T_COMP_LT,        T_NUMERIC, T_COMP_LT, T_NUMERIC]
-    P_RANGE_DESC = [T_NUMERIC, T_COMP_GT,        T_NUMERIC, T_COMP_GT, T_NUMERIC]
-    P_NUM_COMP   = [T_NUMERIC, T_COMPARATOR,     T_NUMERIC]
-    P_STR_COMP   = [T_STRING,  T_COMPARATOR,     T_STRING]
-    P_COMBINE    = [T_LOGICAL, T_COMBINATOR,     T_LOGICAL]
-
-    P_IF         = [T_IF, T_OPEN, T_NON_GROUP, T_COMMA, T_NON_GROUP, T_COMMA, T_NON_GROUP, T_CLOSE]
-    P_ROUND_ONE  = [T_ROUND, T_OPEN, T_NON_GROUP_STAR, T_CLOSE]
-    P_ROUND_TWO  = [T_ROUND, T_OPEN, T_NON_GROUP_STAR, T_COMMA, T_NUMERIC, T_CLOSE]
-    P_ROUNDUP    = [T_ROUNDUP, T_OPEN, T_NON_GROUP_STAR, T_CLOSE]
-    P_ROUNDDOWN  = [T_ROUNDDOWN, T_OPEN, T_NON_GROUP_STAR, T_CLOSE]
-    P_NOT        = [T_NOT, T_OPEN, T_NON_GROUP_STAR, T_CLOSE]
-
-    RULES = [
-      [P_IF,         :if],
-      [P_ROUND_ONE,  :round],
-      [P_ROUND_TWO,  :round],
-      [P_ROUNDUP,    :roundup],
-      [P_ROUNDDOWN,  :rounddown],
-      [P_NOT,        :not],
-
-      [P_GROUP,      :evaluate_group],
-      [P_MATH_POW,   :apply],
-      [P_MATH_MUL,   :apply],
-      [P_MATH_ADD,   :apply],
-      [P_RANGE_ASC,  :expand_range],
-      [P_RANGE_DESC, :expand_range],
-      [P_NUM_COMP,   :apply],
-      [P_STR_COMP,   :apply],
-      [P_COMBINE,    :apply]
-    ]
-
     def evaluate(tokens)
       evaluate_token_stream(tokens).value
     end
 
     def evaluate_token_stream(tokens)
       while tokens.length > 1
-        matched = false
-        RULES.each do |pattern, evaluator|
-          pos, match = find_rule_match(pattern, tokens)
-
-          if pos
-            tokens = evaluate_step(tokens, pos, match.length, evaluator)
-            matched = true
-            break
-          end
-        end
-
+        matched, tokens = match_rule_pattern(tokens)
         raise "no rule matched #{ tokens.map(&:category).inspect }" unless matched
       end
 
@@ -88,9 +18,19 @@ module Dentaku
       tokens.first
     end
 
-    def evaluate_step(token_stream, start, length, evaluator)
-      expr = token_stream.slice!(start, length)
-      token_stream.insert start, *self.send(evaluator, *expr)
+    def match_rule_pattern(tokens)
+      matched = false
+      Rules.each do |pattern, evaluator|
+        pos, match = find_rule_match(pattern, tokens)
+
+        if pos
+          tokens = evaluate_step(tokens, pos, match.length, evaluator)
+          matched = true
+          break
+        end
+      end
+
+      [matched, tokens]
     end
 
     def find_rule_match(pattern, token_stream)
@@ -113,40 +53,19 @@ module Dentaku
       nil
     end
 
+    def evaluate_step(token_stream, start, length, evaluator)
+      expr = token_stream.slice!(start, length)
+      token_stream.insert start, *self.send(evaluator, *expr)
+    end
+
     def evaluate_group(*args)
       evaluate_token_stream(args[1..-2])
     end
 
     def apply(lvalue, operator, rvalue)
-      l = lvalue.value
-      r = rvalue.value
-
-      case operator.value
-      when :pow      then Token.new(:numeric, l ** r)
-      when :add      then Token.new(:numeric, l + r)
-      when :subtract then Token.new(:numeric, l - r)
-      when :multiply then Token.new(:numeric, l * r)
-      when :divide   then Token.new(:numeric, divide(l, r))
-
-      when :le       then Token.new(:logical, l <= r)
-      when :ge       then Token.new(:logical, l >= r)
-      when :lt       then Token.new(:logical, l <  r)
-      when :gt       then Token.new(:logical, l >  r)
-      when :ne       then Token.new(:logical, l != r)
-      when :eq       then Token.new(:logical, l == r)
-
-      when :and      then Token.new(:logical, l && r)
-      when :or       then Token.new(:logical, l || r)
-
-      else
-        raise "unknown comparator '#{ comparator }'"
-      end
-    end
-
-    def divide(numerator, denominator)
-      quotient, remainder = numerator.divmod(denominator)
-      return quotient if remainder == 0
-      numerator.to_f / denominator.to_f
+      operation = BinaryOperation.new(lvalue.value, rvalue.value)
+      raise "unknown operation #{ operator.value }" unless operation.respond_to?(operator.value)
+      Token.new(*operation.send(operator.value))
     end
 
     def expand_range(left, oper1, middle, oper2, right)
@@ -166,35 +85,29 @@ module Dentaku
     def round(*args)
       _, _, *tokens, _ = args
 
-      input_tokens = tokens.take_while { |a| a.category != :grouping }
-      input_value  = evaluate_token_stream(input_tokens).value
-      places       = 0
+      input_tokens, places_tokens = tokens.chunk { |t| t.category == :grouping }.
+                                          reject { |flag, tokens| flag }.
+                                             map { |flag, tokens| tokens }
 
-      if places_token = tokens.drop_while { |a| a.category != :grouping }.last
-        places = places_token.value
-      end
+      input_value  = evaluate_token_stream(input_tokens).value
+      places       = places_tokens ? evaluate_token_stream(places_tokens).value : 0
 
-      begin
-        value = input_value.round(places)
-      rescue ArgumentError
-        value = (input * 10 ** places).round / (10 ** places).to_f
-      end
+      value = input_value.round(places)
 
       Token.new(:numeric, value)
     end
 
-    def roundup(*args)
-      _, _, *tokens, _ = args
+    def round_int(*args)
+      function, _, *tokens, _ = args
 
       value = evaluate_token_stream(tokens).value
-      Token.new(:numeric, value.ceil)
-    end
-
-    def rounddown(*args)
-      _, _, *tokens, _ = args
+      rounded = if function.value == :roundup
+        value.ceil
+      else
+        value.floor
+      end
 
-      value = evaluate_token_stream(tokens).value
-      Token.new(:numeric, value.floor)
+      Token.new(:numeric, rounded)
     end
 
     def not(*args)

data/lib/dentaku/rules.rb

@@ -0,0 +1,75 @@
+require 'dentaku/token'
+require 'dentaku/token_matcher'
+
+module Dentaku
+  class Rules
+    def self.each
+      @rules ||= [
+        [ p(:if),         :if             ],
+        [ p(:round_one),  :round          ],
+        [ p(:round_two),  :round          ],
+        [ p(:roundup),    :round_int      ],
+        [ p(:rounddown),  :round_int      ],
+        [ p(:not),        :not            ],
+
+        [ p(:group),      :evaluate_group ],
+        [ p(:math_pow),   :apply          ],
+        [ p(:math_mul),   :apply          ],
+        [ p(:math_add),   :apply          ],
+        [ p(:range_asc),  :expand_range   ],
+        [ p(:range_desc), :expand_range   ],
+        [ p(:num_comp),   :apply          ],
+        [ p(:str_comp),   :apply          ],
+        [ p(:combine),    :apply          ]
+      ]
+
+      @rules.each { |r| yield r }
+    end
+
+    def self.t(name)
+      @matchers ||= [
+        :numeric, :string, :addsub, :muldiv, :pow,
+        :comparator, :comp_gt, :comp_lt,
+        :open, :close, :comma,
+        :non_group, :non_group_star,
+        :logical, :combinator,
+        :if, :round, :roundup, :rounddown, :not
+      ].each_with_object({}) do |name, matchers|
+        matchers[name] = TokenMatcher.send(name)
+      end
+
+      @matchers[name]
+    end
+
+    def self.p(name)
+      @patterns ||= {
+        group:      pattern(:open,    :non_group_star, :close),
+        math_add:   pattern(:numeric, :addsub,         :numeric),
+        math_mul:   pattern(:numeric, :muldiv,         :numeric),
+        math_pow:   pattern(:numeric, :pow,            :numeric),
+        range_asc:  pattern(:numeric, :comp_lt,        :numeric,  :comp_lt, :numeric),
+        range_desc: pattern(:numeric, :comp_gt,        :numeric,  :comp_gt, :numeric),
+        num_comp:   pattern(:numeric, :comparator,     :numeric),
+        str_comp:   pattern(:string,  :comparator,     :string),
+        combine:    pattern(:logical, :combinator,     :logical),
+
+        if:         func_pattern(:if,        :non_group,      :comma, :non_group, :comma, :non_group),
+        round_one:  func_pattern(:round,     :non_group_star),
+        round_two:  func_pattern(:round,     :non_group_star, :comma, :numeric),
+        roundup:    func_pattern(:roundup,   :non_group_star),
+        rounddown:  func_pattern(:rounddown, :non_group_star),
+        not:        func_pattern(:not,       :non_group_star)
+      }
+
+      @patterns[name]
+    end
+
+    def self.pattern(*symbols)
+      symbols.map { |s| t(s) }
+    end
+
+    def self.func_pattern(func, *tokens)
+      pattern(func, :open, *tokens, :close)
+    end
+  end
+end

data/lib/dentaku/token_matcher.rb

@@ -57,6 +57,27 @@ module Dentaku
     def value_match(value)
       @values.empty? || @values.include?(value)
     end
+
+    def self.numeric;        new(:numeric);                        end
+    def self.string;         new(:string);                         end
+    def self.addsub;         new(:operator, [:add, :subtract]);    end
+    def self.muldiv;         new(:operator, [:multiply, :divide]); end
+    def self.pow;            new(:operator, :pow);                 end
+    def self.comparator;     new(:comparator);                     end
+    def self.comp_gt;        new(:comparator, [:gt, :ge]);         end
+    def self.comp_lt;        new(:comparator, [:lt, :le]);         end
+    def self.open;           new(:grouping, :open);                end
+    def self.close;          new(:grouping, :close);               end
+    def self.comma;          new(:grouping, :comma);               end
+    def self.logical;        new(:logical);                        end
+    def self.combinator;     new(:combinator);                     end
+    def self.if;             new(:function, :if);                  end
+    def self.round;          new(:function, :round);               end
+    def self.roundup;        new(:function, :roundup);             end
+    def self.rounddown;      new(:function, :rounddown);           end
+    def self.not;            new(:function, :not);                 end
+    def self.non_group;      new(:grouping).invert;                end
+    def self.non_group_star; new(:grouping).invert.star;           end
   end
 end
 

data/lib/dentaku/token_scanner.rb

@@ -18,5 +18,66 @@ module Dentaku
 
       false
     end
+
+    class << self
+      def scanners
+        @scanners ||= [
+          whitespace,
+          numeric,
+          double_quoted_string,
+          single_quoted_string,
+          operator,
+          grouping,
+          comparator,
+          combinator,
+          function,
+          identifier
+        ]
+      end
+
+      def whitespace
+        new(:whitespace, '\s+')
+      end
+
+      def numeric
+        new(:numeric, '(\d+(\.\d+)?|\.\d+)\b', lambda { |raw| raw =~ /\./ ? raw.to_f : raw.to_i })
+      end
+
+      def double_quoted_string
+        new(:string, '"[^"]*"', lambda { |raw| raw.gsub(/^"|"$/, '') })
+      end
+
+      def single_quoted_string
+        new(:string, "'[^']*'", lambda { |raw| raw.gsub(/^'|'$/, '') })
+      end
+
+      def operator
+        names = { pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/' }.invert
+        new(:operator, '\^|\+|-|\*|\/', lambda { |raw| names[raw] })
+      end
+
+      def grouping
+        names = { open: '(', close: ')', comma: ',' }.invert
+        new(:grouping, '\(|\)|,', lambda { |raw| names[raw] })
+      end
+
+      def comparator
+        names = { le: '<=', ge: '>=', ne: '!=', lt: '<', gt: '>', eq: '=' }.invert
+        alternate = { ne: '<>' }.invert
+        new(:comparator, '<=|>=|!=|<>|<|>|=', lambda { |raw| names[raw] || alternate[raw] })
+      end
+
+      def combinator
+        new(:combinator, '(and|or)\b', lambda {|raw| raw.strip.downcase.to_sym })
+      end
+
+      def function
+        new(:function, '(if|round(up|down)?|not)\b', lambda {|raw| raw.strip.downcase.to_sym })
+      end
+
+      def identifier
+        new(:identifier, '\w+\b', lambda {|raw| raw.strip.downcase.to_sym })
+      end
+    end
   end
 end

data/lib/dentaku/tokenizer.rb

@@ -4,73 +4,40 @@ require 'dentaku/token_scanner'
 
 module Dentaku
   class Tokenizer
-    SCANNERS = [
-      TokenScanner.new(:whitespace, '\s+'),
-      TokenScanner.new(:numeric,    '(\d+(\.\d+)?|\.\d+)\b', lambda { |raw| raw =~ /\./ ? raw.to_f : raw.to_i }),
-      TokenScanner.new(:string,     '"[^"]*"',               lambda { |raw| raw.gsub(/^"|"$/, '') }),
-      TokenScanner.new(:string,     "'[^']*'",               lambda { |raw| raw.gsub(/^'|'$/, '') }),
-      TokenScanner.new(:operator,   '\^|\+|-|\*|\/', lambda do |raw|
-        case raw
-        when '^' then :pow
-        when '+' then :add
-        when '-' then :subtract
-        when '*' then :multiply
-        when '/' then :divide
-        end
-      end),
-      TokenScanner.new(:grouping,   '\(|\)|,', lambda do |raw|
-        case raw
-        when '(' then :open
-        when ')' then :close
-        when ',' then :comma
-        end
-      end),
-      TokenScanner.new(:comparator, '<=|>=|!=|<>|<|>|=', lambda do |raw|
-        case raw
-        when '<=' then :le
-        when '>=' then :ge
-        when '!=' then :ne
-        when '<>' then :ne
-        when '<'  then :lt
-        when '>'  then :gt
-        when '='  then :eq
-        end
-      end),
-      TokenScanner.new(:combinator, '(and|or)\b', lambda {|raw| raw.strip.downcase.to_sym }),
-      TokenScanner.new(:function,   '(if|round(up|down)?|not)\b',
-                                                  lambda {|raw| raw.strip.downcase.to_sym }),
-      TokenScanner.new(:identifier, '\w+\b',      lambda {|raw| raw.strip.downcase.to_sym })
-    ]
-
     LPAREN = TokenMatcher.new(:grouping, :open)
     RPAREN = TokenMatcher.new(:grouping, :close)
 
     def tokenize(string)
-      nesting = 0
-      tokens  = []
-      input   = string.dup
+      @nesting = 0
+      @tokens  = []
+      input    = string.dup
 
       until input.empty?
-        raise "parse error at: '#{ input }'" unless SCANNERS.any? do |scanner|
-          if token = scanner.scan(input)
-            raise "unexpected zero-width match (:#{ token.category }) at '#{ input }'" if token.length == 0
+        raise "parse error at: '#{ input }'" unless TokenScanner.scanners.any? do |scanner|
+          scanned, input = scan(input, scanner)
+          scanned
+        end
+      end
 
-            nesting += 1 if LPAREN == token
-            nesting -= 1 if RPAREN == token
-            raise "too many closing parentheses" if nesting < 0
+      raise "too many opening parentheses" if @nesting > 0
 
-            tokens << token unless token.is?(:whitespace)
-            input.slice!(0, token.length)
+      @tokens
+    end
 
-            true
-          else
-            false
-          end
-        end
-      end
+    def scan(string, scanner)
+      if token = scanner.scan(string)
+        raise "unexpected zero-width match (:#{ token.category }) at '#{ string }'" if token.length == 0
 
-      raise "too many opening parentheses" if nesting > 0
-      tokens
+        @nesting += 1 if LPAREN == token
+        @nesting -= 1 if RPAREN == token
+        raise "too many closing parentheses" if @nesting < 0
+
+        @tokens << token unless token.is?(:whitespace)
+
+        [true, string[token.length..-1]]
+      else
+        [false, string]
+      end
     end
   end
 end

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "0.2.10"
+  VERSION = "0.2.11"
 end

data/spec/binary_operation_spec.rb

@@ -0,0 +1,41 @@
+require 'dentaku/binary_operation'
+
+describe Dentaku::BinaryOperation do
+  let(:operation) { described_class.new(2, 3) }
+  let(:logical)   { described_class.new(true, false) }
+
+  it 'raises a number to a power' do
+    operation.pow.should eq [:numeric, 8]
+  end
+
+  it 'adds two numbers' do
+    operation.add.should eq [:numeric, 5]
+  end
+
+  it 'subtracts two numbers' do
+    operation.subtract.should eq [:numeric, -1]
+  end
+
+  it 'multiplies two numbers' do
+    operation.multiply.should eq [:numeric, 6]
+  end
+
+  it 'divides two numbers' do
+    operation.divide.should eq [:numeric, (2.0/3.0)]
+  end
+
+  it 'compares two numbers' do
+    operation.le.should eq [:logical, true]
+    operation.lt.should eq [:logical, true]
+    operation.ne.should eq [:logical, true]
+
+    operation.ge.should eq [:logical, false]
+    operation.gt.should eq [:logical, false]
+    operation.eq.should eq [:logical, false]
+  end
+
+  it 'performs logical AND and OR' do
+    logical.and.should eq [:logical, false]
+    logical.or.should  eq [:logical, true]
+  end
+end

data/spec/calculator_spec.rb

@@ -68,6 +68,12 @@ describe Dentaku::Calculator do
     calculator.evaluate('fruit = "Apple"', :fruit => 'Apple').should be_true
   end
 
+  it 'should allow binding logical values' do
+    calculator.evaluate('some_boolean AND 7 > 5', :some_boolean => true).should be_true
+    calculator.evaluate('some_boolean AND 7 < 5', :some_boolean => true).should be_false
+    calculator.evaluate('some_boolean AND 7 > 5', :some_boolean => false).should be_false
+  end
+
   describe 'functions' do
     it 'should include IF' do
       calculator.evaluate('if (foo < 8, 10, 20)', :foo => 2).should eq(10)

data/spec/evaluator_spec.rb

@@ -60,8 +60,9 @@ describe Dentaku::Evaluator do
     end
 
     describe 'functions' do
-      it 'should evaluate function' do
+      it 'should be evaluated' do
         evaluator.evaluate(token_stream(:round,     :open, 5, :divide, 3.0, :close)).should eq 2
+        evaluator.evaluate(token_stream(:round,     :open, 5, :divide, 3.0, :comma, 2, :close)).should eq 1.67
         evaluator.evaluate(token_stream(:roundup,   :open, 5, :divide, 1.2, :close)).should eq 5
         evaluator.evaluate(token_stream(:rounddown, :open, 5, :divide, 1.2, :close)).should eq 4
       end

data/spec/spec_helper.rb

@@ -14,7 +14,7 @@ def type_for(value)
     :numeric
   when :add, :subtract, :multiply, :divide
     :operator
-  when :open, :close
+  when :open, :close, :comma
     :grouping
   when :le, :ge, :ne, :ne, :lt, :gt, :eq
     :comparator

data/spec/token_scanner_spec.rb

@@ -19,5 +19,9 @@ describe Dentaku::TokenScanner do
     token.category.should eq(:numeric)
     token.value.should eq(5)
   end
+
+  it 'should return a list of all configured scanners' do
+    described_class.scanners.length.should eq 10
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.11
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-10 00:00:00.000000000 Z
+date: 2013-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -53,18 +53,22 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - README.md
 - Rakefile
 - dentaku.gemspec
 - lib/dentaku.rb
+- lib/dentaku/binary_operation.rb
 - lib/dentaku/calculator.rb
 - lib/dentaku/evaluator.rb
+- lib/dentaku/rules.rb
 - lib/dentaku/token.rb
 - lib/dentaku/token_matcher.rb
 - lib/dentaku/token_scanner.rb
 - lib/dentaku/tokenizer.rb
 - lib/dentaku/version.rb
+- spec/binary_operation_spec.rb
 - spec/calculator_spec.rb
 - spec/dentaku_spec.rb
 - spec/evaluator_spec.rb
@@ -85,18 +89,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -662526630847863998
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -662526630847863998
 requirements: []
 rubyforge_project: dentaku
 rubygems_version: 1.8.23
@@ -104,6 +102,7 @@ signing_key:
 specification_version: 3
 summary: A formula language parser and evaluator
 test_files:
+- spec/binary_operation_spec.rb
 - spec/calculator_spec.rb
 - spec/dentaku_spec.rb
 - spec/evaluator_spec.rb