dentaku 3.5.0 → 3.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a0b093e29b178197c0f92c1f63ec56342716c1fa84a4d12a73a7d355d42bc76
-  data.tar.gz: 480ccf9248568006227518363a0ef6350843007389f2e94ac5610ae62028e87e
+  metadata.gz: d5592654ee45adeb24167b584374fb2d69bc67d1db4d5f4ac99050130f187f8f
+  data.tar.gz: 31d3952b08887ae934661f4c0ecc5c298b2f36f0f8365cc1503495eb044eb558
 SHA512:
-  metadata.gz: 904292b2d2fd834701fd18900d689b9125579d58421fc58aaad03cd75c0fb556eeaeb5635dcd034a3f29e9f70f5c8fe0370e605acefd599c3dd75eae64436fdd
-  data.tar.gz: 3b6ed8763b9241e55e85f1a1e5a09d2652ec91eee21c080ca825029e04867b8fe65b128ddfc557cab3ef4fae76abb30b936f5971326355ea763081f90ba66638
+  metadata.gz: d8e0d003f897e06173c91b200e62d9fed12ec3bacfe0f2ecc3f3705a1cbf914d1705948b79962f5ac6a5397138ff89c2123aa5c3753963f0046a88280b29825b
+  data.tar.gz: 5f48d3b8fef4e56ed308e717da88937bef508e47dfca4c3e16610aff7523f11405e53e2b55d00c53b5eca8efbe7be64df0d0d12e7ddafbc61099cde08bf92a53

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## [v3.5.1]
+- add bitwise shift left and shift right operators
+- improve numeric conversions
+- improve parse exceptions
+- improve bitwise exceptions
+- include variable name in bulk expression exceptions
+
 ## [v3.5.0]
 - fix bug with function argument count
 - add XOR operator
@@ -224,6 +231,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[Unreleased]: https://github.com/rubysolo/dentaku/compare/v3.5.1...HEAD
+[v3.5.1]: https://github.com/rubysolo/dentaku/compare/v3.5.0...v3.5.1
 [v3.5.0]:  https://github.com/rubysolo/dentaku/compare/v3.4.2...v3.5.0
 [v3.4.2]:  https://github.com/rubysolo/dentaku/compare/v3.4.1...v3.4.2
 [v3.4.1]:  https://github.com/rubysolo/dentaku/compare/v3.4.0...v3.4.1

data/README.md

@@ -137,7 +137,7 @@ application, AST caching will consume more memory with each new formula.
 BUILT-IN OPERATORS AND FUNCTIONS
 ---------------------------------
 
-Math: `+`, `-`, `*`, `/`, `%`, `^`, `|`, `&`
+Math: `+`, `-`, `*`, `/`, `%`, `^`, `|`, `&`, `<<`, `>>`
 
 Also, all functions from Ruby's Math module, including `SIN`, `COS`, `TAN`, etc.
 

data/lib/dentaku/ast/arithmetic.rb

@@ -31,29 +31,30 @@ module Dentaku
       def value(context = {})
         l = cast(left.value(context))
         r = cast(right.value(context))
-        begin
-          l.public_send(operator, r)
-        rescue ::TypeError => e
-          # Right cannot be converted to a suitable type for left. e.g. [] + 1
-          raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
-        end
+
+        l.public_send(operator, r)
+      rescue ::TypeError => e
+        # Right cannot be converted to a suitable type for left. e.g. [] + 1
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
       end
 
       private
 
-      def cast(val, prefer_integer = true)
+      def cast(val)
         validate_value(val)
-        numeric(val, prefer_integer)
+        numeric(val)
+      end
+
+      def numeric(val)
+        case val.to_s
+        when /\A\d*\.\d+\z/ then decimal(val)
+        when /\A-?\d+\z/ then val.to_i
+        else val
+        end
       end
 
