r_calc 0.0.1

data/.autotest

@@ -0,0 +1,10 @@
+# ./.autotest
+Autotest.add_hook(:initialize) {|at|
+  at.add_exception %r{^\.git}  # ignore Version Control System
+  at.add_exception %r{^./tmp}  # ignore temp files, lest autotest will run again, and again...
+  #  at.clear_mappings         # take out the default (test/test*rb)
+  at.add_mapping(%r{^lib/.*\.rb$}) {|f, _|
+    Dir['spec/**/*_spec.rb']
+  }
+  nil
+}

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+.rvmrc
+
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in r_calc.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Milan Jaric
+
+MIT License
+
+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 the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+# RCalc
+
+RCalc is gem which can help you adding calculator like behaviour to your code. It is sandboxed and there is no posibility that end user can execute some code against your system.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'r_calc'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install r_calc
+
+## Usage
+
+To use this gem, after including this could be minimum of required code to run calculation:
+
+`
+require 'r_calc'
+#require 'supermodel'
+#require 'minitest/spec'
+#require 'minitest/autorun'
+
+module RCalcHelpers
+  class Calculator < RCalc::FormulaProcessor
+    # Let's just add all of the usual operators
+
+    include ::RCalc::ParentheticalGrouping # ()
+    include ::RCalc::AssignmentOperator # =
+    include ::RCalc::LastResultOperator # $
+    include ::RCalc::ArithmeticOperators # +-*/%^
+    include ::RCalc::BooleanOperators # true false and or eq ne gt lt ge le not
+    include ::RCalc::FunctionOperators # sum(), max(), min()
+    # example of adding custom operators
+
+    def AddOperators_custom
+
+      calc = self
+
+
+      # Now let's show how you can use a function to access a constant, like PI
+
+      @operators << ::RCalc::BinaryOperator.new("[", 3) {|x, y| x.value + y.value}
+      @operators << ::RCalc::UnaryOperator.new("]", 4) { |x| x.value }
+
+    end
+  end
+
+  def calculator
+
+
+    values = Hash.new
+    calc = Calculator.new do |key, val|
+      values[key] = val if val
+      values[key]
+    end
+    [calc, values]
+  end
+
+end
+`
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
+
+#require 'rake/testtask'
+#
+#Rake::TestTask.new do |t|
+#  t.libs.push "lib"
+#  t.test_files = FileList['specs/**/*_spec.rb']
+#  t.verbose = true
+#end
+

data/lib/r_calc/arithmetic_operations.rb

@@ -0,0 +1,34 @@
+require 'r_calc/binary_operator'
+require 'r_calc/binary_or_unary_operator'
+
+# Arithmetic operators + - * / % ^
+module RCalc
+  module ArithmeticOperators
+    def AddOperators_Arithmetic
+
+      # Plus and minus are binary operators if they are preceeded by an operand.
+      # Otherwise they are unary, and have higher priority.
+
+      @operators << (plus = (BinOrUnOperator.new("+", nil) { |x, y| y ? x.value + y.value : x.value }))
+      @operators << (minus = (BinOrUnOperator.new("-", nil) { |x, y| y ? x.value - y.value : -x.value }))
+
+      # If a + or - has an operand preceding, the priority is lower than * and /,
+      # but higher than =.  If no operand precedes, it is higher than * or /.
+      # So, we create a code block to make this determination.
+
+      pmPriority = Proc.new { |operandPreceding| operandPreceding ? 2 : 4 }
+
+      # and assign it as the priorityProc for the + and - operators
+
+      plus.priorityProc = pmPriority
+      minus.priorityProc = pmPriority
+
+      # Now we add some easy binary operators...
+
+      @operators << (BinaryOperator.new("*", 3) { |x, y| x.value * y.value })
+      @operators << (BinaryOperator.new("/", 3) { |x, y| x.value / y.value })
+      @operators << (BinaryOperator.new("%", 3) { |x, y| x.value % y.value })
+      @operators << (BinaryOperator.new("^", 3) { |x, y| x.value ** y.value })
+    end
+  end
+end

data/lib/r_calc/assignment_operator.rb

@@ -0,0 +1,11 @@
+require 'r_calc/binary_operator'
+
+
+# = for assignment
+module RCalc
+  module AssignmentOperator
+    def AddOperators_Assignment
+      @operators << (::RCalc::BinaryOperator.new("=", 1) { |x, y| x.value = y.value })
+    end
+  end
+end

