dentaku 1.2.6 → 2.0.0

data/lib/dentaku/token.rb

@@ -16,6 +16,10 @@ module Dentaku
       raw_value.to_s.length
     end
 
+    def grouping?
+      is?(:grouping)
+    end
+
     def is?(c)
       category == c
     end

data/lib/dentaku/token_matchers.rb

@@ -0,0 +1,29 @@
+module Dentaku
+  module TokenMatchers
+    def self.token_matchers(*symbols)
+      symbols.map { |s| matcher(s) }
+    end
+
+    def self.function_token_matchers(function_name, *symbols)
+      token_matchers(:fopen, *symbols, :close).unshift(
+        TokenMatcher.send(function_name)
+      )
+    end
+
+    def self.matcher(symbol)
+      @matchers ||= [
+        :numeric, :string, :addsub, :subtract, :muldiv, :pow, :mod,
+        :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,
+        :anchored_minus, :math_neg_pow, :math_neg_mul
+      ].each_with_object({}) do |name, matchers|
+        matchers[name] = TokenMatcher.send(name)
+      end
+
+      @matchers.fetch(symbol) do
+        raise "Unknown token symbol #{ symbol }"
+      end
+    end
+  end
+end

data/lib/dentaku/token_scanner.rb

@@ -1,15 +1,17 @@
+require 'bigdecimal'
 require 'dentaku/token'
 
 module Dentaku
   class TokenScanner