-      def numeric(val, prefer_integer)
-        v = BigDecimal(val, Float::DIG + 1)
-        v = v.to_i if prefer_integer && v.frac.zero?
-        v
-      rescue ::TypeError
-        # If we got a TypeError BigDecimal or to_i failed;
-        # let value through so ruby things like Time - integer work
-        val
+      def decimal(val)
+        BigDecimal(val.to_s, Float::DIG + 1)
       end
 
       def valid_node?(node)
@@ -143,7 +144,7 @@ module Dentaku
       end
 
       def value(context = {})
-        r = cast(right.value(context), false)
+        r = decimal(cast(right.value(context)))
         raise Dentaku::ZeroDivisionError if r.zero?
 
         cast(cast(left.value(context)) / r)

data/lib/dentaku/ast/bitwise.rb

@@ -2,23 +2,40 @@ require_relative './operation'
 
 module Dentaku
   module AST
-    class BitwiseOr < Operation
+    class Bitwise < Operation
       def value(context = {})
-        left.value(context) | right.value(context)
+        left_value = left.value(context)
+        right_value = right.value(context)
+
+        left_value.public_send(operator, right_value)
+      rescue NoMethodError => e
+        raise Dentaku::ArgumentError.for(:invalid_operator, value: left_value, for: left_value.class)
+      rescue TypeError => e
+        raise Dentaku::ArgumentError.for(:invalid_operator, value: right_value, for: right_value.class)
       end
+    end
 
+    class BitwiseOr < Bitwise
       def operator
         :|
       end
     end
 
-    class BitwiseAnd < Operation
-      def value(context = {})
-        left.value(context) & right.value(context)
+    class BitwiseAnd < Bitwise
+      def operator
+        :&
       end
+    end
 
+    class BitwiseShiftLeft < Bitwise
       def operator
-        :&
+        :<<
+      end
+    end
+
+    class BitwiseShiftRight < Bitwise
+      def operator
+        :>>
       end
     end
   end

data/lib/dentaku/ast/comparators.rb

@@ -16,8 +16,8 @@ module Dentaku
       end
 
       def value(context = {})
-        l = validate_value(left.value(context))
-        r = validate_value(right.value(context))
+        l = validate_value(cast(left.value(context)))
+        r = validate_value(cast(right.value(context)))
 
         l.public_send(operator, r)
       rescue ::ArgumentError => e
@@ -26,6 +26,16 @@ module Dentaku
 
       private
 
+      def cast(val)
+        return val unless val.is_a?(::String)
+        return val if val.empty?
+        return val unless val.match?(/\A-?\d*(\.\d+)?\z/)
+
+        v = BigDecimal(val, Float::DIG + 1)
+        v = v.to_i if v.frac.zero?
+        v
+      end
+
       def validate_value(value)
         unless value.respond_to?(operator)
           raise Dentaku::ArgumentError.for(:invalid_operator, operation: self.class, operator: operator),

data/lib/dentaku/bulk_expression_solver.rb

@@ -89,13 +89,9 @@ module Dentaku
     def with_rescues(var_name, results, block)
       yield
 
-    rescue UnboundVariableError,  Dentaku::ZeroDivisionError => ex
+    rescue Dentaku::UnboundVariableError, Dentaku::ZeroDivisionError, Dentaku::ArgumentError => ex
       ex.recipient_variable = var_name
       results[var_name] = block.call(ex)
-
-    rescue Dentaku::ArgumentError => ex
-      results[var_name] = block.call(ex)
-
     ensure
       if results[var_name] == :undefined && calculator.memory.has_key?(var_name.downcase)
         results[var_name] = calculator.memory[var_name.downcase]

data/lib/dentaku/exceptions.rb

@@ -1,10 +1,9 @@
 module Dentaku
   class Error < StandardError
+    attr_accessor :recipient_variable
   end
 
   class UnboundVariableError < Error
-    attr_accessor :recipient_variable
-
     attr_reader :unbound_variables
 
     def initialize(unbound_variables)
@@ -74,6 +73,7 @@ module Dentaku
 
   class ArgumentError < ::ArgumentError
     attr_reader :reason, :meta
+    attr_accessor :recipient_variable
 
     def initialize(reason, **meta)
       @reason = reason

