expression_processor 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.md

@@ -0,0 +1,10 @@
+# ExpressionProcessor
+
+```ruby
+expression = ExpressionProcessor::Expression.new("MAX(10, SUM(A))")
+expression.constants({:A => [1,3,5]})
+expression.valid?([:A]) # specify constants that are allowed
+expression.eval # => 10
+```
+
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/expression_processor.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "expression_processor/version"
+
+Gem::Specification.new do |s|
+  s.name        = "expression_processor"
+  s.version     = ExpressionProcessor::VERSION
+  s.authors     = ["Stephen St. Martin"]
+  s.email       = ["kuprishuz@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Simple excel like formula processor}
+  s.description = %q{Allows you to process simple excel like formulas.}
+
+  s.rubyforge_project = "expression_processor"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/expression_processor.rb

@@ -0,0 +1,150 @@
+require "expression_processor/version"
+
+module ExpressionProcessor
+  class BlankSlate
+    instance_methods.each {|m| undef_method m unless m =~ /^(__|instance_eval|object_id)/}
+  end
+
+  class Expression
+    attr_accessor :constants, :errors, :expression
+
+    def initialize(expression)
+      @constants  = {}
+      @errors     = []
+      @expression = expression || ""
+    end
+
+    def constants=(constants)
+      constants.each {|constant, value| @constants[constant.to_s.downcase.to_sym] = value }
+    end
+
+    def eval
+      proxy     = Proxy.new(@constants)
+      untainted = preprocess.untaint
+      result    = valid? ? proc { $SAFE = 3; proxy.instance_eval(untainted) }.call : 0
+      result.to_f.round(2)
+    end
+
+    def preprocess
+      executable = @expression.downcase
+      tokenize.each do |token|
+        case token[0]
+          # ignore dollar signs
+          when :dollar
+            executable.gsub!(/\$/, '')
+          # convert percent to decimal 10% => 0.10
+          when :percent
+            executable.gsub!(/(#{token[1]})/) {|match| match.gsub(/(%)/, '').to_f / 100 }
+        end
+      end
+
+      # HACK: make sure operators have surrounding whitespace or calculations dont always
+      # have correct result (possibly an eval issue?)
+      executable.gsub!(/([%\/*+-])/, " \\1 ")
+      executable
+    end
+
+    def tokenize
+      @tokens ||= Lexer.new(@expression).tokenize
+    end
+
+    def valid?(constants = nil)
+      validate(constants)
+      @errors.empty?
+    end
+
+    private
+      def validate(constants = nil)
+        constants ||= @constants.keys
+
+        # check parentheses count
+        @errors << "has mismatched parenthesis" unless @expression.scan(/[()]/).length % 2 == 0
+
+        # check all tokens are valid
+        tokenize.each do |token|
+          case token[0]
+          when :call
+            @errors << "calls invalid method #{token[1]}" unless Proxy.instance_methods.include?(token[1].downcase.to_sym)
+          when :identifier
+            @errors << "uses invalid indentifier #{token[1]}" unless constants.include?(token[1].downcase) || constants.include?(token[1].downcase.to_sym)
+          when :operator
+          when :float
+          when :percent
+          when :dollar
+          when "("
+          when ")"
+          when ','
+          else
+            @errors << "has unrecognized token #{token[0]}"
+          end
+        end
+      end
+  end
+
+  class Lexer
+    def initialize(code)
+      @code = code.upcase.gsub(/\s/, '')
+      @tokens = []
+    end
+
+    def tokenize
+      position  = 0
+
+      # scan one character at a time
+      while position < @code.size
+        chunk = @code[position..-1]
+
+        if token = chunk[/\A([A-Z]\w*)\(/, 1]
+          @tokens << [:call, token]
+        elsif token = chunk[/\A([A-Z]\w*)/, 1]
+          @tokens << [:identifier, token]
+        elsif token = chunk[/\A([0-9.]+%{1})/, 1]
+          @tokens << [:percent, token]
+        elsif token = chunk[/\A(\$)[\d.]+/, 1]
+          @tokens << [:dollar, token]
+        elsif token = chunk[/\A([0-9.]+)/, 1]
+          @tokens << [:float, token.to_f]
+        elsif token = chunk[/\A([%\/*+-])/, 1]
+          @tokens << [:operator, token]
+        else
+          token = chunk[0,1]
+          @tokens << [token, token]
+        end
+
+        position += token.size
+      end
+
+      @tokens
+    end
+  end
+
+  class Proxy < BlankSlate
+    def initialize(constants)
+      @constants = constants
+    end
+
+    def method_missing(sym, *args, &block)
+      @constants[sym] || 0.0
+    end
+
+    def max(*values)
+      values = values.flatten! || values
+      values.max
+    end
+
+    def min(*values)
+      values = values.flatten! || values
+      values.min
+    end
+
+    def round(value)
+      value.to_f.round
+    end
+
+    def sum(*values)
+      values = values.flatten! || values
+      values.inject(0.0) {|total, value| total += value if value.is_a?(Numeric) }
+    end
+  end
+end
+

data/lib/expression_processor/version.rb

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

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: expression_processor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Stephen St. Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-20 00:00:00.000000000 Z
+dependencies: []
+description: Allows you to process simple excel like formulas.
+email:
+- kuprishuz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- expression_processor.gemspec
+- lib/expression_processor.rb
+- lib/expression_processor/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: expression_processor
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Simple excel like formula processor
+test_files: []