dentaku 2.0.11 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0febf923ab551e0cfce23bc38794927a3acedbe2
-  data.tar.gz: 3b4db1f045f21acd1e6a7c864ed9a4c272a2f765
+  metadata.gz: 99f7f7efeefb4c1096618e028100c52bb15ca134
+  data.tar.gz: 1afd93ef547f630fb0ea121a6e8c813ea8abeeac
 SHA512:
-  metadata.gz: dad6f87cf37ba49f355b0e30b92a80dfc063eeb9444653ea09832066831dc09c19e022883b2c31c23189a1c46c842ce652fba133725fa4f887db1fb5a9becf2a
-  data.tar.gz: 5b01fa83b5ddd2f3123946196ff6f0be42f1bd196b38195249d24ee2c6e08c1ad077ffd0da2f2cf33dd9c664e447ffe6864ab0f021a79e30e51769189225ef53
+  metadata.gz: 31227f42fb7f0a262e82b2ccdc334adc4458ba7339c87f0fbf81eb49ffb51bac72654e05de9495d8dad73c9669b8d82bf9bdf8c4f7ee1a5b5830aba123dc6f17
+  data.tar.gz: 2f78631eb082dc6c2d52ccac04d057c11c05b212ab05ffaa197e4f5ebf80aafc23113691d1dc0653c6af5df2827d6a4b45af58d4bfac73aa0156e3e91fbdb063

data/.gitignore