data/lib/dentaku/parser.rb

@@ -10,8 +10,11 @@ module Dentaku
       pow:      AST::Exponentiation,
       negate:   AST::Negation,
       mod:      AST::Modulo,
+
       bitor:    AST::BitwiseOr,
       bitand:   AST::BitwiseAnd,
+      bitshiftleft:  AST::BitwiseShiftLeft,
+      bitshiftright: AST::BitwiseShiftRight,
 
       lt:       AST::LessThan,
       gt:       AST::GreaterThan,
@@ -38,6 +41,8 @@ module Dentaku
 
     def consume(count = 2)
       operator = operations.pop
+      fail! :invalid_statement if operator.nil?
+
       operator.peek(output)
 
       args_size = operator.arity || count

data/lib/dentaku/token_scanner.rb

@@ -120,9 +120,9 @@ module Dentaku
 
       def operator
         names = {
-          pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&'
+          pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&', bitshiftleft: '<<', bitshiftright: '>>'
         }.invert
-        new(:operator, '\^|\+|-|\*|\/|%|\||&', lambda { |raw| names[raw] })
+        new(:operator, '\^|\+|-|\*|\/|%|\||&|<<|>>', lambda { |raw| names[raw] })
       end
 
       def grouping

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.0"
+  VERSION = "3.5.1"
 end

data/spec/ast/arithmetic_spec.rb

@@ -45,6 +45,13 @@ describe Dentaku::AST::Arithmetic do
     expect(add(x, one, 'x' => '.1')).to eq(1.1)
     expect { add(x, one, 'x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
     expect { add(x, one, 'x' => '') }.to raise_error(Dentaku::ArgumentError)
+
+    int_one = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, "1")
+    decimal_one = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, "1.0")
+
+    expect(add(int_one, int_one).class).to eq(Integer)
+    expect(add(int_one, decimal_one).class).to eq(BigDecimal)
+    expect(add(decimal_one, decimal_one).class).to eq(BigDecimal)
   end
 
   it 'performs arithmetic on arrays' do

data/spec/ast/comparator_spec.rb

@@ -5,7 +5,9 @@ require 'dentaku/token'
 
 describe Dentaku::AST::Comparator do
   let(:one) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 1) }
+  let(:one_str) { Dentaku::AST::String.new Dentaku::Token.new(:string, '1') }
   let(:two) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 2) }
+  let(:two_str) { Dentaku::AST::String.new Dentaku::Token.new(:string, '2') }
   let(:x) { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
   let(:y) { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'y') }
   let(:nilly) do
@@ -21,6 +23,12 @@ describe Dentaku::AST::Comparator do
     expect(equal(x, y).value(ctx)).to be_falsey
   end
 