-    def initialize(category, regexp, converter=nil)
+    def initialize(category, regexp, converter=nil, condition=nil)
       @category  = category
       @regexp    = %r{\A(#{ regexp })}i
       @converter = converter
+      @condition = condition || ->(*) { true }
     end
 
-    def scan(string)
-      if m = @regexp.match(string)
+    def scan(string, last_token=nil)
+      if (m = @regexp.match(string)) && @condition.call(last_token)
         value = raw = m.to_s
         value = @converter.call(raw) if @converter
 
@@ -28,6 +30,7 @@ module Dentaku
           numeric,
           double_quoted_string,
           single_quoted_string,
+          negate,
           operator,
           grouping,
           comparator,
@@ -53,6 +56,18 @@ module Dentaku
         new(:string, "'[^']*'", lambda { |raw| raw.gsub(/^'|'$/, '') })
       end
 
+      def negate
+        new(:operator, '-', lambda { |raw| :negate }, lambda { |last_token|
+          last_token.nil?             ||
+          last_token.is?(:operator)   ||
+          last_token.is?(:comparator) ||
+          last_token.is?(:combinator) ||
+          last_token.value == :open   ||
+          last_token.value == :fopen  ||
+          last_token.value == :comma
+        })
+      end
+
       def operator
         names = { pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%' }.invert
         new(:operator, '\^|\+|-|\*|\/|%', lambda { |raw| names[raw] })

data/lib/dentaku/tokenizer.rb

@@ -10,7 +10,7 @@ module Dentaku
     def tokenize(string)
       @nesting = 0
       @tokens  = []
-      input    = string.to_s.dup
+      input    = strip_comments(string.to_s.dup)
 
       until input.empty?
         raise "parse error at: '#{ input }'" unless TokenScanner.scanners.any? do |scanner|
@@ -24,8 +24,12 @@ module Dentaku
       @tokens
     end
 
+    def last_token
+      @tokens.last
+    end
+
     def scan(string, scanner)
-      if tokens = scanner.scan(string)
+      if tokens = scanner.scan(string, last_token)
         tokens.each do |token|
           raise "unexpected zero-width match (:#{ token.category }) at '#{ string }'" if token.length == 0
 
@@ -42,5 +46,9 @@ module Dentaku
         [false, string]
       end
     end
+
+    def strip_comments(input)
+      input.gsub(/\/\*[^*]*\*+(?:[^*\/][^*]*\*+)*\//, '')
+    end
   end
 end

data/lib/dentaku/version.rb

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

data/spec/ast/function_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'dentaku/ast/function'
+
+describe Dentaku::AST::Function do
+  it 'maintains a function registry' do
+    expect(described_class).to respond_to(:get)
+  end
+
+  it 'raises an exception when trying to access an undefined function' do
+    expect { described_class.get("flarble") }.to raise_error
+  end
+
+  it 'registers a custom function' do
+    described_class.register("flarble", -> { "flarble" })
+    expect { described_class.get("flarble") }.not_to raise_error
+    function = described_class.get("flarble").new
+    expect(function.value).to eq "flarble"
+  end
+end

data/spec/ast/node_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'dentaku/ast/node'
+require 'dentaku/tokenizer'
+require 'dentaku/parser'
+
+describe Dentaku::AST::Node do
+  it 'returns list of dependencies' do
+    node = make_node('x + 5')
+    expect(node.dependencies).to eq ['x']
+
+    node = make_node('5 < x')
+    expect(node.dependencies).to eq ['x']
+
+    node = make_node('5 < 7')
+    expect(node.dependencies).to eq []
+
+    node = make_node('(y * 7)')
+    expect(node.dependencies).to eq ['y']
+
+    node = make_node('if(x > 5, y, z)')
+    expect(node.dependencies).to eq ['x', 'y', 'z']
+
+    node = make_node('if(x > 5, y, z)')
+    expect(node.dependencies('x' => 7)).to eq ['y', 'z']
+  end
+
+  it 'returns unique list of dependencies' do
+    node = make_node('x + x')
+    expect(node.dependencies).to eq ['x']
+  end
+
+  private
+
+  def make_node(expression)
+    Dentaku::Parser.new(Dentaku::Tokenizer.new.tokenize(expression)).parse
+  end
+end

data/spec/bulk_expression_solver_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'dentaku/bulk_expression_solver'
 
 RSpec.describe Dentaku::BulkExpressionSolver do
@@ -17,34 +18,40 @@ RSpec.describe Dentaku::BulkExpressionSolver do
     it "lets you know if a variable is unbound" do
       expressions = {more_apples: "apples + 1"}
       expect {
-        described_class.new(expressions, {}).solve!()
+        described_class.new(expressions, {}).solve!
       }.to raise_error(Dentaku::UnboundVariableError)
     end
 
     it "lets you know if the result is a div/0 error" do
       expressions = {more_apples: "1/0"}
       expect {
-        described_class.new(expressions, {}).solve!()
+        described_class.new(expressions, {}).solve!
       }.to raise_error(ZeroDivisionError)
     end
+
+    it "does not require keys to be parseable" do
+      expressions = { "the value of x, incremented" => "x + 1" }
+      solver = described_class.new(expressions, "x" => 3)
+      expect(solver.solve!).to eq({ "the value of x, incremented" => 4 })
+    end
   end
 
   describe "#solve" do
     it "returns :undefined when variables are unbound" do
       expressions = {more_apples: "apples + 1"}
-      expect(described_class.new(expressions, {}).solve())
+      expect(described_class.new(expressions, {}).solve)
         .to eq(more_apples: :undefined)
     end
 
     it "allows passing in a custom value to an error handler when a variable is unbound" do
       expressions = {more_apples: "apples + 1"}
-      expect(described_class.new(expressions, {}).solve() { :foo })
+      expect(described_class.new(expressions, {}).solve { :foo })
         .to eq(more_apples: :foo)
     end
 
     it "allows passing in a custom value to an error handler when there is a div/0 error" do
       expressions = {more_apples: "1/0"}
-      expect(described_class.new(expressions, {}).solve() { :foo })
+      expect(described_class.new(expressions, {}).solve { :foo })
         .to eq(more_apples: :foo)
     end
   end

data/spec/calculator_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'dentaku/calculator'
 
 describe Dentaku::Calculator do
@@ -19,7 +20,7 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('(2 + 3) - 1')).to eq(4)
     expect(calculator.evaluate('(-2 + 3) - 1')).to eq(0)
     expect(calculator.evaluate('(-2 - 3) - 1')).to eq(-6)
-    expect(calculator.evaluate('1 + -2 ^ 2')).to eq(-3)
+    expect(calculator.evaluate('1 + -(2 ^ 2)')).to eq(-3)
     expect(calculator.evaluate('3 + -num', num: 2)).to eq(1)
     expect(calculator.evaluate('-num + 3', num: 2)).to eq(1)
     expect(calculator.evaluate('10 ^ 2')).to eq(100)
@@ -198,4 +199,16 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate('NOT(some_boolean) AND -1 > 3', some_boolean: true)).to be_falsey
     end
   end
+
+  describe 'math functions' do
+    Math.methods(false).each do |method|
+      it method do
+        if Math.method(method).arity == 2
+          expect(calculator.evaluate("#{method}(1,2)")).to eq Math.send(method, 1, 2)
+        else
+          expect(calculator.evaluate("#{method}(1)")).to eq Math.send(method, 1)
+        end
+      end
+    end
+  end
 end

data/spec/external_function_spec.rb

@@ -8,28 +8,12 @@ describe Dentaku::Calculator do
       let(:with_external_funcs) do
         c = described_class.new
 
-        now = { name: :now, type: :string, signature: [], body: -> { Time.now.to_s } }
-        c.add_function(now)
+        c.add_function(:now, -> { Time.now.to_s })
 
         fns = [
-          {
-            name:      :exp,
-            type:      :numeric,
-            signature: [ :numeric, :numeric ],
-            body:      ->(mantissa, exponent) { mantissa ** exponent }
-          },
-          {
-            name:      :max,
-            type:      :numeric,
-            signature: [ :arguments ],
-            body:      ->(*args) { args.max }
-          },
-          {
-            name:      :min,
-            type:      :numeric,
-            signature: [ :arguments ],
-            body:      ->(*args) { args.min }
-          }
+          [:pow,      ->(mantissa, exponent) { mantissa ** exponent }],
+          [:biggest,  ->(*args) { args.max }],
+          [:smallest, ->(*args) { args.min }],
         ]
 
         c.add_functions(fns)
@@ -41,18 +25,18 @@ describe Dentaku::Calculator do
         expect(now).not_to be_empty
       end
 
-      it 'includes EXP' do
-        expect(with_external_funcs.evaluate('EXP(2,3)')).to eq(8)
-        expect(with_external_funcs.evaluate('EXP(3,2)')).to eq(9)
-        expect(with_external_funcs.evaluate('EXP(mantissa,exponent)', mantissa: 2, exponent: 4)).to eq(16)
+      it 'includes POW' do
+        expect(with_external_funcs.evaluate('POW(2,3)')).to eq(8)
+        expect(with_external_funcs.evaluate('POW(3,2)')).to eq(9)
+        expect(with_external_funcs.evaluate('POW(mantissa,exponent)', mantissa: 2, exponent: 4)).to eq(16)
       end
 
-      it 'includes MAX' do
-        expect(with_external_funcs.evaluate('MAX(8,6,7,5,3,0,9)')).to eq(9)
+      it 'includes BIGGEST' do
+        expect(with_external_funcs.evaluate('BIGGEST(8,6,7,5,3,0,9)')).to eq(9)
       end
 
-      it 'includes MIN' do
-        expect(with_external_funcs.evaluate('MIN(8,6,7,5,3,0,9)')).to eq(0)
+      it 'includes SMALLEST' do
+        expect(with_external_funcs.evaluate('SMALLEST(8,6,7,5,3,0,9)')).to eq(0)
       end
     end
   end

data/spec/parser_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'dentaku/parser'
+
+describe Dentaku::Parser do
+  it 'is constructed from a token' do
+    token = Dentaku::Token.new(:numeric, 5)
+    node  = described_class.new([token]).parse
+    expect(node.value).to eq 5
+  end
+
+  it 'performs simple addition' do
+    five = Dentaku::Token.new(:numeric, 5)
+    plus = Dentaku::Token.new(:operator, :add)
+    four = Dentaku::Token.new(:numeric, 4)
+
+    node  = described_class.new([five, plus, four]).parse
+    expect(node.value).to eq 9
+  end
+
+  it 'compares two numbers' do
+    five = Dentaku::Token.new(:numeric, 5)
+    lt   = Dentaku::Token.new(:comparator, :lt)
+    four = Dentaku::Token.new(:numeric, 4)
+
+    node  = described_class.new([five, lt, four]).parse
+    expect(node.value).to eq false
+  end
+
+  it 'performs multiple operations in one stream' do
+    five  = Dentaku::Token.new(:numeric, 5)
+    plus  = Dentaku::Token.new(:operator, :add)
+    four  = Dentaku::Token.new(:numeric, 4)
+    times = Dentaku::Token.new(:operator, :multiply)
+    three = Dentaku::Token.new(:numeric, 3)
+
+    node  = described_class.new([five, plus, four, times, three]).parse
+    expect(node.value).to eq 17
+  end
+
+  it 'respects order of operations' do
+    five  = Dentaku::Token.new(:numeric, 5)
+    times = Dentaku::Token.new(:operator, :multiply)
+    four  = Dentaku::Token.new(:numeric, 4)
+    plus  = Dentaku::Token.new(:operator, :add)
+    three = Dentaku::Token.new(:numeric, 3)
+
+    node  = described_class.new([five, times, four, plus, three]).parse
+    expect(node.value).to eq 23
+  end
+
+  it 'respects grouping by parenthesis' do
+    lpar  = Dentaku::Token.new(:grouping, :open)
+    five  = Dentaku::Token.new(:numeric, 5)
+    plus  = Dentaku::Token.new(:operator, :add)
+    four  = Dentaku::Token.new(:numeric, 4)
+    rpar  = Dentaku::Token.new(:grouping, :close)
+    times = Dentaku::Token.new(:operator, :multiply)
+    three = Dentaku::Token.new(:numeric, 3)
+
+    node  = described_class.new([lpar, five, plus, four, rpar, times, three]).parse
+    expect(node.value).to eq 27
+  end
+
+  it 'evaluates functions' do
+    fn    = Dentaku::Token.new(:function, :if)
+    fopen = Dentaku::Token.new(:grouping, :fopen)
+    five  = Dentaku::Token.new(:numeric, 5)
+    lt    = Dentaku::Token.new(:comparator, :lt)
+    four  = Dentaku::Token.new(:numeric, 4)
+    comma = Dentaku::Token.new(:grouping, :comma)
+    three = Dentaku::Token.new(:numeric, 3)
+    two   = Dentaku::Token.new(:numeric, 2)
+    rpar  = Dentaku::Token.new(:grouping, :close)
+
+    node  = described_class.new([fn, fopen, five, lt, four, comma, three, comma, two, rpar]).parse
+    expect(node.value).to eq 2
+  end
+
+  it 'represents formulas with variables' do
+    five  = Dentaku::Token.new(:numeric, 5)
+    times = Dentaku::Token.new(:operator, :multiply)
+    x     = Dentaku::Token.new(:identifier, :x)
+
+    node  = described_class.new([five, times, x]).parse
+    expect { node.value }.to raise_error
+    expect(node.value(x: 3)).to eq 15
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+require 'pry'
+
 # automatically create a token stream from bare values
 def token_stream(*args)
   args.map do |value|
@@ -29,4 +31,3 @@ def type_for(value)
     :identifier
   end
 end
-

data/spec/token_scanner_spec.rb

@@ -2,7 +2,9 @@ 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 }) }
+  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(' ').first
@@ -21,7 +23,6 @@ describe Dentaku::TokenScanner do
   end
 
   it 'returns a list of all configured scanners' do
-    expect(described_class.scanners.length).to eq 10
+    expect(described_class.scanners.length).to eq 11
   end
 end
-