data/lib/r_calc/binary_operator.rb

@@ -0,0 +1,10 @@
+require 'r_calc/operator'
+
+# An operator that takes two operands
+class RCalc::BinaryOperator < ::RCalc::Operator
+
+  private
+  def initialize(symbol, priority)
+    super(symbol, 2, 2, priority)
+  end
+end

data/lib/r_calc/binary_or_unary_operator.rb

@@ -0,0 +1,8 @@
+require 'r_calc/operator'
+
+class RCalc::BinOrUnOperator < ::RCalc::Operator
+  private
+  def initialize(symbol, priority)
+    super(symbol, 1, 2, priority)
+  end
+end

data/lib/r_calc/boolean_operators.rb

@@ -0,0 +1,36 @@
+require 'r_calc/function'
+require 'r_calc/binary_operator'
+require 'r_calc/unary_operator'
+
+module RCalc
+  module BooleanOperators
+    def AddOperators_Boolean
+
+      # Functions for true and false
+
+      @operators << ::RCalc::Function.new("true", 0, 0) { true }
+      @operators << ::RCalc::Function.new("false", 0, 0) { false }
+
+      # Equality and its clan (note we cannot use '==' or other two-character
+      # non-word operators, because of the way we parse the string.  Non-word
+      # characters come in one at a time.
+
+      @operators << ::RCalc::BinaryOperator.new("eq", 3) { |x, y| x.value == y.value }
+      @operators << ::RCalc::BinaryOperator.new("ne", 3) { |x, y| x.value != y.value }
+      @operators << ::RCalc::BinaryOperator.new("gt", 3) { |x, y| x.value > y.value }
+      @operators << ::RCalc::BinaryOperator.new("lt", 3) { |x, y| x.value < y.value }
+      @operators << ::RCalc::BinaryOperator.new("ge", 3) { |x, y| x.value >= y.value }
+      @operators << ::RCalc::BinaryOperator.new("le", 3) { |x, y| x.value <= y.value }
+
+      # Boolean and/or
+
+      @operators << ::RCalc::BinaryOperator.new("and", 2) { |x, y| x.value && y.value }
+      @operators << ::RCalc::BinaryOperator.new("or", 2) { |x, y| x.value || y.value }
+
+      # Logical not
+
+      @operators << ::RCalc::UnaryOperator.new("not", 4) { |x| !x.value }
+
+    end
+  end
+end

data/lib/r_calc/formula_expression_exception.rb

@@ -0,0 +1,5 @@
+=begin
+  A unique class for exceptions so we can rescue them separately if we want to
+=end
+class RCalc::FormulaExpressionException < RuntimeError
+end

data/lib/r_calc/formula_processor.rb