+  it 'performs conversion from string to numeric operands' do
+    expect(less_than(one, two_str).value(ctx)).to be_truthy
+    expect(less_than(one_str, two_str).value(ctx)).to be_truthy
+    expect(less_than(one_str, two).value(ctx)).to be_truthy
+  end
+
   it 'raises a dentaku argument error when incorrect arguments are passed in' do
     expect { less_than(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
     expect { less_than_or_equal(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError

data/spec/ast/or_spec.rb

@@ -6,7 +6,7 @@ describe 'Dentaku::AST::Or' do
   let(:calculator) { Dentaku::Calculator.new }
 
   it 'returns false if all of the arguments are false' do
-    result = Dentaku('OR(1 = "1", 0 = 1)')
+    result = Dentaku('OR(1 = "2", 0 = 1)')
     expect(result).to eq(false)
   end
 

data/spec/bulk_expression_solver_spec.rb

@@ -143,6 +143,15 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       expect(exception.recipient_variable).to eq('more_apples')
     end
 
+    it 'stores the recipient variable on the exception when there is an ArgumentError' do
+      expressions = {apples: "NULL", more_apples: "1 + apples"}
+      exception = nil
+      described_class.new(expressions, calculator).solve do |ex|
+        exception = ex
+      end
+      expect(exception.recipient_variable).to eq('more_apples')
+    end
+
     it 'safely handles argument errors' do
       expressions = {i: "a / 5 + d", a: "m * 12", d: "a + b"}
       result = described_class.new(expressions, calculator.store(m: 3)).solve

data/spec/calculator_spec.rb

@@ -40,6 +40,8 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate("2 | 3 * 9")).to eq (27)
     expect(calculator.evaluate("2 & 3 * 9")).to eq (2)
     expect(calculator.evaluate("5%")).to eq (0.05)
+    expect(calculator.evaluate('1 << 3')).to eq (8)
+    expect(calculator.evaluate('0xFF >> 6')).to eq (3)
   end
 
   describe 'evaluate' do
@@ -67,6 +69,7 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate('ROUNDDOWN(a)', a: nil)).to be_nil
       expect(calculator.evaluate('ROUNDUP(a)', a: nil)).to be_nil
       expect(calculator.evaluate('SUM(a,b)', a: nil, b: nil)).to be_nil
+      expect(calculator.evaluate('1.0 & "bar"')).to be_nil
     end
 
     it 'treats explicit nil as logical false' do
@@ -82,6 +85,13 @@ describe Dentaku::Calculator do
     end
   end
 
+  describe 'ast' do
+    it 'raises parsing errors' do
+      expect { calculator.ast('()') }.to raise_error(Dentaku::ParseError)
+      expect { calculator.ast('(}') }.to raise_error(Dentaku::TokenizerError)
+    end
+  end
+
   describe 'evaluate!' do
     it 'raises exception when formula has error' do
       expect { calculator.evaluate!('1 + + 1') }.to raise_error(Dentaku::ParseError)
@@ -108,6 +118,9 @@ describe Dentaku::Calculator do
       expect { calculator.evaluate!('ROUNDDOWN(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
       expect { calculator.evaluate!('ROUNDUP(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
       expect { calculator.evaluate!('SUM(a,b)', a: nil, b: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('"foo" & "bar"') }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('1.0 & "bar"') }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('1 & "bar"') }.to raise_error(Dentaku::ArgumentError)
     end
 
     it 'raises argument error if a function is called with incorrect arity' do

data/spec/tokenizer_spec.rb

@@ -89,6 +89,18 @@ describe Dentaku::Tokenizer do
     expect(tokens.map(&:value)).to eq([2, :bitand, 3])
   end
 
+  it 'tokenizes bitwise SHIFT LEFT' do
+    tokens = tokenizer.tokenize('2 << 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitshiftleft, 3])
+  end
+
+  it 'tokenizes bitwise SHIFT RIGHT' do
+    tokens = tokenizer.tokenize('2 >> 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitshiftright, 3])
+  end
+
   it 'ignores whitespace' do
     tokens = tokenizer.tokenize('1     / 1     ')
     expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])

data/spec/visitor_spec.rb

@@ -90,6 +90,7 @@ describe TestVisitor do
   def generic_subclasses
     [
       :Arithmetic,
+      :Bitwise,
       :Combinator,
       :Comparator,
       :Function,
@@ -111,7 +112,7 @@ describe TestVisitor do
     visit_nodes('1 < 2 and 3 <= 4 or 5 > 6 AND 7 >= 8 OR 9 != 10 and true')
     visit_nodes('IF(a[0] = NULL, "five", \'seven\')')
     visit_nodes('case (a % 5) when 0 then a else b end')
-    visit_nodes('0xCAFE & 0xDECAF | 0xBEEF')
+    visit_nodes('0xCAFE & (0xDECAF << 3) | (0xBEEF >> 5)')
     visit_nodes('2017-12-24 23:59:59')
     visit_nodes('ALL({1, 2, 3}, "val", val % 2 == 0)')
     visit_nodes('ANY(vals, val, val > 1)')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.5.1
 platform: ruby
 authors:
 - Solomon White
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-17 00:00:00.000000000 Z
+date: 2022-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -283,7 +283,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.9
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A formula language parser and evaluator