dentaku 1.2.0 → 1.2.1

data/README.md

@@ -199,9 +199,9 @@ As an example, the exponentiation function takes two parameters, the mantissa
 and the exponent, so the token list could be defined as: `[:numeric,
 :numeric]`.  Other functions might be variadic -- consider `max`, a function
 that takes any number of numeric inputs and returns the largest one.  Its token
-list could be defined as: `[:non_close_plus]` (one or more tokens that are not
-closing parentheses).  See the
-[rules definitions](https://github.com/rubysolo/dentaku/blob/master/lib/dentaku/token_matcher.rb#L61)
+list could be defined as: `[:arguments]` (one or more numeric, string, or logical
+values, separated by commas).  See the
+[rules definitions](https://github.com/rubysolo/dentaku/blob/master/lib/dentaku/token_matcher.rb#L87)
 for the names of token patterns you can use.
 
 Functions can be added individually using Calculator#add_function, or en masse using
@@ -230,10 +230,10 @@ Here's an example of adding the `max` function:
 > c.add_function(
     name: :max,
     type: :numeric,
-    signature: [:non_close_plus],
+    signature: [:arguments],
     body: ->(*args) { args.max }
   )
-> c.evaluate 'MAX(5,3,9,6,2)'
+> c.evaluate 'MAX(8,6,7,5,3,0,9)'
 #=> 9
 ```
 
@@ -245,14 +245,17 @@ Big thanks to [ElkStone Basements](http://www.elkstonebasements.com/) for
 allowing me to extract and open source this code.  Thanks also to all the
 contributors:
 
+* [0xCCD](https://github.com/0xCCD)
+* [AlexeyMK](https://github.com/AlexeyMK)
 * [CraigCottingham](https://github.com/CraigCottingham)
-* [arnaudl](https://github.com/arnaudl)
-* [thbar](https://github.com/thbar) / [BoxCar](https://www.boxcar.io)
 * [antonversal](https://github.com/antonversal)
-* [mvbrocato](https://github.com/mvbrocato)
+* [arnaudl](https://github.com/arnaudl)
+* [bernardofire](https://github.com/bernardofire)
 * [brixen](https://github.com/brixen)
-* [0xCCD](https://github.com/0xCCD)
-* [AlexeyMK](https://github.com/AlexeyMK)
+* [jasonhutchens](https://github.com/jasonhutchens)
+* [jmangs](https://github.com/jmangs)
+* [mvbrocato](https://github.com/mvbrocato)
+* [thbar](https://github.com/thbar) / [BoxCar](https://www.boxcar.io)
 
 
 LICENSE

data/lib/dentaku.rb

@@ -7,14 +7,6 @@ module Dentaku
     calculator.evaluate(expression, data)
   end
 
-  class UnboundVariableError < StandardError
-    attr_reader :unbound_variables
-
-    def initialize(unbound_variables)
-      @unbound_variables = unbound_variables
-    end
-  end
-
   private
 
   def self.calculator

data/lib/dentaku/binary_operation.rb

@@ -1,3 +1,5 @@
+require 'bigdecimal'
+
 module Dentaku
   class BinaryOperation
     attr_reader :left, :right

data/lib/dentaku/calculator.rb

@@ -1,4 +1,5 @@
 require 'dentaku/evaluator'
+require 'dentaku/exceptions'
 require 'dentaku/expression'
 require 'dentaku/rules'
 require 'dentaku/token'

data/lib/dentaku/exceptions.rb

@@ -0,0 +1,9 @@
+module Dentaku
+  class UnboundVariableError < StandardError
+    attr_reader :unbound_variables
+
+    def initialize(unbound_variables)
+      @unbound_variables = unbound_variables
+    end
+  end
+end

data/lib/dentaku/rules.rb

@@ -42,7 +42,7 @@ module Dentaku
       @rules.unshift [
         [
           TokenMatcher.send(ext.name),
-          t(:open),
+          t(:fopen),
           *pattern(*ext.tokens),
           t(:close)
         ],
@@ -53,22 +53,20 @@ module Dentaku
 
     def self.func(name)
       @funcs ||= {}
-      @funcs[name]
+      @funcs.fetch(name)
     end
 
     def self.t(name)
       @matchers ||= generate_matchers
-      @matchers[name]
+      @matchers.fetch(name)
     end
 
     def self.generate_matchers
       [
         :numeric, :string, :addsub, :subtract, :muldiv, :pow, :mod,
-        :comparator, :comp_gt, :comp_lt,
-        :open, :close, :comma,
-        :non_close_plus, :non_group, :non_group_star,
-        :logical, :combinator,
-        :if, :round, :roundup, :rounddown, :not
+        :comparator, :comp_gt, :comp_lt, :fopen, :open, :close, :comma,
+        :non_close_plus, :non_group, :non_group_star, :arguments,
+        :logical, :combinator, :if, :round, :roundup, :rounddown, :not
       ].each_with_object({}) do |name, matchers|
         matchers[name] = TokenMatcher.send(name)
       end
@@ -90,10 +88,10 @@ module Dentaku
         combine:    pattern(:logical,  :combinator,     :logical),
 
         if:         func_pattern(:if,        :non_group,      :comma, :non_group, :comma, :non_group),
-        round:      func_pattern(:round,     :non_close_plus),
-        roundup:    func_pattern(:roundup,   :non_close_plus),
-        rounddown:  func_pattern(:rounddown, :non_close_plus),
-        not:        func_pattern(:not,       :non_close_plus)
+        round:      func_pattern(:round,     :arguments),
+        roundup:    func_pattern(:roundup,   :arguments),
+        rounddown:  func_pattern(:rounddown, :arguments),
+        not:        func_pattern(:not,       :arguments)
       }
 
       @patterns[name]
@@ -104,7 +102,7 @@ module Dentaku
     end
 
     def self.func_pattern(func, *tokens)
-      pattern(func, :open, *tokens, :close)
+      pattern(func, :fopen, *tokens, :close)
     end
   end
 end

data/lib/dentaku/token_matcher.rb

@@ -2,27 +2,31 @@ require 'dentaku/token'
 
 module Dentaku
   class TokenMatcher
-    def initialize(categories=nil, values=nil)
-      @categories = [categories].compact.flatten
-      @values     = [values].compact.flatten
-      @invert     = false
+    attr_reader :children
 
-      @categories_hash = Hash[@categories.map { |cat| [cat, 1] }]
-      @values_hash = Hash[@values.map { |value| [value, 1] }]
+    def initialize(categories=nil, values=nil, children=[])
+      # store categories and values as hash to optimize key lookup, h/t @jan-mangs
+      @categories = [categories].compact.flatten.each_with_object({}) { |c,h| h[c] = 1 }
+      @values     = [values].compact.flatten.each_with_object({}) { |v,h| h[v] = 1 }
+      @children   = children.compact
+      @invert     = false
 
       @min = 1
       @max = 1
       @range = (@min..@max)
     end
 
+    def | (other_matcher)
+      self.class.new(:nomatch, :nomatch, leaf_matchers + other_matcher.leaf_matchers)
+    end
+
     def invert
       @invert = ! @invert
       self
     end
 
     def ==(token)
-      return false if token.nil?
-      (category_match(token.category) && value_match(token.value)) ^ @invert
+      leaf_matcher? ? matches_token?(token) : any_child_matches_token?(token)
     end
 
     def match(token_stream, offset=0)
@@ -53,40 +57,65 @@ module Dentaku
       self
     end
 
+    def leaf_matcher?
+      children.empty?
+    end
+
+    def leaf_matchers
+      leaf_matcher? ? [self] : children
+    end
+
     private
 
+    def any_child_matches_token?(token)
+      children.any? { |child| child == token }
+    end
+
+    def matches_token?(token)
+      return false if token.nil?
+      (category_match(token.category) && value_match(token.value)) ^ @invert
+    end
+
     def category_match(category)
-      @categories_hash.empty? || @categories_hash.key?(category)
+      @categories.empty? || @categories.key?(category)
     end
 
     def value_match(value)
-      @values.empty? || @values_hash.key?(value)
+      @values.empty? || @values.key?(value)
     end
 
     def self.numeric;        new(:numeric);                        end
     def self.string;         new(:string);                         end
+    def self.logical;        new(:logical);                        end
+    def self.value
+      new(:numeric) | new(:string) | new(:logical)
+    end
+
     def self.addsub;         new(:operator, [:add, :subtract]);    end
     def self.subtract;       new(:operator, :subtract);            end
     def self.muldiv;         new(:operator, [:multiply, :divide]); end
     def self.pow;            new(:operator, :pow);                 end
     def self.mod;            new(:operator, :mod);                 end
+    def self.combinator;     new(:combinator);                     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.fopen;          new(:grouping, :fopen);               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.non_group;      new(:grouping).invert;                end
+    def self.non_group_star; new(:grouping).invert.star;           end
+    def self.non_close_plus; new(:grouping, :close).invert.plus;   end
+    def self.arguments;      (value | comma).plus;                 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_close_plus; new(:grouping, :close).invert.plus;   end
-    def self.non_group;      new(:grouping).invert;                end
-    def self.non_group_star; new(:grouping).invert.star;           end
-
 
     def self.method_missing(name, *args, &block)
       new(:function, name)
@@ -95,6 +124,5 @@ module Dentaku
     def self.respond_to_missing?(name, include_priv)
       true
     end
-
   end
-end
+end

data/lib/dentaku/token_scanner.rb

@@ -13,7 +13,9 @@ module Dentaku
         value = raw = m.to_s
         value = @converter.call(raw) if @converter
 
-        return Token.new(@category, value, raw)
+        return Array(value).map do |v|
+          Token === v ? v : Token.new(@category, v, raw)
+        end
       end
 
       false
@@ -68,15 +70,18 @@ module Dentaku
       end
 
       def combinator
-        new(:combinator, '(and|or)\b', lambda {|raw| raw.strip.downcase.to_sym })
+        new(:combinator, '(and|or)\b', lambda { |raw| raw.strip.downcase.to_sym })
       end
 
       def function
-        new(:function, '(\w+\s*(?=\())', lambda {|raw| raw.strip.downcase.to_sym })
+        new(:function, '\w+\s*\(', lambda do |raw|
+          function_name = raw.gsub('(', '')
+          [Token.new(:function, function_name.strip.downcase.to_sym, function_name), Token.new(:grouping, :fopen, '(')]
+        end)
       end
 
       def identifier
-        new(:identifier, '\w+\b', lambda {|raw| raw.strip.downcase.to_sym })
+        new(:identifier, '\w+\b', lambda { |raw| raw.strip.downcase.to_sym })
       end
     end
   end

data/lib/dentaku/tokenizer.rb

@@ -4,7 +4,7 @@ require 'dentaku/token_scanner'
 
 module Dentaku
   class Tokenizer
-    LPAREN = TokenMatcher.new(:grouping, :open)
+    LPAREN = TokenMatcher.new(:grouping, [:open, :fopen])
     RPAREN = TokenMatcher.new(:grouping, :close)
 
     def tokenize(string)
@@ -25,16 +25,19 @@ module Dentaku
     end
 
     def scan(string, scanner)
-      if token = scanner.scan(string)
-        raise "unexpected zero-width match (:#{ token.category }) at '#{ string }'" if token.length == 0
+      if tokens = scanner.scan(string)
+        tokens.each do |token|
+          raise "unexpected zero-width match (:#{ token.category }) at '#{ string }'" if token.length == 0
 
-        @nesting += 1 if LPAREN == token
-        @nesting -= 1 if RPAREN == token
-        raise "too many closing parentheses" if @nesting < 0
+          @nesting += 1 if LPAREN == token
+          @nesting -= 1 if RPAREN == token
+          raise "too many closing parentheses" if @nesting < 0
 
-        @tokens << token unless token.is?(:whitespace)
+          @tokens << token unless token.is?(:whitespace)
+        end
 
-        [true, string[token.length..-1]]
+        match_length = tokens.map(&:length).reduce(:+)
+        [true, string[match_length..-1]]
       else
         [false, string]
       end

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "1.2.0"
+  VERSION = "1.2.1"
 end

data/spec/dentaku_spec.rb

@@ -8,4 +8,8 @@ describe Dentaku do
   it 'binds values to variables' do
     expect(Dentaku('oranges > 7', {:oranges => 10})).to be_truthy
   end
+
+  it 'evaulates a nested function' do
+    expect(Dentaku('roundup(roundup(3 * cherries) + raspberries)', cherries: 1.5, raspberries: 0.9)).to eql(6)
+  end
 end

data/spec/evaluator_spec.rb

@@ -70,12 +70,21 @@ describe Dentaku::Evaluator do
       end
     end
 
+    describe 'find_rule_match' do
+      it 'matches a function call' do
+        if_pattern, _ = *Dentaku::Rules.core_rules.first
+        position, tokens = evaluator.find_rule_match(if_pattern, token_stream(:if, :fopen, true, :comma, 1, :comma, 2, :close))
+        expect(position).to eq 0
+        expect(tokens.length).to eq 8
+      end
+    end
+
     describe 'functions' do
       it 'is evaluated' do
-        expect(evaluator.evaluate(token_stream(:round,     :open, 5, :divide, 3.0, :close))).to eq 2
-        expect(evaluator.evaluate(token_stream(:round,     :open, 5, :divide, 3.0, :comma, 2, :close))).to eq 1.67
-        expect(evaluator.evaluate(token_stream(:roundup,   :open, 5, :divide, 1.2, :close))).to eq 5
-        expect(evaluator.evaluate(token_stream(:rounddown, :open, 5, :divide, 1.2, :close))).to eq 4
+        expect(evaluator.evaluate(token_stream(:round,     :fopen, 5, :divide, 3.0, :close))).to eq 2
+        expect(evaluator.evaluate(token_stream(:round,     :fopen, 5, :divide, 3.0, :comma, 2, :close))).to eq 1.67
+        expect(evaluator.evaluate(token_stream(:roundup,   :fopen, 5, :divide, 1.2, :close))).to eq 5
+        expect(evaluator.evaluate(token_stream(:rounddown, :fopen, 5, :divide, 1.2, :close))).to eq 4
       end
     end
 
@@ -96,13 +105,13 @@ describe Dentaku::Evaluator do
       end
 
       it 'evaluates combined conditionals' do
-        expect(evaluator.evaluate(token_stream(5, :gt, 1, :or, :false))).to be_truthy
-        expect(evaluator.evaluate(token_stream(5, :gt, 1, :and, :false))).to be_falsey
+        expect(evaluator.evaluate(token_stream(5, :gt, 1, :or, false))).to be_truthy
+        expect(evaluator.evaluate(token_stream(5, :gt, 1, :and, false))).to be_falsey
       end
 
       it 'negates a logical value' do
-        expect(evaluator.evaluate(token_stream(:not, :open, 5, :gt, 1, :or,  :false, :close))).to be_falsey
-        expect(evaluator.evaluate(token_stream(:not, :open, 5, :gt, 1, :and, :false, :close))).to be_truthy
+        expect(evaluator.evaluate(token_stream(:not, :fopen, 5, :gt, 1, :or,  false, :close))).to be_falsey
+        expect(evaluator.evaluate(token_stream(:not, :fopen, 5, :gt, 1, :and, false, :close))).to be_truthy
       end
     end
   end

data/spec/external_function_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'dentaku/calculator'
 
 describe Dentaku::Calculator do
@@ -20,13 +21,13 @@ describe Dentaku::Calculator do
           {
             name:      :max,
             type:      :numeric,
-            signature: [ :non_close_plus ],
+            signature: [ :arguments ],
             body:      ->(*args) { args.max }
           },
           {
             name:      :min,
             type:      :numeric,
-            signature: [ :non_close_plus ],
+            signature: [ :arguments ],
             body:      ->(*args) { args.min }
           }
         ]

data/spec/spec_helper.rb

@@ -2,7 +2,6 @@
 def token_stream(*args)
   args.map do |value|
     type = type_for(value)
-    value = (value == :true) if type == :logical
     Dentaku::Token.new(type, value)
   end
 end
@@ -12,16 +11,18 @@ def type_for(value)
   case value
   when Numeric
     :numeric
+  when String
+    :string
+  when true, false
+    :logical
   when :add, :subtract, :multiply, :divide, :mod
     :operator
-  when :open, :close, :comma
+  when :fopen, :open, :close, :comma
     :grouping
   when :le, :ge, :ne, :ne, :lt, :gt, :eq
     :comparator
   when :and, :or
     :combinator
-  when :true, :false
-    :logical
   when :if, :round, :roundup, :rounddown, :not
     :function
   else

data/spec/token_matcher_spec.rb

@@ -53,6 +53,26 @@ describe Dentaku::TokenMatcher do
     expect(matcher).to eq(cmp)
   end
 
+  describe 'combining multiple tokens' do
+    let(:numeric) { described_class.new(:numeric) }
+    let(:string)  { described_class.new(:string) }
+
+    it 'matches either' do
+      either = numeric | string
+      expect(either).to eq(Dentaku::Token.new(:numeric, 5))
+      expect(either).to eq(Dentaku::Token.new(:string, 'rhubarb'))
+    end
+
+    it 'matches any value' do
+      value = described_class.value
+      expect(value).to eq(Dentaku::Token.new(:numeric, 8))
+      expect(value).to eq(Dentaku::Token.new(:string, 'apricot'))
+      expect(value).to eq(Dentaku::Token.new(:logical, false))
+      expect(value).not_to eq(Dentaku::Token.new(:function, :round))
+      expect(value).not_to eq(Dentaku::Token.new(:identifier, :hello))
+    end
+  end
+
   describe 'stream matching' do
     let(:stream) { token_stream(5, 11, 9, 24, :hello, 8) }
 
@@ -100,6 +120,16 @@ describe Dentaku::TokenMatcher do
         expect(matched).not_to be_truthy
       end
     end
+
+    describe 'arguments' do
+      it 'matches comma-separated values' do
+        stream = token_stream(1, :comma, 2, :comma, true, :comma, 'olive', :comma, :'(')
+        matched, substream = described_class.arguments.match(stream)
+        expect(matched).to be_truthy
+        expect(substream.length).to eq 8
+        expect(substream.map(&:value)).to eq [1, :comma, 2, :comma, true, :comma, 'olive', :comma]
+      end
+    end
   end
 end
 

data/spec/token_scanner_spec.rb

@@ -5,7 +5,7 @@ describe Dentaku::TokenScanner do
   let(:numeric)    { described_class.new(:numeric,    '(\d+(\.\d+)?|\.\d+)', lambda{|raw| raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i }) }
 
   it 'returns a token for a matching string' do
-    token = whitespace.scan(' ')
+    token = whitespace.scan(' ').first
     expect(token.category).to eq(:whitespace)
     expect(token.value).to eq(' ')
   end
@@ -15,7 +15,7 @@ describe Dentaku::TokenScanner do
   end
 
   it 'performs raw value conversion' do
-    token = numeric.scan('5')
+    token = numeric.scan('5').first
     expect(token.category).to eq(:numeric)
     expect(token.value).to eq(5)
   end

data/spec/tokenizer_spec.rb

@@ -102,36 +102,43 @@ describe Dentaku::Tokenizer do
       tokens = tokenizer.tokenize('if(x < 10, y, z)')
       expect(tokens.length).to eq(10)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :identifier, :comparator, :numeric, :grouping, :identifier, :grouping, :identifier, :grouping])
-      expect(tokens.map(&:value)).to eq([:if, :open, :x, :lt, 10, :comma, :y, :comma, :z, :close])
+      expect(tokens.map(&:value)).to eq([:if, :fopen, :x, :lt, 10, :comma, :y, :comma, :z, :close])
     end
 
     it 'include ROUND/UP/DOWN' do
       tokens = tokenizer.tokenize('round(8.2)')
       expect(tokens.length).to eq(4)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:round, :open, BigDecimal.new('8.2'), :close])
+      expect(tokens.map(&:value)).to eq([:round, :fopen, BigDecimal.new('8.2'), :close])
 
       tokens = tokenizer.tokenize('round(8.75, 1)')
       expect(tokens.length).to eq(6)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :grouping, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:round, :open, BigDecimal.new('8.75'), :comma, 1, :close])
+      expect(tokens.map(&:value)).to eq([:round, :fopen, BigDecimal.new('8.75'), :comma, 1, :close])
 
       tokens = tokenizer.tokenize('ROUNDUP(8.2)')
       expect(tokens.length).to eq(4)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:roundup, :open, BigDecimal.new('8.2'), :close])
+      expect(tokens.map(&:value)).to eq([:roundup, :fopen, BigDecimal.new('8.2'), :close])
 
       tokens = tokenizer.tokenize('RoundDown(8.2)')
       expect(tokens.length).to eq(4)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:rounddown, :open, BigDecimal.new('8.2'), :close])
+      expect(tokens.map(&:value)).to eq([:rounddown, :fopen, BigDecimal.new('8.2'), :close])
     end
 
     it 'include NOT' do
       tokens = tokenizer.tokenize('not(8 < 5)')
       expect(tokens.length).to eq(6)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :comparator, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:not, :open, 8, :lt, 5, :close])
+      expect(tokens.map(&:value)).to eq([:not, :fopen, 8, :lt, 5, :close])
+    end
+
+    it 'handles whitespace after function name' do
+      tokens = tokenizer.tokenize('not (8 < 5)')
+      expect(tokens.length).to eq(6)
+      expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :comparator, :numeric, :grouping])
+      expect(tokens.map(&:value)).to eq([:not, :fopen, 8, :lt, 5, :close])
     end
   end
 end

metadata

@@ -1,53 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
+  prerelease: 
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-21 00:00:00.000000000 Z
+date: 2014-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: |2
-      Dentaku is a parser and evaluator for mathematical formulas
+description: ! '    Dentaku is a parser and evaluator for mathematical formulas
+
+'
 email:
 - rubysolo@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
+- .travis.yml
 - Gemfile
 - README.md
 - Rakefile
@@ -57,6 +63,7 @@ files:
 - lib/dentaku/calculator.rb
 - lib/dentaku/dependency_resolver.rb
 - lib/dentaku/evaluator.rb
+- lib/dentaku/exceptions.rb
 - lib/dentaku/expression.rb
 - lib/dentaku/external_function.rb
 - lib/dentaku/rules.rb
@@ -79,26 +86,33 @@ files:
 homepage: http://github.com/rubysolo/dentaku
 licenses:
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1375666282720046081
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1375666282720046081
 requirements: []
 rubyforge_project: dentaku
-rubygems_version: 2.2.2
+rubygems_version: 1.8.23.2
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: A formula language parser and evaluator
 test_files:
 - spec/binary_operation_spec.rb

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 064d1f2a40ca1fa6caf9b07f5fb535a673fcbe32
-  data.tar.gz: 0fe2cb4349c5423da447fa81173d3b70636bacff
-SHA512:
-  metadata.gz: 55fdf11b6a81a851c4d5db09bd2d1ee3385d7ca0f08d2ba806bb9cf9dc914acda0b90d38b817353d28ab99c1b89b198a7d10e998360b2870ca04d485616a97cf
-  data.tar.gz: f68bc08dd8d1ff2f3d4e79f5af7f3131b59ce539d2001360e78c8fe340421f993c6e67d4ea1490b69928861c19b74615caea09cfd0e74cd251f0affd142eb0bd