@@ -0,0 +1,195 @@
+require 'r_calc/parse_token'
+require 'r_calc/operator'
+require 'r_calc/unary_operator'
+require 'r_calc/binary_operator'
+require 'r_calc/binary_or_unary_operator'
+require 'r_calc/function'
+require 'r_calc/pusher'
+require 'r_calc/popper'
+require 'r_calc/separator'
+require 'r_calc/identifier'
+require 'r_calc/literal'
+require 'r_calc/operator_list'
+require 'r_calc/parse_token'
+
+
+module RCalc
+# An expression processor.  This class can be derived to process many types of
+# expressions.  The modules defined below can be included in a derived class to
+# support popular sets of operations, or you can define your own.
+# The code block passed to the new method for this class is used for evaluating
+# identifiers in the expression.  This allows the client code to supply/store
+# variables in any way it wishes.
+  class FormulaProcessor
+    attr_reader :operators, :last_result, :receipt_components
+    private
+    def initialize(&proc)
+      @proc = proc # code block for accessing values for identifiers
+      @operators = OperatorList.new # hash for operators
+      @operators << Separator.new(',') # comma separates by default
+      @curr = nil # current operand stack
+      @currop = nil # current operator
+      @opstack = nil # stack of operators
+      @last_result = nil # result of last expression
+      @receipt_components =[] # the list of local identifiers which was used to store
+                   # values carried to next calculation
+
+                   # Here's a nifty little trick.  We'll inspect our methods and call any method
+                   # whose name starts with "AddOperator_".  That allows a derived class to include
+                   # any of the operator modules defined below, and automatically get support
+                   # for the operators included in each module, without having to invoke the
+                   # methods explicitly.
+
+      methods.each do |name|
+        self.send(name) if (name =~ /^AddOperators_/)
+      end
+    end
+
+    # Resolve the expression composed of the current operator (@currop) and the
+    # current operand stack (@curr)
+
+    def resolve
+      if (@currop) then # Do we have an operator?
+        args = @curr[1..-1] # omit the "pusher" (curr[0] is always a Pusher)
+
+        # check argument count requirements
+
+        if (@currop.minarg && (args.length < @currop.minarg))
+          raise(FormulaExpressionException, "Not enough arguments for operation '#{@currop.symbol}'\nMinimum: #{@currop.minarg}, encountered #{args.length}")
+        end
+        if (@currop.maxarg && (args.length > @currop.maxarg))
+          raise(FormulaExpressionException, "Too many arguments for operation '#{@currop.symbol}'\nMaximum: #{@currop.maxarg}, encountered #{args.length}")
+        end
+
+        # Call the operator's code block and store the result as element 1, trimming the other operands
+
+        @curr[1..-1] = Literal.new(@currop.proc.call(*args))
+        @currop = nil # No more current operator
+      end
+      if (@curr[0].implied) # pop off any implied Pusher
+        val = @curr[1] # grab the value
+        @curr = @curr[0].parent # pop back up to the parent operand stack
+        @curr[-1] = val # store the value over the reference to the stack we just popped
+        @currop = @opstack.pop # pop off the operator from the previous level
+      end
+      return @curr[-1] # In either case, return the last value on the current operand stack
+    end
+
+
+    public
+    # Evaluate an expression
+    def eval(input=$_) # default to current string if not passed
+      stack = [Pusher.new(nil)] # operand array (a stack of operands and/or operand stacks)
+      @opstack = [] # operator stack
+      @curr = stack # current operand stack
+      @currop = nil # operator at current stack level
+
+      # Tokenize as numeric or identifier or non-space/comma (presumably an operator or parentheses)
+      input.scan(/[0-9.]+|\w+|,|[^\s\t\r\n\f]/) do |token|
+        t = nil
+        if (token =~ /^[0-9]+$/) then # integer literal
+          t = Literal.new(token.to_i)
+        elsif (token =~ /^[0-9.]+$/) then # floating point literal
+          t = Literal.new(token.to_f)
+        elsif (t = @operators[token]) then # a defined operator
+        elsif (token =~ /^\w+$/) # an identifier
+          t = Identifier.new(token, @proc)
+          receipt_components << token unless receipt_components.include? token
+        else
+          raise(FormulaExpressionException, "Unrecognized character in expression: #{token}")
+        end
+
+        if (t) # Did we create something?
+          case t.parseAction # What are we to do with it?
+            when ParseToken::PARSE_VALUE # Literals and identifiers
+              @curr.push(t) #  get pushed as operands
+
+            when ParseToken::PARSE_OP # Operators and functions
+              t = t.clone # Must copy to establish priority independently
+
+              # Get the priority (note our only context-based syntax element, a leading operand)
+              prior = t.priority(opPreceding = @currop ? (@curr.length > 2) : (@curr.length > 1))
+
+              # If we already have an operator with at least equal priority, resolve it
+              while (@currop && (prior <= @currop.priority))
+                resolve
+              end
+              if (@currop) then # We found an operator of lower priority
+                pusher = Pusher.new(nil) # Group our new operation (implied parenthesis)
+                pusher.implied = true
+                pusher.parent = @curr # back-link the stack
+                if (opPreceding) then # operand preceding?
+                  new = [pusher, @curr[-1]] # move last operand to new operation
+                  @curr[-1] = new # link new stack to end of old one
+                else
+                  new = [pusher]
+                  @curr.push(new) # just push and go
+                end
+                @curr = new # save reference to new operand stack
+                @opstack.push(@currop) # push the previous operator
+              end
+              @currop = t # now we have a new operator
+
+              # Resolve the operation if we already reached the maximum argument count
+              resolve if (@currop.maxarg && (@curr.length > @currop.maxarg))
+
+            when ParseToken::PARSE_PUSH # Grouping (parenthesis equivalent)
+              t = t.clone # Clone so we have a unique parent property
+              t.parent = @curr # Back-link to previous operand stack
+              @curr.push(new = [t]) # Forward-link to new operand stack
+              @curr = new # Save reference to new stack
+              @opstack.push(@currop) # Push the current operator, if any
+              @currop = nil # No current operator yet within this grouping
+
+            when ParseToken::PARSE_POP # End grouping (close parenthesis)
+              resolve while (@curr[0].implied) # Resolve all implied pushes first
+              if (@currop) then # Do we have an operator?
+                val = resolve # Resolve the contained operation
+
+                # If we're already unwound, this is an extra one
+                raise(FormulaExpressionException, "Unmatched #{t.symbol}") if (@curr == stack)
+                @curr = @curr[0].parent # Pop back to parent stack
+                @curr[-1] = val # Store the value over the forward reference (losing the reference)
+              else # No current operator, just move the operands back
+                val = @curr[1..-1] # Gather the operands
+                @curr = @curr[0].parent # Pop back to parent stack
+                @curr[-1, val.length] = val # Extend the operand stack with the new operands
+              end
+              @currop = @opstack.pop # Pop back to previous operator
+
+            when ParseToken::PARSE_SEPARATE # Separator, like comma
+              resolve if (@currop || @curr[0].implied) # Resolve any pending operation
+              pusher = Pusher.new(nil) # Implied push to prevent folding operators across separator
+              pusher.implied = true
+              pusher.parent = @curr
+              new = [pusher]
+              @curr.push(new)
+              @curr = new
+              @opstack.push(@currop)
+              @currop = nil
+          end # case t.parseAction
+        end # if (t)
+      end # input.scan
+
+      # Pop off any implied pushes, resolving the values
+      resolve while (@curr[0].implied)
+
+      # Make sure we unwound completely
+      raise(FormulaExpressionException, "Unmatched #{@curr[0].symbol}") if (@curr != stack)
+
+      # Resolve any final operator, and save the value
+      @last_result = resolve.value
+
+      # Make sure we ended up with just one value
+      raise(FormulaExpressionException, "Missing operator") if (@curr.length > 2)
+
+      # Return that value
+      @last_result
+    end
+
+  end
+end
+
+
+
+

