dentaku 2.0.8 → 2.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5dd3288b6e13441c5e71ac914a527a9c4d97daa
-  data.tar.gz: 88c305d4010f094f2f59615fd830ea583274d9ca
+  metadata.gz: cc6a362189b735fe68596e1b94e28787d7290ac8
+  data.tar.gz: cec7635943905eaa4cb8cd888649f5c34a0c1871
 SHA512:
-  metadata.gz: 588690a66352277de04db87a048047c54d47bf8bd5ce92f3b1d841345a5cf721c903631a283d8912346ccead66242c13ae2f86e3ad186a1ab9b943e05988d095
-  data.tar.gz: 38b5f255f8e5bac861729589a71b7d7b6deec651bfc0fde17bfb07e96c2c710c758f58835dd9071bf695bb6dda45c532e6a25fc895e908ea10066a7450ac8123
+  metadata.gz: d82af702ad0a2b009680e7a3292388174915408f7d8e67c5b5cb0d545bd24544edd40a66a0611268bbb5614920c2de386784f8c7132c420802a1577d30b67a43
+  data.tar.gz: 417cd814e7f46973c312568e8dcd9dd4bbe9fe1dfa27abcb8ac178c58e78850c477d99f9a76abd285abd8141d1e647dceb52b40edcb54681743d9af95cde9684

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change Log
 
+## [v2.0.9] 2016-09-19
+- namespace tokenization errors
+- automatically coerce arguments to string functions as strings
+- selectively disable or clear AST cache
+
 ## [v2.0.8] 2016-05-10
 - numeric input validations
 - fail with gem-specific error for invalid arithmetic operands
@@ -106,6 +111,7 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[v2.0.9]:  https://github.com/rubysolo/dentaku/compare/v2.0.8...v2.0.9
 [v2.0.8]:  https://github.com/rubysolo/dentaku/compare/v2.0.7...v2.0.8
 [v2.0.7]:  https://github.com/rubysolo/dentaku/compare/v2.0.6...v2.0.7
 [v2.0.6]:  https://github.com/rubysolo/dentaku/compare/v2.0.5...v2.0.6

data/README.md

@@ -169,11 +169,11 @@ calc.dependencies("annual_income / 5")
 #=> [:annual_income]
 ```
 
-#### Calculator.solve!
+#### Calculator.solve! / Calculator.solve
 Have Dentaku figure out the order in which your formulas need to be evaluated.
 
 Pass in a hash of `{eventual_variable_name: "expression"}` to `solve!` and
-have Dentaku figure out dependencies (using `TSort`) for you.
+have Dentaku resolve dependencies (using `TSort`) for you.
 
 Raises `TSort::Cyclic` when a valid expression order cannot be found.
 
@@ -194,6 +194,11 @@ calc.solve!(
 #=> raises TSort::Cyclic
 ```
 
+`solve!` will also raise an exception if any of the formulas in the set cannot
+be evaluated (e.g. raise `ZeroDivisionError`).  The non-bang `solve` method will
+find as many solutions as possible and return the symbol `:undefined` for the
+problem formulas.
+
 INLINE COMMENTS
 ---------------------------------
 
@@ -272,7 +277,7 @@ LICENSE
 
 (The MIT License)
 
-Copyright © 2012 Solomon White
+Copyright © 2012-2016 Solomon White
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the ‘Software’), to deal in

data/lib/dentaku/ast/arithmetic.rb

@@ -86,6 +86,27 @@ module Dentaku
     end
 
     class Modulo < Arithmetic
+      def initialize(left, right)
+        @left  = left
+        @right = right
+
+        unless (valid_node?(left) || left.nil?) && valid_node?(right)
+          fail ParseError, "#{ self.class } requires numeric operands"
+        end
+      end
+
+      def percent?
+        left.nil?
+      end
+
+      def value(context={})
+        if percent?
+          cast(right.value(context)) * 0.01
+        else
+          super
+        end
+      end
+
       def operator
         :%
       end

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

@@ -10,7 +10,9 @@ module Dentaku
         end
 
         def value(context={})
-          @string.value(context)[0, @length.value(context)]
+          string = @string.value(context).to_s
+          length = @length.value(context)
+          string[0, length]
         end
       end
 
@@ -21,7 +23,7 @@ module Dentaku
         end
 
         def value(context={})
