dentaku 1.2.6 → 2.0.0

data/spec/binary_operation_spec.rb

@@ -1,45 +0,0 @@
-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
-    expect(operation.pow).to eq [:numeric, 8]
-  end
-
-  it 'adds two numbers' do
-    expect(operation.add).to eq [:numeric, 5]
-  end
-
-  it 'subtracts two numbers' do
-    expect(operation.subtract).to eq [:numeric, -1]
-  end
-
-  it 'multiplies two numbers' do
-    expect(operation.multiply).to eq [:numeric, 6]
-  end
-
-  it 'divides two numbers' do
-    expect(operation.divide).to eq [:numeric, (BigDecimal.new('2.0')/BigDecimal.new('3.0'))]
-  end
-
-  it 'compares two numbers' do
-    expect(operation.le).to eq [:logical, true]
-    expect(operation.lt).to eq [:logical, true]
-    expect(operation.ne).to eq [:logical, true]
-
-    expect(operation.ge).to eq [:logical, false]
-    expect(operation.gt).to eq [:logical, false]
-    expect(operation.eq).to eq [:logical, false]
-  end
-
-  it 'performs logical AND and OR' do
-    expect(logical.and).to eq [:logical, false]
-    expect(logical.or).to  eq [:logical, true]
-  end
-
-  it 'mods two numbers' do
-    expect(operation.mod).to eq [:numeric, 2%3]
-  end
-end

data/spec/evaluator_spec.rb

@@ -1,145 +0,0 @@
-require 'spec_helper'
-require 'dentaku/evaluator'
-
-describe Dentaku::Evaluator do
-  let(:rule_set)  { Dentaku::RuleSet.new }
-  let(:evaluator) { Dentaku::Evaluator.new(rule_set) }
-
-  describe 'rule scanning' do
-    it 'finds a matching rule' do
-      rule   = [Dentaku::TokenMatcher.new(:numeric, nil)]
-      stream = [Dentaku::Token.new(:numeric, 1), Dentaku::Token.new(:operator, :add), Dentaku::Token.new(:numeric, 1)]
-      position, _match = evaluator.find_rule_match(rule, stream)
-      expect(position).to eq(0)
-    end
-  end
-
-  describe 'evaluating' do
-    it 'empty expression is be truthy' do
-      expect(evaluator.evaluate([])).to be
-    end
-
-    it 'empty expression equals 0' do
-      expect(evaluator.evaluate([])).to eq(0)
-    end
-
-    it 'single numeric evaluates to its value' do
-      expect(evaluator.evaluate([Dentaku::Token.new(:numeric, 10)])).to eq(10)
-      expect(evaluator.evaluate([Dentaku::Token.new(:string,  'a')])).to eq('a')
-    end
-
-    it 'evaluates one apply step' do
-      stream   = token_stream(1, :add, 1, :add, 1)
-      expected = token_stream(2, :add, 1)
-
-      expect(evaluator.evaluate_step(stream, 0, 3, :apply)).to eq(expected)
-    end
-
-    it 'evaluates one grouping step' do
-      stream   = token_stream(:open, 1, :add, 1, :close, :multiply, 5)
-      expected = token_stream(2, :multiply, 5)
-
-      expect(evaluator.evaluate_step(stream, 0, 5, :evaluate_group)).to eq(expected)
-    end
-
-    it 'supports unary minus' do
-      expect(evaluator.evaluate(token_stream(:subtract, 1))).to eq(-1)
-      expect(evaluator.evaluate(token_stream(1, :subtract, :subtract, 1))).to eq(2)
-      expect(evaluator.evaluate(token_stream(1, :subtract, :subtract, :subtract, 1))).to eq(0)
-      expect(evaluator.evaluate(token_stream(:subtract, 1, :add, 1))).to eq(0)
-      expect(evaluator.evaluate(token_stream(3, :add, 0, :multiply, :subtract, 3))).to eq(3)
-    end
-
-    it 'evaluates a number multiplied by an exponent' do
-      expect(evaluator.evaluate(token_stream(10, :pow, 2))).to eq(100)
-      expect(evaluator.evaluate(token_stream(0, :multiply, 10, :pow, 5))).to eq(0)
-      expect(evaluator.evaluate(token_stream(0, :multiply, 10, :pow, :subtract, 5))).to eq(0)
-    end
-
-    it 'supports unary percentage' do
-      expect(evaluator.evaluate(token_stream(50, :mod))).to eq(0.5)
-      expect(evaluator.evaluate(token_stream(50, :mod, :multiply, 100))).to eq(50)
-    end
-
-    describe 'maths' do
-      it 'performs addition' do
-        expect(evaluator.evaluate(token_stream(1, :add, 1))).to eq(2)
-      end
-
-      it 'respects order of precedence' do
-        expect(evaluator.evaluate(token_stream(1, :add, 1, :multiply, 5))).to eq(6)
-        expect(evaluator.evaluate(token_stream(2, :add, 10, :mod, 2))).to eq(2)
-      end
-
-      it 'respects explicit grouping' do
-        expect(evaluator.evaluate(token_stream(:open, 1, :add, 1, :close, :multiply, 5))).to eq(10)
-      end
-
-      it 'returns floating point from division when there is a remainder' do
-        expect(evaluator.evaluate(token_stream(5, :divide, 4))).to eq(1.25)
-      end
-    end
-
-    describe 'find_rule_match' do
-      it 'matches a function call' do
-        if_pattern, _ = *rule_set.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
-
-      describe 'with start-anchored token' do
-        let(:number) { [Dentaku::TokenMatcher.new(:numeric).caret] }
-        let(:string) { [Dentaku::TokenMatcher.new(:string).caret] }
-        let(:stream) { token_stream(1, 'foo') }
-
-        it 'matches anchored to the beginning of the token stream' do
-          position, tokens = evaluator.find_rule_match(number, stream)
-          expect(position).to eq 0
-          expect(tokens.length).to eq 1
-        end
-
-        it 'does not match later in the stream' do
-          position, _tokens = evaluator.find_rule_match(string, stream)
-          expect(position).to be_nil
-        end
-      end
-    end
-
-    describe 'functions' do
-      it 'is evaluated' do
-        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
-
-    describe 'logic' do
-      it 'evaluates conditional' do
-        expect(evaluator.evaluate(token_stream(5, :gt, 1))).to be_truthy
-      end
-
-      it 'expands inequality ranges' do
-        stream   = token_stream(5, :lt, 10, :le, 10)
-        expected = token_stream(5, :lt, 10, :and, 10, :le, 10)
-        expect(evaluator.evaluate_step(stream, 0, 5, :expand_range)).to eq(expected)
-
-        expect(evaluator.evaluate(token_stream(5, :lt, 10, :le, 10))).to be_truthy
-        expect(evaluator.evaluate(token_stream(3, :gt,  5, :ge,  1))).to be_falsey
-
-        expect { evaluator.evaluate(token_stream(3, :gt,  2, :lt,   1)) }.to raise_error
-      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
-      end
-
-      it 'negates a logical value' do
-        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
-end