data/lib/r_calc/function.rb

@@ -0,0 +1,11 @@
+require 'r_calc/operator'
+
+# A function has the lowest priority, because usually the arguments are
+# enclosed in a push/pop sequence (e.g., parentheses)
+
+class RCalc::Function < ::RCalc::Operator
+  private
+  def initialize(name, minarg, maxarg)
+    super(name, minarg, maxarg, 5)
+  end
+end

data/lib/r_calc/function_operators.rb

@@ -0,0 +1,33 @@
+require 'r_calc/function'
+require 'r_calc/binary_operator'
+require 'r_calc/unary_operator'
+
+module RCalc
+  module FunctionOperators
+    def AddOperators_ArithmeticFunctions
+      @operators << ::RCalc::Function.new("sum", 1, nil) do |*args|
+        args.inject(0) { |sum, arg| sum + arg.value }
+      end
+
+      @operators << ::RCalc::Function.new("max", 1, nil) do |*args|
+        max = nil
+        args.each { |arg| max = arg.value if !max || arg.value > max }
+        max
+      end
+
+      @operators << ::RCalc::Function.new("min", 1, nil) do |*args|
+        min = nil
+        args.each { |arg| min = arg.value if !min || arg.value < min }
+        min
+      end
+
+      @operators << ::RCalc::Function.new("PI", 0, 0) { Math::PI }
+    end
+
+    def AddOperators_BooleanFunctions
+      @operators << ::RCalc::Function.new("if", 3, 3) do |cond, x, y|
+        cond.value ? x.value : (y.value || 0)
+      end
+    end
+  end
+end

data/lib/r_calc/identifier.rb

@@ -0,0 +1,21 @@
+require 'r_calc/parse_token'
+
+# A token that presumably references a variable of some sort
+# This class demonstrates calling a code block from a saved reference to it.
+
+class RCalc::Identifier < RCalc::ParseToken
+  private
+  def initialize(name, proc)
+    super(name, ::RCalc::ParseToken::PARSE_VALUE) # Note we use the name as the symbol
+    @proc = proc # proc is a code block for evaluating the symbol
+  end
+
+  public
+  def value=(newvalue) # Assign to value
+    @proc.call(self.symbol, newvalue) # We pass newvalue to denote assignment
+  end
+
+  def value # Get value
+    @proc.call(self.symbol) # No newvalue passed here
+  end
+end

data/lib/r_calc/last_result_operator.rb