-          string = @string.value(context)
+          string = @string.value(context).to_s
           length = @length.value(context)
           string[length * -1, length] || string
         end
@@ -35,7 +37,7 @@ module Dentaku
         end
 
         def value(context={})
-          string = @string.value(context)
+          string = @string.value(context).to_s
           offset = @offset.value(context)
           length = @length.value(context)
           string[offset - 1, length].to_s
@@ -48,7 +50,8 @@ module Dentaku
         end
 
         def value(context={})
-          @string.value(context).length
+          string = @string.value(context).to_s
+          string.length
         end
       end
 
@@ -60,7 +63,8 @@ module Dentaku
 
         def value(context={})
           needle = @needle.value(context)
-          haystack = @haystack.value(context)
+          needle = needle.to_s unless needle.is_a?(Regexp)
+          haystack = @haystack.value(context).to_s
           pos = haystack.index(needle)
           pos && pos + 1
         end
@@ -74,9 +78,10 @@ module Dentaku
         end
 
         def value(context={})
-          original = @original.value(context)
+          original = @original.value(context).to_s
           search = @search.value(context)
-          replacement = @replacement.value(context)
+          search = search.to_s unless search.is_a?(Regexp)
+          replacement = @replacement.value(context).to_s
           original.sub(search, replacement)
         end
       end
@@ -88,7 +93,9 @@ module Dentaku
         end
 
         def value(context={})
-          @left.value(context) + @right.value(context)
+          left = @left.value(context).to_s
+          right = @right.value(context).to_s
+          left + right
         end
       end
     end

data/lib/dentaku/calculator.rb

@@ -1,4 +1,3 @@
-require 'dentaku'
 require 'dentaku/bulk_expression_solver'
 require 'dentaku/exceptions'
 require 'dentaku/token'
@@ -13,6 +12,7 @@ module Dentaku
       clear
       @tokenizer = Tokenizer.new
       @ast_cache = {}
+      @disable_ast_cache = false
     end
 
     def add_function(name, type, body)
@@ -25,6 +25,13 @@ module Dentaku
       self
     end
 
+    def disable_cache
+      @disable_ast_cache = true
+      yield(self) if block_given?
+    ensure
+      @disable_ast_cache = false
+    end
+
     def evaluate(expression, data={})
       evaluate!(expression, data)
     rescue UnboundVariableError, ArgumentError
@@ -54,11 +61,24 @@ module Dentaku
     def ast(expression)
       @ast_cache.fetch(expression) {
         Parser.new(tokenizer.tokenize(expression)).parse.tap do |node|
-          @ast_cache[expression] = node if Dentaku.cache_ast?
+          @ast_cache[expression] = node if cache_ast?
         end
       }
     end
 
+    def clear_cache(pattern=:all)
+      case pattern
+      when :all
+        @ast_cache = {}
+      when String
+        @ast_cache.delete(pattern)
+      when Regexp
+        @ast_cache.delete_if { |k,_| k =~ pattern }
+      else
+        fail Dentaku::ArgumentError
+      end
+    end
+
     def store(key_or_hash, value=nil)
       restore = Hash[memory]
 
@@ -96,5 +116,9 @@ module Dentaku
     def empty?
       memory.empty?
     end
+
+    def cache_ast?
+      Dentaku.cache_ast? && !@disable_ast_cache
+    end
   end
 end

data/lib/dentaku/exceptions.rb

@@ -13,6 +13,9 @@ module Dentaku
   class ParseError < StandardError
   end
 
+  class TokenizerError < StandardError
+  end
+
   class ArgumentError < ::ArgumentError
   end
 

data/lib/dentaku/tokenizer.rb

@@ -13,13 +13,13 @@ module Dentaku
       input    = strip_comments(string.to_s.dup)
 
       until input.empty?
-        raise "parse error at: '#{ input }'" unless TokenScanner.scanners.any? do |scanner|
+        fail TokenizerError, "parse error at: '#{ input }'" unless TokenScanner.scanners.any? do |scanner|
           scanned, input = scan(input, scanner)
           scanned
         end
       end
 
-      raise "too many opening parentheses" if @nesting > 0
+      fail TokenizerError, "too many opening parentheses" if @nesting > 0
 
       @tokens
     end
