dentaku 0.2.8 → 0.2.9

data/lib/dentaku/evaluator.rb

@@ -20,6 +20,8 @@ module Dentaku
     T_COMBINATOR = TokenMatcher.new(:combinator)
     T_IF         = TokenMatcher.new(:function, :if)
     T_ROUND      = TokenMatcher.new(:function, :round)
+    T_ROUNDUP    = TokenMatcher.new(:function, :roundup)
+    T_ROUNDDOWN  = TokenMatcher.new(:function, :rounddown)
     T_NOT        = TokenMatcher.new(:function, :not)
 
     T_NON_GROUP_STAR = TokenMatcher.new(:grouping).invert.star
@@ -38,12 +40,16 @@ module Dentaku
     P_IF         = [T_IF, T_OPEN, T_NON_GROUP, T_COMMA, T_NON_GROUP, T_COMMA, T_NON_GROUP, T_CLOSE]
     P_ROUND_ONE  = [T_ROUND, T_OPEN, T_NON_GROUP_STAR, T_CLOSE]
     P_ROUND_TWO  = [T_ROUND, T_OPEN, T_NON_GROUP_STAR, T_COMMA, T_NUMERIC, T_CLOSE]
+    P_ROUNDUP    = [T_ROUNDUP, T_OPEN, T_NON_GROUP_STAR, T_CLOSE]
+    P_ROUNDDOWN  = [T_ROUNDDOWN, T_OPEN, T_NON_GROUP_STAR, T_CLOSE]
     P_NOT        = [T_NOT, T_OPEN, T_NON_GROUP_STAR, T_CLOSE]
 
     RULES = [
       [P_IF,         :if],
       [P_ROUND_ONE,  :round],
       [P_ROUND_TWO,  :round],
+      [P_ROUNDUP,    :roundup],
+      [P_ROUNDDOWN,  :rounddown],
       [P_NOT,        :not],
 
       [P_GROUP,      :evaluate_group],
@@ -171,6 +177,20 @@ module Dentaku
       Token.new(:numeric, value)
     end
 
+    def roundup(*args)
+      _, _, *tokens, _ = args
+
+      value = evaluate_token_stream(tokens).value
+      Token.new(:numeric, value.ceil)
+    end
+
+    def rounddown(*args)
+      _, _, *tokens, _ = args
+
+      value = evaluate_token_stream(tokens).value
+      Token.new(:numeric, value.floor)
+    end
+
     def not(*args)
       Token.new(:logical, ! evaluate_token_stream(args[2..-2]).value)
     end

data/lib/dentaku/tokenizer.rb

@@ -36,9 +36,10 @@ module Dentaku
         when '='  then :eq
         end
       end),
-      TokenScanner.new(:combinator, '(and|or)\b',       lambda {|raw| raw.strip.downcase.to_sym }),
-      TokenScanner.new(:function,   '(if|round|not)\b', lambda {|raw| raw.strip.downcase.to_sym }),
-      TokenScanner.new(:identifier, '\w+\b',            lambda {|raw| raw.strip.downcase.to_sym })
+      TokenScanner.new(:combinator, '(and|or)\b', lambda {|raw| raw.strip.downcase.to_sym }),
+      TokenScanner.new(:function,   '(if|round(up|down)?|not)\b',
+                                                  lambda {|raw| raw.strip.downcase.to_sym }),
+      TokenScanner.new(:identifier, '\w+\b',      lambda {|raw| raw.strip.downcase.to_sym })
     ]
 
     LPAREN = TokenMatcher.new(:grouping, :open)

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "0.2.8"
+  VERSION = "0.2.9"
 end

data/spec/evaluator_spec.rb

@@ -57,7 +57,9 @@ describe Dentaku::Evaluator do
 
     describe 'functions' do
       it 'should evaluate function' do
-        evaluator.evaluate(token_stream(:round, :open, 5, :divide, 3.0, :close)).should eq 2
+        evaluator.evaluate(token_stream(:round,     :open, 5, :divide, 3.0, :close)).should eq 2
+        evaluator.evaluate(token_stream(:roundup,   :open, 5, :divide, 1.2, :close)).should eq 5
+        evaluator.evaluate(token_stream(:rounddown, :open, 5, :divide, 1.2, :close)).should eq 4
       end
     end
 

data/spec/spec_helper.rb

@@ -22,7 +22,7 @@ def type_for(value)
     :combinator
   when :true, :false
     :logical
-  when :if, :round, :not
+  when :if, :round, :roundup, :rounddown, :not
     :function
   else
     :identifier

data/spec/tokenizer_spec.rb

@@ -87,7 +87,7 @@ describe Dentaku::Tokenizer do
       tokens.map(&:value).should eq([:if, :open, :x, :lt, 10, :comma, :y, :comma, :z, :close])
     end
 
-    it 'include ROUND' do
+    it 'include ROUND/UP/DOWN' do
       tokens = tokenizer.tokenize('round(8.2)')
       tokens.length.should eq(4)
       tokens.map(&:category).should eq([:function, :grouping, :numeric, :grouping])
@@ -97,6 +97,16 @@ describe Dentaku::Tokenizer do
       tokens.length.should eq(6)
       tokens.map(&:category).should eq([:function, :grouping, :numeric, :grouping, :numeric, :grouping])
       tokens.map(&:value).should eq([:round, :open, 8.75, :comma, 1, :close])
+
+      tokens = tokenizer.tokenize('ROUNDUP(8.2)')
+      tokens.length.should eq(4)
+      tokens.map(&:category).should eq([:function, :grouping, :numeric, :grouping])
+      tokens.map(&:value).should eq([:roundup, :open, 8.2, :close])
+
+      tokens = tokenizer.tokenize('RoundDown(8.2)')
+      tokens.length.should eq(4)
+      tokens.map(&:category).should eq([:function, :grouping, :numeric, :grouping])
+      tokens.map(&:value).should eq([:rounddown, :open, 8.2, :close])
     end
 
     it 'include NOT' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-30 00:00:00.000000000 Z
+date: 2012-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -87,7 +87,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4557179252548583095
+      hash: -4230531870219194848
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -96,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4557179252548583095
+      hash: -4230531870219194848
 requirements: []
 rubyforge_project: dentaku
 rubygems_version: 1.8.23