@@ -0,0 +1,9 @@
+require 'r_calc/function'
+# $ for last result
+module RCalc
+  module LastResultOperator
+    def AddOperators_LastResult
+      @operators << ::RCalc::Function.new("$", 0, 0) { self.last_result }
+    end
+  end
+end

data/lib/r_calc/literal.rb

@@ -0,0 +1,25 @@
+require 'r_calc/formula_expression_exception'
+require 'r_calc/parse_token'
+# A literal value
+
+class RCalc::Literal < RCalc::ParseToken
+  attr_reader :value # Just like an Identifier, we can get the
+                     # value using the 'value' property, even
+                     # though the implementation has nothing in common.
+                     # The nice thing about Ruby is that these
+                     # two classes do not need to be derived
+                     # from an abstract parent class (less typing,
+                     # in every sense of the word).
+  private
+  def initialize(value)
+    super(value, ::RCalc::ParseToken::PARSE_VALUE) # Note we use the value itself as the symbol
+    @value = value
+  end
+
+  public
+                     # We could have left out the following method, but our version gives a better error
+                     # messsage than the default "method missing value=".
+  def value=(newvalue) # Assign a value
+    raise(::RCalc::FormulaExpressionException, "Writing into a literal") # Not!
+  end
+end

data/lib/r_calc/operator.rb

@@ -0,0 +1,32 @@
+require 'r_calc/parse_token'
+
+
+=begin
+An operator (or function identifier)
+=end
+class RCalc::Operator < RCalc::ParseToken
+  attr_reader :proc, :minarg, :maxarg, :priorityProc
+  attr_writer :priorityProc
+
+  private
+  def initialize(symbol, minarg, maxarg, priority, &proc)
+    super(symbol, RCalc::ParseToken::PARSE_OP)
+    @minarg = minarg # minimum number of operands
+    @maxarg = maxarg # maximum number of operands
+    @priority = priority # operator precedence (0 = low .. 5 = high)
+    @proc = proc # code block for performing the operation
+    @priorityProc = nil # procedure for determining priority
+                        # (we need this for operators that determine
+                        #  priority based on context, like + and -
+  end
+
+  public
+  # Get priority of the operator
+  def priority(operandPreceding = nil)
+    # only determine priority once, possibly based on context
+    if (!(@priority) && @priorityProc) # do we have a proc for processing priority?
+      @priority = @priorityProc.call(operandPreceding) # call it
+    end
+    @priority # return it
+  end
+end

data/lib/r_calc/operator_list.rb

@@ -0,0 +1,8 @@
+# A special Hash for the list of supported operators
+# The user can append new operators, without worrying about how we need to handle them.
+
+class RCalc::OperatorList < Hash
+  def <<(oper) # No need for the user to know about the keys
+    self[oper.symbol] = oper # We use the operator's symbol for the key, BTW
+  end
+end

data/lib/r_calc/parenthetical_grouping.rb

@@ -0,0 +1,20 @@
+require 'r_calc/pusher'
+require 'r_calc/popper'
+
+module RCalc
+
+# Mix-ins for the usual operations.  See ExpressionProcessor#initialize for how
+# these "AddOperator_" methods get invoked.
+
+# First, parenthetical grouping
+  module ParentheticalGrouping
+    def AddOperators_ParentheticalGrouping
+
+      # Define "(" and ")" as our grouping operators
+
+      @operators << ::RCalc::Pusher.new("(")
+      @operators << ::RCalc::Popper.new(")")
+    end
+  end
+
+end

data/lib/r_calc/parse_token.rb

@@ -0,0 +1,18 @@
+=begin
+Any token we might encounter in the expression
+=end
+class RCalc::ParseToken
+  public
+  # values for parseAction (what to do when we encounter this token):
+  PARSE_VALUE = 0 # A literal or an identifier (stack it)
+  PARSE_OP = 1 # An operator
+  PARSE_PUSH = 2 # Open parenthesis, for example
+  PARSE_POP = 3 # Close parenthesis, for example
+  PARSE_SEPARATE = 4 # Comma, for example
+  attr_reader :symbol, :parseAction
+  private
+  def initialize(symbol, parseAction)
+    @symbol = symbol # symbol used for parsing
+    @parseAction = parseAction # action when parsing
+  end
+end

data/lib/r_calc/popper.rb

@@ -0,0 +1,10 @@
+require 'r_calc/parse_token'
+
+# The complementary close parenthesis (or equivalent)
+
+class RCalc::Popper < RCalc::ParseToken
+  private
+  def initialize(symbol)
+    super(symbol, RCalc::ParseToken::PARSE_POP)
+  end
+end