@@ -9,3 +9,6 @@ vendor/*
 /.ruby-gemset
 /.ruby-version
 /.rspec
+
+.byebug_history
+coverage

data/.travis.yml

@@ -1,7 +1,6 @@
 language: ruby
 sudo: false
 rvm:
-  - 1.9.3
   - 2.0.0
   - 2.1.0
   - 2.1.1

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Change Log
 
+## [v3.0.0] 2017-10-11
+- add && and || as aliases for AND and OR
+- add hexadecimal literal support
+- add the SWITCH function
+- add AND and OR functions
+- add array access
+- make UnboundVariableError show all missing values
+- cast inputs to numeric function to numeric
+- fix issue with zero-arity functions used as function args
+- fix division when context values contain one or more strings
+- drop Ruby 1.9 support
+
 ## [v2.0.11] 2017-05-08
 - fix dependency checking for logical AST nodes
 - make `CONCAT` variadic
@@ -8,6 +20,12 @@
 - add `&` (bitwise and) and `|` (bitwise or) operators
 - fix incompatibility with 'mathn' module
 - add `CONTAINS` string function
+- allow storage of nested hashes in calculator memory
+- allow duck type arithmetic
+- fix error handling code to work with Ruby 2.4.0
+- allow calculators to store own registry of functions
+- add timezone support to time literals
+- optimizations
 
 ## [v2.0.10] 2016-12-30
 - fix string function initialization bug
@@ -125,6 +143,7 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[v3.0.0]:  https://github.com/rubysolo/dentaku/compare/v2.0.11...v3.0.0
 [v2.0.11]:  https://github.com/rubysolo/dentaku/compare/v2.0.10...v2.0.11
 [v2.0.10]:  https://github.com/rubysolo/dentaku/compare/v2.0.9...v2.0.10
 [v2.0.9]:  https://github.com/rubysolo/dentaku/compare/v2.0.8...v2.0.9

data/README.md

@@ -6,6 +6,7 @@ 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)
+[![Coverage Status](https://coveralls.io/repos/github/rubysolo/dentaku/badge.svg)](https://coveralls.io/github/rubysolo/dentaku)
 
 DESCRIPTION
 -----------
@@ -129,9 +130,9 @@ Also, all functions from Ruby's Math module, including `SIN`, `COS`, `TAN`, etc.
 
 Comparison: `<`, `>`, `<=`, `>=`, `<>`, `!=`, `=`,
 
-Logic: `IF`, `AND`, `OR`, `NOT`
+Logic: `IF`, `AND`, `OR`, `NOT`, `SWITCH`
 
-Functions: `MIN`, `MAX`, `ROUND`, `ROUNDDOWN`, `ROUNDUP`
+Numeric: `MIN`, `MAX`, `ROUND`, `ROUNDDOWN`, `ROUNDUP`
 
 Selections: `CASE` (syntax see [spec](https://github.com/rubysolo/dentaku/blob/master/spec/calculator_spec.rb#L292))
 

data/dentaku.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rake')
   s.add_development_dependency('rspec')
   s.add_development_dependency('pry')
+  s.add_development_dependency('coveralls')
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/dentaku/ast.rb

@@ -10,15 +10,19 @@ require_relative './ast/bitwise'
 require_relative './ast/negation'
 require_relative './ast/comparators'
 require_relative './ast/combinators'
+require_relative './ast/access'
 require_relative './ast/grouping'
 require_relative './ast/case'
 require_relative './ast/function_registry'
+require_relative './ast/functions/and'
 require_relative './ast/functions/if'
 require_relative './ast/functions/max'
 require_relative './ast/functions/min'
 require_relative './ast/functions/not'
+require_relative './ast/functions/or'
 require_relative './ast/functions/round'
 require_relative './ast/functions/roundup'
 require_relative './ast/functions/rounddown'
 require_relative './ast/functions/ruby_math'
 require_relative './ast/functions/string_functions'
+require_relative './ast/functions/switch'

data/lib/dentaku/ast/access.rb

@@ -0,0 +1,27 @@
+module Dentaku
+  module AST
+    class Access
+      def self.arity
+        2
+      end
+
+      def self.peek(*)
+      end
+
+      def initialize(data_structure, index)
+        @structure = data_structure
+        @index = index
+      end
+
+      def value(context={})
+        structure = @structure.value(context)
+        index = @index.value(context)
+        structure[index]
+      end
+
+      def dependencies(context={})
+        @structure.dependencies(context) + @index.dependencies(context)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/arithmetic.rb

@@ -7,8 +7,14 @@ module Dentaku
     class Arithmetic < Operation
       def initialize(*)
         super
-        unless valid_left? && valid_right?
-          fail ParseError, "#{ self.class } requires numeric operands"
+
+        unless valid_left?
+          raise NodeError.new(:numeric, left.type, :left),
+                "#{self.class} requires numeric operands"
+        end
+        unless valid_right?
+          raise NodeError.new(:numeric, right.type, :right),
+                "#{self.class} requires numeric operands"
         end
       end
 
@@ -17,7 +23,7 @@ module Dentaku
       end
 
       def operator
-        raise "Not implemented"
+        raise NotImplementedError
       end
 
       def value(context={})
@@ -29,8 +35,7 @@ module Dentaku
       private
 
       def cast(val, prefer_integer=true)
-        validate_operation(val)
-        validate_format(val) if val.is_a?(::String)
+        validate_value(val)
         numeric(val, prefer_integer)
       end
 
@@ -56,15 +61,25 @@ module Dentaku
         valid_node?(right)
       end
 
+      def validate_value(val)
+        if val.is_a?(::String)
+          validate_format(val)
+        else
+          validate_operation(val)
+        end
+      end
+
       def validate_operation(val)
         unless val.respond_to?(operator)
-          fail Dentaku::ArgumentError, "#{ self.class } requires operands that respond to #{ operator }"
+          raise Dentaku::ArgumentError.for(:invalid_operator, operation: self.class, operator: operator),
+                "#{ self.class } requires operands that respond to #{operator}"
         end
       end
 
       def validate_format(string)
         unless string =~ /\A-?\d+(\.\d+)?\z/
-          fail Dentaku::ArgumentError, "String input '#{ string }' is not coercible to numeric"
+          raise Dentaku::ArgumentError.for(:invalid_value, value: string, for: BigDecimal),
+                "String input '#{string}' is not coercible to numeric"
         end
       end
     end
@@ -117,6 +132,33 @@ module Dentaku
     end
 
     class Modulo < Arithmetic
+      def self.arity
+        @arity
+      end
+
+      def self.peek(input)
+        @arity = 1
+        @arity = 2 if input.length > 1
+      end
+
+      def initialize(left, right=nil)
+        if right
+          @left  = left
+          @right = right
+        else
+          @right = left
+        end
+
+        unless valid_left?
+          raise NodeError.new(%i[numeric nil], left.type, :left),
+                "#{self.class} requires numeric operands or nil"
+        end
+        unless valid_right?
+          raise NodeError.new(:numeric, right.type, :right),
+                "#{self.class} requires numeric operands"
+        end
+      end
+
       def percent?
         left.nil?
       end

data/lib/dentaku/ast/case.rb

@@ -42,9 +42,23 @@ module Dentaku
 
       def dependencies(context={})
         # TODO: should short-circuit
-        @switch.dependencies(context) +
-          @conditions.flat_map { |condition| condition.dependencies(context) } +
-          @else.dependencies(context)
+        switch_dependencies(context) +
+        condition_dependencies(context) +
+        else_dependencies(context)
+      end
+
+      private
+
+      def switch_dependencies(context={})
+        @switch.dependencies(context)
+      end
+
+      def condition_dependencies(context={})
+        @conditions.flat_map { |condition| condition.dependencies(context) }
+      end
+
+      def else_dependencies(context={})
+        @else ? @else.dependencies(context) : []
       end
     end
   end

data/lib/dentaku/ast/combinators.rb

@@ -5,8 +5,14 @@ module Dentaku
     class Combinator < Operation
       def initialize(*)
         super
-        unless valid_node?(left) && valid_node?(right)
-          fail ParseError, "#{ self.class } requires logical operands"
+
+        unless valid_node?(left)
+          raise NodeError.new(:logical, left.type, :left),
+                "#{self.class} requires logical operands"
+        end
+        unless valid_node?(right)
+          raise NodeError.new(:logical, right.type, :right),
+                "#{self.class} requires logical operands"
         end
       end
 

data/lib/dentaku/ast/function.rb

@@ -4,6 +4,9 @@ require_relative 'function_registry'
 module Dentaku
   module AST
     class Function < Node
+      # @return [Integer] with the number of significant decimal digits to use.
+      DIG = Float::DIG + 1
+
       def initialize(*args)
         @args = args
       end
@@ -27,6 +30,19 @@ module Dentaku
       def self.registry
         @registry ||= FunctionRegistry.new
       end
+
+      # @return [Numeric] where possible it returns an Integer otherwise a BigDecimal.
+      # An Exception will be raised if a value is passed that cannot be cast to a Number.
+      def self.numeric(value)
+        return value if value.is_a?(::Numeric)
+
+        if value.is_a?(::String)
+          number = value[/\A-?\d*\.?\d+\z/]
+          return number.include?('.') ? ::BigDecimal.new(number, DIG) : number.to_i if number
+        end
+
+        raise TypeError, "#{value || value.class} could not be cast to a number."
+      end
     end
   end
 end

data/lib/dentaku/ast/function_registry.rb

@@ -5,11 +5,19 @@ module Dentaku
         name = function_name(name)
         return self[name] if has_key?(name)
         return default[name] if default.has_key?(name)
-        fail ParseError, "Undefined function #{ name }"
+        nil
       end
 
       def register(name, type, implementation)
         function = Class.new(Function) do
+          def self.name=(name)
+            @name = name
+          end
+
+          def self.name
+            @name
+          end
+
           def self.implementation=(impl)
             @implementation = impl
           end
@@ -26,6 +34,10 @@ module Dentaku
             @type
           end
 
+          def self.arity
+            @implementation.arity < 0 ? nil : @implementation.arity
+          end
+
           def value(context={})
             args = @args.map { |a| a.value(context) }
             self.class.implementation.call(*args)
@@ -36,8 +48,9 @@ module Dentaku
           end
         end
 
-        function.implementation = implementation
+        function.name = name
         function.type = type
+        function.implementation = implementation
 
         self[function_name(name)] = function
       end

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

@@ -0,0 +1,25 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+Dentaku::AST::Function.register(:and, :logical, lambda { |*args|
+  if args.empty?
+    raise Dentaku::ArgumentError.for(
+      :too_few_arguments,
+      function_name: 'AND()', at_least: 1, given: 0
+    ), 'AND() requires at least one argument'
+  end
+
+  args.all? do |arg|
+    case arg
+    when TrueClass, nil
+      true
+    when FalseClass
+      false
+    else
+      raise Dentaku::ArgumentError.for(
+        :incompatible_type,
+        function_name: 'AND()', expect: :logical, actual: arg.class
+      ), 'AND() requires arguments to be logical expressions'
+    end
+  end
+})

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

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

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

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

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

@@ -0,0 +1,25 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+Dentaku::AST::Function.register(:or, :logical, lambda { |*args|
+  if args.empty?
+    raise Dentaku::ArgumentError.for(
+      :too_few_arguments,
+      function_name: 'OR()', at_least: 1, given: 0
+    ), 'OR() requires at least one argument'
+  end
+
+  args.any? do |arg|
+    case arg
+    when TrueClass, nil
+      true
+    when FalseClass
+      false
+    else
+      raise Dentaku::ArgumentError.for(
+        :incompatible_type,
+        function_name: 'AND()', expect: :logical, actual: arg.class
+      ), 'AND() requires arguments to be logical expressions'
+    end
+  end
+})

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

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

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

@@ -1,7 +1,8 @@
 require_relative '../function'
 
-Dentaku::AST::Function.register(:rounddown, :numeric, ->(numeric, precision=0) {
+Dentaku::AST::Function.register(:rounddown, :numeric, lambda { |numeric, precision = 0|
+  precision = precision.to_i
   tens = 10.0**precision
-  result = (numeric * tens).floor / tens
+  result = (Dentaku::AST::Function.numeric(numeric) * tens).floor / tens
   precision <= 0 ? result.to_i : result
 })