data/spec/expression_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'dentaku/expression'
-
-describe Dentaku::Expression do
-  describe 'an all literal expression' do
-    it 'is fully bound' do
-      static = described_class.new('1 + 1')
-      expect(static).not_to be_unbound
-    end
-  end
-
-  describe 'an expression with variable identifiers' do
-    it 'is unbound' do
-      dynamic = described_class.new('a > 5')
-      expect(dynamic).to be_unbound
-    end
-
-    describe 'with values set for all variables' do
-      it 'is fully bound' do
-        dynamic = described_class.new('a > 5', {a: 7})
-        expect(dynamic).not_to be_unbound
-      end
-    end
-  end
-end

data/spec/rule_set_spec.rb

@@ -1,43 +0,0 @@
-require 'dentaku/rule_set'
-
-describe Dentaku::RuleSet do
-  subject { described_class.new }
-
-  it 'yields core rules' do
-    functions = []
-    subject.each { |pattern, function| functions << function }
-    expect(functions).to eq [:if,
-                             :round,
-                             :round_int,
-                             :round_int,
-                             :not,
-                             :evaluate_group,
-                             :negate,
-                             :apply,
-                             :pow_negate,
-                             :apply,
-                             :apply,
-                             :mul_negate,
-                             :apply,
-                             :percentage,
-                             :negate,
-                             :expand_range,
-                             :expand_range,
-                             :apply,
-                             :apply,
-                             :apply,
-                            ]
-  end
-
-  it 'adds custom function patterns' do
-    functions = []
-    subject.add_function(
-      name:      :min,
-      type:      :numeric,
-      signature: [ :arguments ],
-      body:      ->(*args) { args.min }
-    )
-    subject.each { |pattern, function| functions << function }
-    expect(functions).to include('min')
-  end
-end