data/lib/r_calc/pusher.rb

@@ -0,0 +1,17 @@
+require 'r_calc/formula_expression_exception'
+require 'r_calc/parse_token'
+
+class RCalc::Pusher < RCalc::ParseToken
+  attr_reader :parent, :implied # parent operand array
+  attr_writer :parent, :implied # implied means we created it via operator precedence
+  private
+  def initialize(symbol)
+    super(symbol, RCalc::ParseToken::PARSE_PUSH)
+    @implied = false # by default it is a literal token
+  end
+
+  public
+  def value # Tried to evaluate one of these
+    raise(RCalc::FormulaExpressionException, "Unrecognized expression")
+  end
+end

data/lib/r_calc/separator.rb

@@ -0,0 +1,10 @@
+require 'r_calc/parse_token'
+
+# A separator, like comma
+
+class RCalc::Separator < RCalc::ParseToken
+  private
+  def initialize(symbol)
+    super(symbol, RCalc::ParseToken::PARSE_SEPARATE)
+  end
+end

data/lib/r_calc/unary_operator.rb

@@ -0,0 +1,11 @@
+require 'r_calc/operator'
+
+
+# An operator that takes only one operand
+
+class RCalc::UnaryOperator < RCalc::Operator
+  private
+  def initialize(symbol, priority)
+    super(symbol, 1, 1, priority)
+  end
+end

data/lib/r_calc/version.rb

@@ -0,0 +1,3 @@
+module RCalc
+  VERSION = "0.0.1"
+end

data/lib/r_calc.rb

@@ -0,0 +1,12 @@
+require "r_calc/version"
+require 'r_calc/formula_expression_exception'
+require 'r_calc/formula_processor'
+require 'r_calc/parenthetical_grouping'
+require 'r_calc/assignment_operator'
+require 'r_calc/last_result_operator'
+require 'r_calc/arithmetic_operations'
+require 'r_calc/boolean_operators'
+require 'r_calc/function_operators'
+module RCalc
+  # Your code goes here...
+end

data/r_calc.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/r_calc/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors = ["Milan Jaric"]
+  gem.email = ["milan.jaric@gmail.com"]
+  gem.description = %q{Gem defines basic grammar for formula builder and ability to execute formulas to get it results or sum them.}
+  gem.summary = %q{Sandboxed formula builder and evaluator}
+  gem.homepage = "https://github.com/mjaric/formulator"
+
+  gem.files = `git ls-files`.split($\)
+  gem.executables = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name = "r_calc"
+  gem.require_paths = ["lib"]
+  gem.version = RCalc::VERSION
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "ZenTest"
+  gem.add_development_dependency "autotest-fsevent"
+  gem.add_development_dependency "autotest-growl"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "minitest-spec"
+  #gem.add_development_dependency "supermodel"
+end

data/spec/r_calc_spec.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+require 'spec/spec_helper'
+
+describe RCalc::FormulaProcessor do
+
+  RSpec.configure do |c|
+    c.include RCalcHelpers
+  end
+
+  let :c do
+    a, b= calculator
+    a
+  end
+
+  describe "#eval" do
+    it "can add two numbers" do
+      c.eval("2+2").should eq(4)
+    end
+    it "can multiple two numbers" do
+      c.eval("2*2").should eq(4)
+    end
+    it "can divide two numbers" do
+      c.eval("2/2").should eq(1)
+    end
+    it "can mod (%) two numbers" do
+      c.eval("3%2").should eq(1)
+    end
+    it "can pow (^) two numbers" do
+      c.eval("3^2").should eq(9)
+    end
+    it "can sum more than 2 numbers" do
+      c.eval("sum(1,2,3,4,5)").should eq(15)
+    end
+    it "can get minimum of number sequence" do
+      c.eval("min(1,2,3,4,5)").should eq(1)
+    end
+    it "can get maximum of number sequence" do
+      c.eval("max(1,2,3,4,5)").should eq(5)
+    end
+    it "can compare numbers" do
+      c.eval("4 lt 2").should eq(false)
+      c.eval("4 lt 4").should eq(false)
+      c.eval("4 lt 5").should eq(true)
+
+      c.eval("4 le 2").should eq(false)
+      c.eval("4 le 4").should eq(true)
+      c.eval("4 le 5").should eq(true)
+
+      c.eval("4 gt 2").should eq(true)
+      c.eval("4 gt 4").should eq(false)
+      c.eval("4 gt 5").should eq(false)
+
+      c.eval("4 ge 2").should eq(true)
+      c.eval("4 ge 4").should eq(true)
+      c.eval("4 ge 5").should eq(false)
+
+      c.eval("4 eq 2").should eq(false)
+      c.eval("4 eq 4").should eq(true)
+      c.eval("4 eq 5").should eq(false)
+
+      c.eval("4 ne 2").should eq(true)
+      c.eval("4 ne 4").should eq(false)
+      c.eval("4 ne 5").should eq(true)
+
+    end
+
+    it "can compare numbers using if statement with two branches" do
+      c.eval("if(4 lt 2, 1, -1 )").should eq(-1)
+    end
+
+  end
+
+  describe "memoizable #eval" do
+    it "can memoize variables into the hash" do
+      calc, memo = calculator
+      calc.eval("number=12*3").should eq(36)
+      memo["number"].should eq(36)
+    end
+    it "can memoize variables and it can be reused later in next step formula" do
+      calc, memo = calculator
+      calc.eval("number=12*3")
+      calc.eval("number * 10").should eq(360)
+    end
+
+    it "can memoize last value sing $" do
+      calc, memo = calculator
+      val = calc.eval("12*3")
+      calc.eval("$").should eq(36)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'r_calc'
+#require 'supermodel'
+#require 'minitest/spec'
+#require 'minitest/autorun'
+
+module RCalcHelpers
+  class Calculator < RCalc::FormulaProcessor
+    # Let's just add all of the usual operators
+
+    include ::RCalc::ParentheticalGrouping # ()
+    include ::RCalc::AssignmentOperator # =
+    include ::RCalc::LastResultOperator # $
+    include ::RCalc::ArithmeticOperators # +-*/%^
+    include ::RCalc::BooleanOperators # true false and or eq ne gt lt ge le not
+    include ::RCalc::FunctionOperators # sum(), max(), min()
+    # example of adding custom operators
+
+    def AddOperators_custom
+
+      calc = self
+
+
+      # Now let's show how you can use a function to access a constant, like PI
+
+      @operators << ::RCalc::BinaryOperator.new("[", 3) {|x, y| x.value + y.value}
+      @operators << ::RCalc::UnaryOperator.new("]", 4) { |x| x.value }
+
+    end
+  end
+
+  def calculator
+
+
+    values = Hash.new
+    calc = Calculator.new do |key, val|
+      values[key] = val if val
+      values[key]
+    end
+    [calc, values]
+  end
+
+end

metadata

@@ -0,0 +1,213 @@
+--- !ruby/object:Gem::Specification
+name: r_calc
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.0.1
+platform: ruby
+authors:
+- Milan Jaric
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: ZenTest
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: autotest-fsevent
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: autotest-growl
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: minitest
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: minitest-spec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+description: Gem defines basic grammar for formula builder and ability to execute formulas to get it results or sum them.
+email:
+- milan.jaric@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".autotest"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/r_calc.rb
+- lib/r_calc/arithmetic_operations.rb
+- lib/r_calc/assignment_operator.rb
+- lib/r_calc/binary_operator.rb
+- lib/r_calc/binary_or_unary_operator.rb
+- lib/r_calc/boolean_operators.rb
+- lib/r_calc/formula_expression_exception.rb
+- lib/r_calc/formula_processor.rb
+- lib/r_calc/function.rb
+- lib/r_calc/function_operators.rb
+- lib/r_calc/identifier.rb
+- lib/r_calc/last_result_operator.rb
+- lib/r_calc/literal.rb
+- lib/r_calc/operator.rb
+- lib/r_calc/operator_list.rb
+- lib/r_calc/parenthetical_grouping.rb
+- lib/r_calc/parse_token.rb
+- lib/r_calc/popper.rb
+- lib/r_calc/pusher.rb
+- lib/r_calc/separator.rb
+- lib/r_calc/unary_operator.rb
+- lib/r_calc/version.rb
+- r_calc.gemspec
+- spec/r_calc_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mjaric/formulator
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: 2
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: 2
+      version: !binary |-
+        MA==
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.25
+signing_key:
+specification_version: 3
+summary: Sandboxed formula builder and evaluator
+test_files:
+- spec/r_calc_spec.rb
+- spec/spec_helper.rb