dentaku 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85e18c02f88a1fc906c69667776e00ccb1f969f5
-  data.tar.gz: 6fba624e3b93a4e64e2ce55fb6fe13f42d9138be
+  metadata.gz: fa37d9abba8c7bf0ea6d99f1f0ac472058772436
+  data.tar.gz: c07c67b22659bb6c26d7a70edd119bee53ada064
 SHA512:
-  metadata.gz: befe922779a83e64b95ed17907846a29901c59badb2810d2c28f2555aabc5359f7a21a1aeac6cca12b63c39bb59dad225ce233bfccc59b91af9eea027f3ab3cf
-  data.tar.gz: 2bac8daaa567d69860f8c5d00ed52375f989bde4893bb7b405ca513c257edf987a742ea7dc97d5817d8fa6023a82a77040bd69e17ca487c4f2fc45c8c6fba4e1
+  metadata.gz: 4b489326fecca7a6a114c64d01efd17149992338167e42cec9fd71f1e12b96bafb72a91ccf2b8b4f6ab895b85d72a74ceb12ad3c3a2b574bff7f3a43471bbb2f
+  data.tar.gz: 58bf32696c4c604269f117fa062dc5ea155dd6c9d2eab7007611dd8bc75b129b332d63dfa15aff3deb4f5c6bd1153aed9546fa3ffbca0b59a8c9fa398dfc0868

data/CHANGELOG.md

@@ -0,0 +1,97 @@
+# Change Log
+
+## [v2.0.1] 2015-08-15
+- add support for boolean literals
+- implement basic parse-time type checking
+
+## [v2.0.0] 2015-08-07
+- shunting-yard parser for performance enhancement and AST generation
+- AST caching for performance enhancement
+- support comments in formulas
+- support all functions from the Ruby Math module
+
+## [v1.2.6] 2015-05-30
+- support custom error handlers for systems of formulas
+
+## [v1.2.5] 2015-05-23
+- fix memory leak
+
+## [v1.2.2] 2014-12-19
+- performance enhancements
+- unary minus bug fixes
+- preserve provided hash keys for systems of formulas
+
+## [v1.2.0] 2014-10-21
+- add dependency resolution to automatically solve systems of formulas
+
+## [v1.1.0] 2014-07-30
+- add strict evaluation mode to raise `UnboundVariableError` if not all variable values are provided
+- return division results as `BigDecimal` values
+
+## [v1.0.0] 2014-03-06
+- cleanup and 1.0 release
+
+## [v0.2.14] 2014-01-24
+- add modulo operator
+- add unary percentage operator
+- support registration of custom functions at runtime
+
+## [v0.2.10] 2012-12-10
+- return integer result for exact division, decimal otherwise
+
+## [v0.2.9] 2012-10-17
+- add `ROUNDUP` / `ROUNDDOWN` functions
+
+## [v0.2.8] 2012-09-30
+- make function name matching case-insensitive
+
+## [v0.2.7] 2012-09-26
+- support passing arbitrary expressions as function arguments
+
+## [v0.2.6] 2012-09-19
+- add `NOT` function
+
+## [v0.2.5] 2012-06-20
+- add exponent operator
+- add support for digits in variable identifiers
+
+## [v0.2.4] 2012-02-29
+- add support for `min < x < max` syntax for inequality ranges
+
+## [v0.2.2] 2012-02-22
+- support `ROUND` to arbitrary decimal place on older Rubies
+- ensure case is preserved for string values
+
+## [v0.2.1] 2012-02-12
+- add `ROUND` function
+
+## [v0.1.3] 2012-01-31
+- add support for string datatype
+
+## [v0.1.1] 2012-01-24
+- change from square bracket to parentheses for top-level evaluation
+- add `IF` function
+
+## [v0.1.0] 2012-01-20
+- initial release
+
+[v2.0.0]:  https://github.com/rubysolo/dentaku/compare/v1.2.6...v2.0.0
+[v1.2.6]:  https://github.com/rubysolo/dentaku/compare/v1.2.5...v1.2.6
+[v1.2.5]:  https://github.com/rubysolo/dentaku/compare/v1.2.2...v1.2.5
+[v1.2.2]:  https://github.com/rubysolo/dentaku/compare/v1.2.0...v1.2.2
+[v1.2.0]:  https://github.com/rubysolo/dentaku/compare/v1.1.0...v1.2.0
+[v1.1.0]:  https://github.com/rubysolo/dentaku/compare/v1.0.0...v1.1.0
+[v1.0.0]:  https://github.com/rubysolo/dentaku/compare/v0.2.14...v1.0.0
+[v0.2.14]: https://github.com/rubysolo/dentaku/compare/v0.2.10...v0.2.14
+[v0.2.10]: https://github.com/rubysolo/dentaku/compare/v0.2.9...v0.2.10
+[v0.2.9]:  https://github.com/rubysolo/dentaku/compare/v0.2.8...v0.2.9
+[v0.2.8]:  https://github.com/rubysolo/dentaku/compare/v0.2.7...v0.2.8
+[v0.2.7]:  https://github.com/rubysolo/dentaku/compare/v0.2.6...v0.2.7
+[v0.2.6]:  https://github.com/rubysolo/dentaku/compare/v0.2.5...v0.2.6
+[v0.2.5]:  https://github.com/rubysolo/dentaku/compare/v0.2.4...v0.2.5
+[v0.2.4]:  https://github.com/rubysolo/dentaku/compare/v0.2.2...v0.2.4
+[v0.2.2]:  https://github.com/rubysolo/dentaku/compare/v0.2.1...v0.2.2
+[v0.2.1]:  https://github.com/rubysolo/dentaku/compare/v0.1.3...v0.2.1
+[v0.1.3]:  https://github.com/rubysolo/dentaku/compare/v0.1.1...v0.1.3
+[v0.1.1]:  https://github.com/rubysolo/dentaku/compare/v0.1.0...v0.1.1
+[v0.1.0]:  https://github.com/rubysolo/dentaku/commit/68724fd9c8fa637baf7b9d5515df0caa31e226bd

data/README.md

@@ -5,6 +5,7 @@ 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)
+[![Hakiri](https://hakiri.io/github/rubysolo/dentaku/master.svg)](https://hakiri.io/github/rubysolo/dentaku)
 
 DESCRIPTION
 -----------
@@ -204,15 +205,15 @@ that's not feasible because:
 1. The formula is the secret sauce for your startup
 
 Whatever your reasons, Dentaku supports adding functions at runtime.  To add a
-function, you'll need to specify a name and a lambda that accepts all function
-arguments and returns the result value.
+function, you'll need to specify a name, a return type, and a lambda that
+accepts all function arguments and returns the result value.
 
 Here's an example of adding a function named `POW` that implements
 exponentiation.
 
 ```ruby
 > c = Dentaku::Calculator.new
-> c.add_function(:pow, ->(mantissa, exponent) { mantissa ** exponent })
+> c.add_function(:pow, :numeric, ->(mantissa, exponent) { mantissa ** exponent })
 > c.evaluate('POW(3,2)')
 #=> 9
 > c.evaluate('POW(2,3)')
@@ -223,7 +224,7 @@ Here's an example of adding a variadic function:
 
 ```ruby
 > c = Dentaku::Calculator.new
-> c.add_function(:max, ->(*args) { args.max })
+> c.add_function(:max, :numeric, ->(*args) { args.max })
 > c.evaluate 'MAX(8,6,7,5,3,0,9)'
 #=> 9
 ```

data/lib/dentaku/ast.rb

@@ -1,13 +1,10 @@
 require_relative './ast/node'
 require_relative './ast/nil'
 require_relative './ast/numeric'
+require_relative './ast/logical'
 require_relative './ast/string'
 require_relative './ast/identifier'
-require_relative './ast/addition'
-require_relative './ast/subtraction'
-require_relative './ast/multiplication'
-require_relative './ast/division'
-require_relative './ast/exponentiation'
+require_relative './ast/arithmetic'
 require_relative './ast/negation'
 require_relative './ast/comparators'
 require_relative './ast/combinators'

data/lib/dentaku/ast/arithmetic.rb

@@ -0,0 +1,72 @@
+require_relative './operation'
+
+module Dentaku
+  module AST
+    class Arithmetic < Operation
+      def initialize(*)
+        super
+        fail "#{ self.class } requires numeric operands" unless valid_node?(left) && valid_node?(right)
+      end
+
+      def type
+        :numeric
+      end
+
+      private
+
+      def valid_node?(node)
+        node.is_a?(Identifier) || node.type == :numeric
+      end
+    end
+
+    class Addition < Arithmetic
+      def value(context={})
+        left.value(context) + right.value(context)
+      end
+
+      def self.precedence
+        10
+      end
+    end
+
+    class Subtraction < Arithmetic
+      def value(context={})
+        left.value(context) - right.value(context)
+      end
+
+      def self.precedence
+        10
+      end
+    end
+
+    class Multiplication < Arithmetic
+      def value(context={})
+        left.value(context) * right.value(context)
+      end
+
+      def self.precedence
+        20
+      end
+    end
+
+    class Division < Arithmetic
+      def value(context={})
+        left.value(context) / right.value(context)
+      end
+
+      def self.precedence
+        20
+      end
+    end
+
+    class Exponentiation < Arithmetic
+      def value(context={})
+        left.value(context) ** right.value(context)
+      end
+
+      def self.precedence
+        30
+      end
+    end
+  end
+end

data/lib/dentaku/ast/combinators.rb

@@ -1,12 +1,27 @@
+require_relative './operation'
+
 module Dentaku
   module AST
-    class And < Operation
+    class Combinator < Operation
+      def initialize(*)
+        super
+        fail "#{ self.class } requires logical operands" unless valid_node?(left) && valid_node?(right)
+      end
+
+      private
+
+      def valid_node?(node)
+        node.is_a?(Identifier) || node.type == :logical
+      end
+    end
+
+    class And < Combinator
       def value(context={})
         left.value(context) && right.value(context)
       end
     end
 
-    class Or < Operation
+    class Or < Combinator
       def value(context={})
         left.value(context) || right.value(context)
       end

data/lib/dentaku/ast/comparators.rb

@@ -6,6 +6,10 @@ module Dentaku
       def self.precedence
         5
       end
+
+      def type
+        :logical
+      end
     end
 
     class LessThan < Comparator

data/lib/dentaku/ast/function.rb

@@ -15,7 +15,7 @@ module Dentaku
         registry.fetch(function_name(name)) { fail "Undefined function #{ name } "}
       end
 
-      def self.register(name, implementation)
+      def self.register(name, type, implementation)
         function = Class.new(self) do
           def self.implementation=(impl)
             @implementation = impl
@@ -25,13 +25,30 @@ module Dentaku
             @implementation
           end
 
+          def self.type=(type)
+            @type = type
+          end
+
+          def self.type
+            @type
+          end
+
           def value(context={})
             args = @args.flat_map { |a| a.value(context) }
             self.class.implementation.call(*args)
           end
+
+          def type
+            self.class.type
+          end
         end
 
+        function_class = name.to_s.capitalize
+        Dentaku::AST.send(:remove_const, function_class) if Dentaku::AST.const_defined?(function_class)
+        Dentaku::AST.const_set(function_class, function)
+
         function.implementation = implementation
+        function.type = type
 
         registry[function_name(name)] = function
       end

data/lib/dentaku/ast/functions/if.rb

@@ -15,6 +15,10 @@ module Dentaku
         predicate.value(context) ? left.value(context) : right.value(context)
       end
 
+      def type
+        left.type
+      end
+
       def dependencies(context={})
         # TODO : short-circuit?
         (predicate.dependencies(context) + left.dependencies(context) + right.dependencies(context)).uniq

data/lib/dentaku/ast/functions/max.rb

@@ -1,5 +1,5 @@
 require_relative '../function'
 
-Dentaku::AST::Function.register(:max, ->(*args) {
+Dentaku::AST::Function.register(:max, :numeric, ->(*args) {
   args.max
 })

data/lib/dentaku/ast/functions/min.rb

@@ -1,5 +1,5 @@
 require_relative '../function'
 
-Dentaku::AST::Function.register(:min, ->(*args) {
+Dentaku::AST::Function.register(:min, :numeric, ->(*args) {
   args.min
 })

data/lib/dentaku/ast/functions/not.rb

@@ -1,5 +1,5 @@
 require_relative '../function'
 
-Dentaku::AST::Function.register(:not, ->(logical) {
+Dentaku::AST::Function.register(:not, :logical, ->(logical) {
   ! logical
 })

data/lib/dentaku/ast/functions/round.rb

@@ -1,5 +1,5 @@
 require_relative '../function'
 
-Dentaku::AST::Function.register(:round, ->(numeric, places=nil) {
+Dentaku::AST::Function.register(:round, :numeric, ->(numeric, places=nil) {
   numeric.round(places || 0)
 })

data/lib/dentaku/ast/functions/rounddown.rb

@@ -1,5 +1,5 @@
 require_relative '../function'
 
-Dentaku::AST::Function.register(:rounddown, ->(numeric) {
+Dentaku::AST::Function.register(:rounddown, :numeric, ->(numeric) {
   numeric.floor
 })

data/lib/dentaku/ast/functions/roundup.rb

@@ -1,5 +1,5 @@
 require_relative '../function'
 
-Dentaku::AST::Function.register(:roundup, ->(numeric) {
+Dentaku::AST::Function.register(:roundup, :numeric, ->(numeric) {
   numeric.ceil
 })

data/lib/dentaku/ast/functions/ruby_math.rb

@@ -2,7 +2,7 @@
 require_relative "../function"
 
 Math.methods(false).each do |method|
-  Dentaku::AST::Function.register(method, ->(*args) {
+  Dentaku::AST::Function.register(method, :numeric, ->(*args) {
     Math.send(method, *args)
   })
 end

data/lib/dentaku/ast/grouping.rb

@@ -8,6 +8,10 @@ module Dentaku
       def value(context={})
         @node.value(context)
       end
+
+      def type
+        @node.type
+      end
     end
   end
 end

data/lib/dentaku/ast/literal.rb

@@ -0,0 +1,20 @@
+module Dentaku
+  module AST
+    class Literal < Node
+      attr_reader :type
+
+      def initialize(token)
+        @value = token.value
+        @type  = token.category
+      end
+
+      def value(*)
+        @value
+      end
+
+      def dependencies(*)
+        []
+      end
+    end
+  end
+end

data/lib/dentaku/ast/logical.rb

@@ -0,0 +1,8 @@
+require_relative "./literal"
+
+module Dentaku
+  module AST
+    class Logical < Literal
+    end
+  end
+end

data/lib/dentaku/ast/negation.rb

@@ -3,12 +3,17 @@ module Dentaku
     class Negation < Operation
       def initialize(node)
         @node = node
+        fail "Negation requires numeric operand" unless valid_node?(node)
       end
 
       def value(context={})
         @node.value(context) * -1
       end
 
+      def type
+        :numeric
+      end
+
       def self.arity
         1
       end
@@ -20,6 +25,12 @@ module Dentaku
       def self.precedence
         40
       end
+
+      private
+
+      def valid_node?(node)
+        node.is_a?(Identifier) || node.type == :numeric
+      end
     end
   end
 end

data/lib/dentaku/ast/numeric.rb

@@ -1,17 +1,8 @@
+require_relative "./literal"
+
 module Dentaku
   module AST
-    class Numeric < Node
-      def initialize(token)
-        @value = token.value
-      end
-
-      def value(*)
-        @value
-      end
-
-      def dependencies(*)
-        []
-      end
+    class Numeric < Literal
     end
   end
 end

data/lib/dentaku/ast/operation.rb

@@ -1,3 +1,5 @@
+require_relative './node'
+
 module Dentaku
   module AST
     class Operation < Node

data/lib/dentaku/ast/string.rb

@@ -1,17 +1,8 @@
+require_relative "./literal"
+
 module Dentaku
   module AST
-    class String < Node
-      def initialize(token)
-        @value = token.value
-      end
-
-      def value(*)
-        @value
-      end
-
-      def dependencies(*)
-        []
-      end
+    class String < Literal
     end
   end
 end

data/lib/dentaku/calculator.rb

@@ -14,13 +14,13 @@ module Dentaku
       @ast_cache = {}
     end
 
-    def add_function(name, body)
-      Dentaku::AST::Function.register(name, body)
+    def add_function(name, type, body)
+      Dentaku::AST::Function.register(name, type, body)
       self
     end
 
     def add_functions(fns)
-      fns.each { |(name, body)| add_function(name, body) }
+      fns.each { |(name, type, body)| add_function(name, type, body) }
       self
     end
 

data/lib/dentaku/parser.rb

@@ -28,6 +28,9 @@ module Dentaku
         when :numeric
           output.push AST::Numeric.new(token)
 
+        when :logical
+          output.push AST::Logical.new(token)
+
         when :string
           output.push AST::String.new(token)
 

data/lib/dentaku/token_scanner.rb

@@ -35,6 +35,7 @@ module Dentaku
           grouping,
           comparator,
           combinator,
+          boolean,
           function,
           identifier
         ]
@@ -88,6 +89,10 @@ module Dentaku
         new(:combinator, '(and|or)\b', lambda { |raw| raw.strip.downcase.to_sym })
       end
 
+      def boolean
+        new(:logical, '(true|false)\b', lambda { |raw| raw.strip.downcase == 'true' })
+      end
+
       def function
         new(:function, '\w+\s*\(', lambda do |raw|
           function_name = raw.gsub('(', '')

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "2.0.0"
+  VERSION = "2.0.1"
 end

data/spec/ast/addition_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'dentaku/ast/arithmetic'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Addition do
+  let(:five) { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 5) }
+  let(:six)  { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 6) }
+
+  let(:t)    { Dentaku::AST::Numeric.new Dentaku::Token.new(:logical, true) }
+
+  it 'performs addition' do
+    node = described_class.new(five, six)
+    expect(node.value).to eq 11
+  end
+
+  it 'requires numeric operands' do
+    expect {
+      described_class.new(five, t)
+    }.to raise_error
+
+    expression = Dentaku::AST::Multiplication.new(five, five)
+    group = Dentaku::AST::Grouping.new(expression)
+
+    expect {
+      described_class.new(group, five)
+    }.not_to raise_error
+  end
+end

data/spec/ast/and_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'dentaku/ast/combinators'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::And do
+  let(:t) { Dentaku::AST::Logical.new Dentaku::Token.new(:logical, true)  }
+  let(:f) { Dentaku::AST::Logical.new Dentaku::Token.new(:logical, false) }
+
+  let(:five) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 5) }
+
+  it 'performs logical AND' do
+    node = described_class.new(t, f)
+    expect(node.value).to eq false
+  end
+
+  it 'requires logical operands' do
+    expect {
+      described_class.new(t, five)
+    }.to raise_error
+
+    expression = Dentaku::AST::LessThanOrEqual.new(five, five)
+    expect {
+      described_class.new(t, expression)
+    }.not_to raise_error
+  end
+end

data/spec/ast/function_spec.rb

@@ -11,7 +11,7 @@ describe Dentaku::AST::Function do
   end
 
   it 'registers a custom function' do
-    described_class.register("flarble", -> { "flarble" })
+    described_class.register("flarble", :string, -> { "flarble" })
     expect { described_class.get("flarble") }.not_to raise_error
     function = described_class.get("flarble").new
     expect(function.value).to eq "flarble"

data/spec/ast/numeric_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'dentaku/ast/numeric'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Numeric do
+  subject { described_class.new(Dentaku::Token.new(:numeric, 5)) }
+
+  it 'has numeric type' do
+    expect(subject.type).to eq :numeric
+  end
+
+  it 'has no dependencies' do
+    expect(subject.dependencies).to be_empty
+  end
+end

data/spec/external_function_spec.rb

@@ -8,12 +8,12 @@ describe Dentaku::Calculator do
       let(:with_external_funcs) do
         c = described_class.new
 
-        c.add_function(:now, -> { Time.now.to_s })
+        c.add_function(:now, :string, -> { Time.now.to_s })
 
         fns = [
-          [:pow,      ->(mantissa, exponent) { mantissa ** exponent }],
-          [:biggest,  ->(*args) { args.max }],
-          [:smallest, ->(*args) { args.min }],
+          [:pow,      :numeric, ->(mantissa, exponent) { mantissa ** exponent }],
+          [:biggest,  :numeric, ->(*args) { args.max }],
+          [:smallest, :numeric, ->(*args) { args.min }],
         ]
 
         c.add_functions(fns)

data/spec/parser_spec.rb

@@ -85,4 +85,13 @@ describe Dentaku::Parser do
     expect { node.value }.to raise_error
     expect(node.value(x: 3)).to eq 15
   end
+
+  it 'evaluates boolean expressions' do
+    d_true  = Dentaku::Token.new(:logical, true)
+    d_and   = Dentaku::Token.new(:combinator, :and)
+    d_false = Dentaku::Token.new(:logical, false)
+
+    node  = described_class.new([d_true, d_and, d_false]).parse
+    expect(node.value).to eq false
+  end
 end

data/spec/token_scanner_spec.rb

@@ -3,7 +3,7 @@ require 'dentaku/token_scanner'
 describe Dentaku::TokenScanner do
   let(:whitespace) { described_class.new(:whitespace, '\s') }
   let(:numeric)    { described_class.new(:numeric,    '(\d+(\.\d+)?|\.\d+)',
-    lambda{|raw| raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i })
+    lambda { |raw| raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i })
   }
 
   it 'returns a token for a matching string' do
@@ -23,6 +23,6 @@ describe Dentaku::TokenScanner do
   end
 
   it 'returns a list of all configured scanners' do
-    expect(described_class.scanners.length).to eq 11
+    expect(described_class.scanners.length).to eq 12
   end
 end

data/spec/tokenizer_spec.rb

@@ -153,6 +153,18 @@ describe Dentaku::Tokenizer do
     expect(tokens.map(&:value)).to eq(['andover', :lt, 10])
   end
 
+  it 'tokenizes TRUE and FALSE literals' do
+    tokens = tokenizer.tokenize('true and false')
+    expect(tokens.length).to eq(3)
+    expect(tokens.map(&:category)).to eq([:logical, :combinator, :logical])
+    expect(tokens.map(&:value)).to eq([true, :and, false])
+
+    tokens = tokenizer.tokenize('true_lies and falsehoods')
+    expect(tokens.length).to eq(3)
+    expect(tokens.map(&:category)).to eq([:identifier, :combinator, :identifier])
+    expect(tokens.map(&:value)).to eq(['true_lies', :and, 'falsehoods'])
+  end
+
   describe 'functions' do
     it 'include IF' do
       tokens = tokenizer.tokenize('if(x < 10, y, z)')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-07 00:00:00.000000000 Z
+date: 2015-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -63,17 +63,16 @@ files:
 - ".gitignore"
 - ".pryrc"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
 - dentaku.gemspec
 - lib/dentaku.rb
 - lib/dentaku/ast.rb
-- lib/dentaku/ast/addition.rb
+- lib/dentaku/ast/arithmetic.rb
 - lib/dentaku/ast/combinators.rb
 - lib/dentaku/ast/comparators.rb
-- lib/dentaku/ast/division.rb
-- lib/dentaku/ast/exponentiation.rb
 - lib/dentaku/ast/function.rb
 - lib/dentaku/ast/functions/if.rb
 - lib/dentaku/ast/functions/max.rb
@@ -85,14 +84,14 @@ files:
 - lib/dentaku/ast/functions/ruby_math.rb
 - lib/dentaku/ast/grouping.rb
 - lib/dentaku/ast/identifier.rb
-- lib/dentaku/ast/multiplication.rb
+- lib/dentaku/ast/literal.rb
+- lib/dentaku/ast/logical.rb
 - lib/dentaku/ast/negation.rb
 - lib/dentaku/ast/nil.rb
 - lib/dentaku/ast/node.rb
 - lib/dentaku/ast/numeric.rb
 - lib/dentaku/ast/operation.rb
 - lib/dentaku/ast/string.rb
-- lib/dentaku/ast/subtraction.rb
 - lib/dentaku/bulk_expression_solver.rb
 - lib/dentaku/calculator.rb
 - lib/dentaku/dependency_resolver.rb
@@ -104,8 +103,11 @@ files:
 - lib/dentaku/token_scanner.rb
 - lib/dentaku/tokenizer.rb
 - lib/dentaku/version.rb
+- spec/ast/addition_spec.rb
+- spec/ast/and_spec.rb
 - spec/ast/function_spec.rb
 - spec/ast/node_spec.rb
+- spec/ast/numeric_spec.rb
 - spec/benchmark.rb
 - spec/bulk_expression_solver_spec.rb
 - spec/calculator_spec.rb
@@ -142,8 +144,11 @@ signing_key:
 specification_version: 4
 summary: A formula language parser and evaluator
 test_files:
+- spec/ast/addition_spec.rb
+- spec/ast/and_spec.rb
 - spec/ast/function_spec.rb
 - spec/ast/node_spec.rb
+- spec/ast/numeric_spec.rb
 - spec/benchmark.rb
 - spec/bulk_expression_solver_spec.rb
 - spec/calculator_spec.rb

data/lib/dentaku/ast/addition.rb

@@ -1,15 +0,0 @@
-require_relative './operation'
-
-module Dentaku
-  module AST
-    class Addition < Operation
-      def value(context={})
-        left.value(context) + right.value(context)
-      end
-
-      def self.precedence
-        10
-      end
-    end
-  end
-end

data/lib/dentaku/ast/division.rb

@@ -1,15 +0,0 @@
-require_relative './operation'
-
-module Dentaku
-  module AST
-    class Division < Operation
-      def value(context={})
-        left.value(context) / right.value(context)
-      end
-
-      def self.precedence
-        20
-      end
-    end
-  end
-end

data/lib/dentaku/ast/exponentiation.rb

@@ -1,15 +0,0 @@
-require_relative './operation'
-
-module Dentaku
-  module AST
-    class Exponentiation < Operation
-      def value(context={})
-        left.value(context) ** right.value(context)
-      end
-
-      def self.precedence
-        30
-      end
-    end
-  end
-end

data/lib/dentaku/ast/multiplication.rb

@@ -1,15 +0,0 @@
-require_relative './operation'
-
-module Dentaku
-  module AST
-    class Multiplication < Operation
-      def value(context={})
-        left.value(context) * right.value(context)
-      end
-
-      def self.precedence
-        20
-      end
-    end
-  end
-end

data/lib/dentaku/ast/subtraction.rb

@@ -1,15 +0,0 @@
-require_relative './operation'
-
-module Dentaku
-  module AST
-    class Subtraction < Operation
-      def value(context={})
-        left.value(context) - right.value(context)
-      end
-
-      def self.precedence
-        10
-      end
-    end
-  end
-end