@@ -31,11 +31,11 @@ module Dentaku
     def scan(string, scanner)
       if tokens = scanner.scan(string, last_token)
         tokens.each do |token|
-          raise "unexpected zero-width match (:#{ token.category }) at '#{ string }'" if token.length == 0
+          fail TokenizerError, "unexpected zero-width match (:#{ token.category }) at '#{ string }'" if token.length == 0
 
           @nesting += 1 if LPAREN == token
           @nesting -= 1 if RPAREN == token
-          raise "too many closing parentheses" if @nesting < 0
+          fail TokenizerError, "too many closing parentheses" if @nesting < 0
 
           @tokens << token unless token.is?(:whitespace)
         end

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "2.0.8"
+  VERSION = "2.0.9"
 end

data/spec/calculator_spec.rb

@@ -142,6 +142,20 @@ describe Dentaku::Calculator do
         more_peaches: 2
       )
     end
+
+    it "solves remainder of expressions when one cannot be evaluated" do
+      result = calculator.solve(
+        conditional: "IF(d != 0, ratio, 0)",
+        ratio:       "10/d",
+        d:           0,
+      )
+
+      expect(result).to eq(
+        conditional: 0,
+        ratio:       :undefined,
+        d:           0,
+      )
+    end
   end
 
   it 'evaluates a statement with no variables' do
@@ -379,6 +393,53 @@ describe Dentaku::Calculator do
     end
   end
 
+  describe 'disable_cache' do
+    before do
+      allow(Dentaku).to receive(:cache_ast?) { true }
+    end
+
+    it 'disables the AST cache' do
+      expect(calculator.disable_cache{ |c| c.cache_ast? }).to be false
+    end
+
+    it 'calculates normally' do
+      expect(calculator.disable_cache{ |c| c.evaluate("2 + 2") }).to eq(4)
+    end
+  end
+
+  describe 'clear_cache' do
+    before do
+      allow(Dentaku).to receive(:cache_ast?) { true }
+
+      calculator.ast("1+1")
+      calculator.ast("pineapples * 5")
+      calculator.ast("pi * radius ^ 2")
+
+      def calculator.ast_cache
+        @ast_cache
+      end
+    end
+
+    it 'clears all items from cache' do
+      expect(calculator.ast_cache.length).to eq 3
+      calculator.clear_cache
+      expect(calculator.ast_cache.keys).to be_empty
+    end
+
+    it 'clears one item from cache' do
+      calculator.clear_cache("1+1")
+      expect(calculator.ast_cache.keys.sort).to eq([
+        'pi * radius ^ 2',
+        'pineapples * 5',
+      ])
+    end
+
+    it 'clears items matching regex from cache' do
+      calculator.clear_cache(/^pi/)
+      expect(calculator.ast_cache.keys.sort).to eq(['1+1'])
+    end
+  end
+
   describe 'string functions' do
     it 'concatenates two strings' do
       expect(

data/spec/parser_spec.rb

@@ -27,6 +27,14 @@ describe Dentaku::Parser do
     expect(node.value).to eq false
   end
 
+  it 'calculates unary percentage' do
+    five = Dentaku::Token.new(:numeric, 5)
+    mod  = Dentaku::Token.new(:operator, :mod)
+
+    node  = described_class.new([five, mod]).parse
+    expect(node.value).to eq 0.05
+  end
+
   it 'performs multiple operations in one stream' do
     five  = Dentaku::Token.new(:numeric, 5)
     plus  = Dentaku::Token.new(:operator, :add)

data/spec/tokenizer_spec.rb

@@ -142,8 +142,8 @@ describe Dentaku::Tokenizer do
   end
 
   it 'detects unbalanced parentheses' do
-    expect { tokenizer.tokenize('(5+3') }.to raise_error(RuntimeError, /too many opening parentheses/)
-    expect { tokenizer.tokenize(')')    }.to raise_error(RuntimeError, /too many closing parentheses/)
+    expect { tokenizer.tokenize('(5+3') }.to raise_error(Dentaku::TokenizerError, /too many opening parentheses/)
+    expect { tokenizer.tokenize(')')    }.to raise_error(Dentaku::TokenizerError, /too many closing parentheses/)
   end
 
   it 'recognizes identifiers that share initial substrings with combinators' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 2.0.8
+  version: 2.0.9
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-10 00:00:00.000000000 Z
+date: 2016-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake