romanesco 0.1.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: efdfbccebe16fe99c864f88845a127cf8cc663a9
+  data.tar.gz: 661732d53c05909b584cb63f26361c2222bb091c
+SHA512:
+  metadata.gz: bfb3ec65909612ee9e14b06d5bab01bd22f4da04a8cdd170fc0ac77cec68af689dfb028f23a53f773f1c30710d40a34d14f97759e0fee49872d887cbad0d04d8
+  data.tar.gz: 8619b8a4be699f71f80cb7dc3718c6f8188dd09d65758b82fe56ddc5094e39455d3a3ee7822aaaa74cf90f3be07f17379a6e825a1a7c743221c3640854e8437b

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Charlie Ablett and Craig Taube-Schock (Enspiral Craftworks)
+
+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,89 @@
+# Romanesco
+
+[![Gem Version](https://badge.fury.io/rb/romanesco.svg)](http://badge.fury.io/rb/romanesco)
+
+Romanesco allows you to parse simple mathematical expressions, and creates a fully object-oriented expression tree for evaluation.
+
+You can inject variable values at runtime so that formulae can be used, edited and re-saved as part of an application. 
+
+Currently Romanesco supports the four basic operators (addition, subtraction, multiplication, division) as well as parentheses. It supports the use of constants and named variables.
+
+Written by Charlie Ablett of Enspiral Craftworks (http://www.enspiral.com) with support from Craig Taube-Schock.
+
+MIT License.
+
+So named because Romanesco broccoli is neat-looking and has self-repeating patterns, much like the structure of the resulting expression tree. Also, it's tasty.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'romanesco'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install romanesco
+
+## Usage
+
+You can use Romanesco as a basic calculator if you want.
+
+    expression = Romanesco.parse("1+10*3")
+    result = expression.evaluate #=> 31.0
+    original_expression = expression.to_s #=> "1 + 10 * 3"
+
+If you have variables, inject them as follows:
+
+    expression = Romanesco.parse("a * (b + c)")
+    result = expression.evaluate(a: 5, b: 2, c: 10) # => 100.0
+    original_expression_string = expression.to_s # => "a * (b + c)"
+    
+In fact, you can inject anything that responds to the message `evaluate(options)`...
+
+    class FakeClass
+      def evaluate(options)
+        100
+      end
+    end
+
+    expression = Romanesco.parse("one_hundred + 2.2")
+    result = expression.evaluate(one_hundred: FakeClass.new) # => 102.2        
+    
+... including *other expressions* (Don't worry, in this case we *can* detect infinite loops):
+    
+    dangerous_animals = Romanesco.parse("honey_badgers + dangerous_australian_animals")
+    australian = Romanesco.parse("box_jellyfish + snakes")
+    result = dangerous_animals.evaluate(box_jellyfish: 10, snakes: 4, dangerous_australian_animals: australian, honey_badgers: 1) #=> 15    
+
+Get a list of the variables you'll need by calling `required_variables`:
+
+    expression = Romanesco.parse("(lions + tigers) * bears")
+    required = expression.required_variables #=> [:lions, :tigers, :bears]
+    
+If you're missing any variables, Romanesco will let you know:
+
+    expression = Romanesco.parse("maine_coon * japanese_bobtail")
+     
+    begin
+      expression.evaluate
+    rescue Romanesco::MissingVariables => e
+      e.missing_variables #=> [:maine_coon, :japanese_bobtail]
+    end
+    
+Otherwise, you can provide a default value for any missing variables:
+    
+    expression = Romanesco.parse("maine_coon * japanese_bobtail")
+    
+    expression.evaluate({}, 3) #=> 9.0
+    
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/romanesco/elements/addition_operator.rb

@@ -0,0 +1,20 @@
+require 'romanesco/elements/binary_operator'
+
+module Romanesco
+  class AdditionOperator < BinaryOperator
+
+    def initialize(symbol)
+      @symbol = '+'
+    end
+
+    def evaluate(options={})
+      left_result, right_result = super(options)
+      left_result + right_result
+    end
+
+    def default_precedence
+      10
+    end
+
+  end
+end

data/lib/romanesco/elements/binary_operator.rb

@@ -0,0 +1,36 @@
+require 'romanesco/elements/operator'
+
+module Romanesco
+  class BinaryOperator < Operator
+
+    attr_accessor :left_operand, :right_operand, :symbol
+
+    def initialize(symbol)
+      @symbol = symbol
+    end
+
+    def evaluate(options)
+      check_for_blank_symbol
+      left_result = @left_operand.evaluate(options)
+      right_result = @right_operand.evaluate(options)
+      return left_result, right_result
+    end
+
+    def to_s
+      "#{@left_operand.to_s} #{symbol} #{@right_operand.to_s}"
+    end
+
+    def insert_element_to_left(element)
+      @left_operand = element
+      element.parent = self
+      element
+    end
+
+    def insert_element_to_right(element)
+      @right_operand = element
+      element.parent = self
+      element
+    end
+
+  end
+end

data/lib/romanesco/elements/constant_operand.rb

@@ -0,0 +1,21 @@
+require 'romanesco/elements/operand'
+
+module Romanesco
+  class ConstantOperand < Operand
+
+    attr_accessor :value
+
+    def initialize(value)
+      @value = value.to_f
+    end
+
+    def evaluate(options)
+      @value
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+  end
+end

data/lib/romanesco/elements/division_operator.rb

@@ -0,0 +1,20 @@
+require 'romanesco/elements/binary_operator'
+
+module Romanesco
+  class DivisionOperator < BinaryOperator
+
+    def initialize(symbol)
+      @symbol = '/'
+    end
+
+    def evaluate(options)
+      left_result, right_result = super(options)
+      left_result / right_result
+    end
+
+    def default_precedence
+      50
+    end
+
+  end
+end

data/lib/romanesco/elements/expression.rb

@@ -0,0 +1,15 @@
+module Romanesco
+  class Expression
+
+    attr_accessor :parent
+
+    def initialize(expression_part)
+      @expression_part = expression_part
+    end
+
+    def evaluate(options)
+      raise NotImplementedError
+    end
+
+  end
+end

data/lib/romanesco/elements/multiplication_operator.rb

@@ -0,0 +1,19 @@
+require 'romanesco/elements/binary_operator'
+
+module Romanesco
+  class MultiplicationOperator < BinaryOperator
+
+    def initialize(symbol)
+      @symbol = '*'
+    end
+
+    def evaluate(options)
+      left_result, right_result = super(options)
+      left_result * right_result
+    end
+
+    def default_precedence
+      50
+    end
+  end
+end

data/lib/romanesco/elements/operand.rb

@@ -0,0 +1,15 @@
+require 'romanesco/elements/expression'
+
+module Romanesco
+  class Operand < Expression
+
+    def connect(last_operator, last_operand)
+      if last_operator && last_operator.is_a?(BinaryOperator) && last_operator.left_operand
+        last_operator.insert_element_to_right(self)
+      elsif last_operator
+        last_operator.insert_element_to_right(self)
+      end
+    end
+
+  end
+end

data/lib/romanesco/elements/operator.rb

@@ -0,0 +1,72 @@
+require 'romanesco/elements/expression'
+
+module Romanesco
+  class Operator < Expression
+
+    attr_accessor :symbol
+
+    def evaluate(options)
+      raise NotImplementedError
+    end
+
+    def precedence
+      @precedence || default_precedence
+    end
+
+    def check_for_blank_symbol
+      raise NoSymbolError if @symbol.nil? || @symbol.gsub(/\s+/, '').empty?
+    end
+
+    def precedence=(value)
+      @precedence = value
+    end
+
+    def default_precedence
+      raise NotImplementedError
+    end
+
+    def connect(last_operator, last_operand)
+      if last_operator && last_operator.is_a?(ParenthesesOperator) && last_operator.precedence > self.precedence
+        connect_in_place(last_operator, last_operand)
+      elsif last_operator && last_operator.is_a?(ParenthesesOperator) && self.is_a?(ParenthesesOperator)
+        last_operator.connect_to_left(self)
+      elsif last_operator && last_operator.parent && last_operator.precedence >= self.precedence
+        connect_in_place_with_parent(last_operator, last_operand)
+      elsif last_operator && last_operator.parent && last_operator.precedence < self.precedence
+        connect_in_place_with_parent(last_operator, last_operand)
+      elsif last_operator && last_operator.is_a?(ParenthesesOperator) && last_operator.precedence < self.precedence
+        connect_up_tree(last_operator)
+      elsif last_operator && last_operator.precedence >= self.precedence
+        connect_up_tree(last_operator)
+      elsif last_operator && self.is_a?(ParenthesesOperator)
+        connect_to_right(last_operator)
+      elsif last_operator
+        connect_in_place(last_operator, last_operand)
+      else
+        connect_to_left(last_operand)
+      end
+    end
+
+    def connect_in_place_with_parent(last_operator, last_operand)
+      last_operator.parent.insert_element_to_right(self)
+      self.insert_element_to_left(last_operand)
+    end
+
+    def connect_in_place(last_operator, last_operand)
+      self.insert_element_to_left(last_operand)
+      last_operator.insert_element_to_right(self)
+    end
+
+    def connect_up_tree(last_operator)
+      self.insert_element_to_left(last_operator)
+    end
+
+    def connect_to_left(element)
+      self.insert_element_to_left(element)
+    end
+
+    def connect_to_right(element)
+      element.insert_element_to_right(self)
+    end
+  end
+end

data/lib/romanesco/elements/parentheses_operator.rb

@@ -0,0 +1,15 @@
+require 'romanesco/elements/unary_operator'
+
+module Romanesco
+  class ParenthesesOperator < UnaryOperator
+
+    def initialize(symbol)
+      @symbol = '()'
+    end
+
+    def default_precedence
+      100
+    end
+
+  end
+end

data/lib/romanesco/elements/subtraction_operator.rb

@@ -0,0 +1,18 @@
+module Romanesco
+  class SubtractionOperator < BinaryOperator
+
+    def initialize(symbol)
+      @symbol = '-'
+    end
+
+    def evaluate(options)
+      left_result, right_result = super(options)
+      left_result - right_result
+    end
+
+    def default_precedence
+      10
+    end
+
+  end
+end

data/lib/romanesco/elements/unary_operator.rb

@@ -0,0 +1,35 @@
+require 'romanesco/elements/operator'
+
+module Romanesco
+  class UnaryOperator < Operator
+
+    attr_accessor :operand, :symbol
+
+    def initialize(symbol)
+      @symbol = symbol
+    end
+
+    def evaluate(options)
+      check_for_blank_symbol
+      @result = @operand.evaluate(options)
+    end
+
+    def to_s
+      "(#{@operand.to_s})"
+    end
+
+    def insert_element_to_left(element)
+      insert_element(element)
+    end
+
+    def insert_element_to_right(element)
+      insert_element(element)
+    end
+
+    def insert_element(element)
+      @operand = element
+      element.parent = self if element
+      element
+    end
+  end
+end

data/lib/romanesco/elements/variable_operand.rb

@@ -0,0 +1,26 @@
+require 'romanesco/elements/operand'
+require 'romanesco/errors'
+
+module Romanesco
+
+  class VariableOperand < Operand
+
+    attr_accessor :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def evaluate(options)
+      element = options[@name.to_sym]
+      return element.evaluate(options) if element.respond_to?(:evaluate)
+      options[@name.to_sym].to_f if element.is_a? Numeric
+    end
+
+    def to_s
+      @name.to_s
+    end
+
+  end
+
+end

data/lib/romanesco/errors.rb

@@ -0,0 +1,18 @@
+module Romanesco
+
+  class NoSymbolError < StandardError; end
+  class InvalidExpressionError < StandardError; end
+
+  class MissingVariables < StandardError
+    attr_accessor :missing_variables
+
+    def initialize(message = nil, missing_variables = nil)
+      super(message)
+      self.missing_variables = missing_variables
+    end
+  end
+
+
+  class HasInfiniteLoopError < StandardError; end
+
+end

data/lib/romanesco/expression_tree.rb

@@ -0,0 +1,92 @@
+require 'romanesco/errors'
+
+module Romanesco
+  class ExpressionTree
+    attr_accessor :last_operand, :last_operator, :original_expression
+    attr_reader :required_variables
+
+    def initialize(expression)
+      @original_expression = expression
+      @required_variables = []
+    end
+
+    def add(element)
+      element.connect(@last_operator, @last_operand)
+      @last_operand = element if element.is_a? Operand
+      @last_operator = element if element.is_a? Operator
+      @required_variables << element.name.to_sym if element.is_a? VariableOperand
+    end
+
+    def close_parenthesis
+      if last_operator.is_a? ParenthesesOperator
+        current_node = @last_operator
+      else
+        current_node = @last_operand
+        until current_node.is_a? ParenthesesOperator || current_node.parent.nil?
+          current_node = current_node.parent
+        end
+      end
+
+      current_node.precedence = 0
+      @last_operand = @last_operator = current_node
+    end
+
+    def evaluate(options={}, default_value=nil)
+      start = starting_point
+      check_for_loops(start, options)
+      missing_variables, new_options = check_for_missing_variables(start, options, [], default_value)
+      raise MissingVariables.new("Missing variables: #{missing_variables.join', '}", missing_variables) unless missing_variables.empty?
+      start.evaluate(new_options)
+    end
+
+    def to_s
+      starting_point.to_s
+    end
+
+    def starting_point
+      return @starting_point if @starting_point
+      current_node = @last_operand
+      until current_node.parent.nil?
+        current_node = current_node.parent
+      end
+      @starting_point = current_node
+    end
+
+    private
+
+    def check_for_loops(start, options)
+      iterate_to_variables(self, start, options) do |node, element, opts, block|
+        variable_value = opts[element.name.to_sym]
+        if variable_value.respond_to? :starting_point
+          raise HasInfiniteLoopError.new('Cannot evaluate - infinite loop detected') if node == variable_value
+          iterate_to_variables node, variable_value.starting_point, opts, &block if variable_value.respond_to? :evaluate
+        end
+      end
+    end
+
+    def check_for_missing_variables(start, options, missing_variables, default_value)
+      iterate_to_variables(missing_variables, start, options) do |missing_variables, element, opts, block|
+        variable_value = opts[element.name.to_sym]
+        if variable_value.respond_to? :starting_point
+          iterate_to_variables missing_variables, variable_value.starting_point, opts, &block if variable_value.respond_to? :evaluate
+        elsif variable_value.nil?
+          options[element.name.to_sym] = default_value
+          missing_variables << element.name.to_sym unless default_value
+        end
+      end
+      return missing_variables, options
+    end
+
+    def iterate_to_variables(node, element, options, &block)
+      if element.is_a? BinaryOperator
+        iterate_to_variables node, element.left_operand, options, &block
+        iterate_to_variables node, element.right_operand, options, &block
+      elsif element.is_a? UnaryOperator
+        iterate_to_variables node, element.operand, options, &block
+      elsif element.is_a? VariableOperand
+        block.call(node, element, options, block)
+      end
+    end
+
+  end
+end

data/lib/romanesco/expression_tree_builder.rb

@@ -0,0 +1,15 @@
+require 'romanesco/state_machine'
+require 'romanesco/expression_tree'
+
+module Romanesco
+  class ExpressionTreeBuilder
+
+    def build_tree(expression, elements)
+      first_state = StateZero
+      new_tree = ExpressionTree.new(expression)
+      first_state.transition(new_tree, elements)
+      new_tree
+    end
+
+  end
+end

data/lib/romanesco/parser.rb

@@ -0,0 +1,33 @@
+require 'romanesco/expression_tree_builder'
+require 'romanesco/validators/parenthesis_count_validator'
+require 'romanesco/validators/character_validator'
+require 'romanesco/tokeniser'
+
+module Romanesco
+  class Parser
+
+    def parse(raw_expression)
+      validate_expression(raw_expression)
+
+      tokens = Tokeniser.new.tokenise(raw_expression)
+
+      tree_builder = ExpressionTreeBuilder.new
+      tree_builder.build_tree(raw_expression, tokens)
+    end
+
+    private
+
+    def validate_expression(raw_expression)
+      chain = build_chain([Validators::CharacterValidator, Validators::ParenthesisCountValidator])
+      chain.execute(raw_expression)
+    end
+
+    def build_chain(classes)
+      last = nil
+      classes.reverse.each do |klass|
+        last = klass.new(last)
+      end
+      last
+    end
+  end
+end

data/lib/romanesco/state_machine.rb

@@ -0,0 +1,65 @@
+require 'romanesco/token'
+
+module Romanesco
+
+  class ExpressionState
+
+    class << self
+      def next_state(token)
+        state = @states[token.state_machine_class]
+        return state if state
+        raise InvalidExpressionError
+      end
+
+      def finish_here
+        @finishing_state = true
+      end
+
+      def transitions(value)
+        @states = value
+      end
+
+      def transition(tree, tokens)
+        if tokens.empty?
+          return tree if @finishing_state
+          raise InvalidExpressionError
+        end
+        current_token = tokens.shift
+        tree.add(current_token.element.new(current_token.expression_part)) unless current_token.is_a? CloseParenthesisToken
+        tree.close_parenthesis if current_token.is_a? CloseParenthesisToken
+        next_state = next_state(current_token)
+        classify(next_state).transition(tree, tokens)
+      end
+
+      private
+
+      def classify(string)
+        Object.const_get("Romanesco::#{string}")
+      end
+    end
+  end
+
+  class StateZero < ExpressionState
+    transitions( OperandToken => 'StateOne',
+        OpenParenthesisToken => 'StateZero' )
+  end
+
+  class StateOne < ExpressionState
+    transitions( OperatorToken => 'StateTwo',
+      CloseParenthesisToken => 'StateOne' )
+
+    finish_here
+  end
+
+  class StateTwo < ExpressionState
+    transitions( OperandToken => 'StateThree',
+        OpenParenthesisToken => 'StateZero' )
+  end
+
+  class StateThree < ExpressionState
+    transitions( OperatorToken => 'StateTwo',
+      CloseParenthesisToken => 'StateOne' )
+
+    finish_here
+  end
+end

data/lib/romanesco/token.rb

@@ -0,0 +1,90 @@
+require 'romanesco/elements/addition_operator'
+require 'romanesco/elements/subtraction_operator'
+require 'romanesco/elements/multiplication_operator'
+require 'romanesco/elements/division_operator'
+require 'romanesco/elements/parentheses_operator'
+require 'romanesco/elements/variable_operand'
+require 'romanesco/elements/constant_operand'
+
+module Romanesco
+
+  class Token
+
+    attr_accessor :expression_part
+
+    def initialize(string)
+      @expression_part = string
+    end
+
+    def element
+      raise NotImplementedError
+    end
+
+    def state_machine_class
+      self.class
+    end
+  end
+
+  class OperatorToken < Token
+
+    def state_machine_class
+      OperatorToken
+    end
+  end
+
+  class MultiplicationToken < OperatorToken
+    def element
+      MultiplicationOperator
+    end
+  end
+
+  class DivisionToken < OperatorToken
+    def element
+      DivisionOperator
+    end
+  end
+
+  class AdditionToken < OperatorToken
+    def element
+      AdditionOperator
+    end
+  end
+
+  class SubtractionToken < OperatorToken
+    def element
+      SubtractionOperator
+    end
+  end
+
+
+  class OperandToken < Token
+
+    def state_machine_class
+      OperandToken
+    end
+
+  end
+
+  class VariableToken < OperandToken
+    def element
+      VariableOperand
+    end
+  end
+
+  class ConstantToken < OperandToken
+    def element
+      ConstantOperand
+    end
+  end
+
+
+  class OpenParenthesisToken < Token
+    def element
+      ParenthesesOperator
+    end
+  end
+
+  class CloseParenthesisToken < Token
+  end
+
+end

data/lib/romanesco/tokeniser.rb

@@ -0,0 +1,43 @@
+require_relative './token'
+
+module Romanesco
+  class Tokeniser
+
+    TOKEN_TYPES = [
+        {name: 'addition', regex: /^\+/, token_class: AdditionToken},
+        {name: 'multiplication', regex: /^\*/, token_class: MultiplicationToken},
+        {name: 'subtraction', regex: /^\-/, token_class: SubtractionToken},
+        {name: 'division', regex: /^\//, token_class: DivisionToken},
+        {name: 'open parenthesis', regex: /^\(/, token_class: OpenParenthesisToken},
+        {name: 'close parenthesis', regex: /^\)/, token_class: CloseParenthesisToken},
+        {name: 'constant', regex: /^[0-9]*\.?[0-9]+/, token_class: ConstantToken},
+        {name: 'string', regex: /^[a-zA-Z_]+/, token_class: VariableToken}
+    ]
+
+    def tokenise(raw_expression)
+      expression = remove_commas_and_whitespace(raw_expression)
+
+      tokens = []
+
+      while expression.length > 0
+        token_count = tokens.count
+        TOKEN_TYPES.each do |type|
+          if expression =~ type[:regex]
+            token_string = expression.slice!(type[:regex])
+            tokens << type[:token_class].send(:new, token_string)
+          end
+        end
+
+        raise InvalidExpressionError.new("Expression error starting at #{expression}") if tokens.size == token_count
+      end
+
+      tokens
+    end
+
+    private
+
+    def remove_commas_and_whitespace(raw_expression)
+      raw_expression.gsub(/\s+/, '').gsub(',', '')
+    end
+  end
+end

data/lib/romanesco/validators/character_validator.rb

@@ -0,0 +1,18 @@
+require 'romanesco/validators/validator'
+
+module Romanesco
+  module Validators
+    class CharacterValidator < Validator
+
+      def validate(raw_expression)
+        regex = /^[\w\s\-\*\+\/\(\)\.,]*$/
+
+        no_whitespace = raw_expression.gsub(/\s+/, '')
+        raise InvalidExpressionError.new('Empty expression') if raw_expression.nil? || no_whitespace.empty?
+        raise InvalidExpressionError.new('Illegal characters found') unless regex =~ raw_expression
+
+        raw_expression
+      end
+    end
+  end
+end

data/lib/romanesco/validators/parenthesis_count_validator.rb

@@ -0,0 +1,20 @@
+require 'romanesco/validators/validator'
+
+module Romanesco
+  module Validators
+    class ParenthesisCountValidator < Validator
+
+      def validate(raw_expression)
+        open_parenthesis = /(\()/
+        close_parenthesis = /(\))/
+
+        open_parenthesis_count = raw_expression.scan(open_parenthesis).size
+        close_parenthesis_count = raw_expression.scan(close_parenthesis).size
+
+        raise InvalidExpressionError.new('Uneven number of parentheses') unless open_parenthesis_count == close_parenthesis_count
+
+        raw_expression
+      end
+    end
+  end
+end

data/lib/romanesco/validators/validator.rb

@@ -0,0 +1,22 @@
+module Romanesco
+  module Validators
+    class Validator
+
+      attr_accessor :next_step
+
+      def initialize(next_step=nil)
+        @next_step = next_step
+      end
+
+      def execute(object)
+        modified_object = validate(object)
+        return modified_object if next_step.nil?
+        next_step.execute(modified_object)
+      end
+
+      def validate(object)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/romanesco/version.rb

@@ -0,0 +1,3 @@
+module Romanesco
+  VERSION = '0.1.8'
+end

data/lib/romanesco.rb

@@ -0,0 +1,12 @@
+require 'romanesco/version'
+require 'romanesco/parser'
+
+module Romanesco
+  extend self
+
+  def self.parse(raw_expression)
+    parser = Parser.new
+    parser.parse(raw_expression)
+  end
+
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: romanesco
+version: !ruby/object:Gem::Version
+  version: 0.1.8
+platform: ruby
+authors:
+- Charlie Ablett
+- Craig Taube-Schock
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parses simple mathematical expressions, creates a fully object-oriented
+  expression tree. Evaluation can have injected variables.
+email:
+- charlie@enspiral.com
+- craig.schock@enspiral.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/romanesco.rb
+- lib/romanesco/expression_tree.rb
+- lib/romanesco/token.rb
+- lib/romanesco/elements/unary_operator.rb
+- lib/romanesco/elements/addition_operator.rb
+- lib/romanesco/elements/parentheses_operator.rb
+- lib/romanesco/elements/variable_operand.rb
+- lib/romanesco/elements/multiplication_operator.rb
+- lib/romanesco/elements/division_operator.rb
+- lib/romanesco/elements/expression.rb
+- lib/romanesco/elements/subtraction_operator.rb
+- lib/romanesco/elements/operator.rb
+- lib/romanesco/elements/constant_operand.rb
+- lib/romanesco/elements/operand.rb
+- lib/romanesco/elements/binary_operator.rb
+- lib/romanesco/expression_tree_builder.rb
+- lib/romanesco/parser.rb
+- lib/romanesco/tokeniser.rb
+- lib/romanesco/state_machine.rb
+- lib/romanesco/errors.rb
+- lib/romanesco/validators/parenthesis_count_validator.rb
+- lib/romanesco/validators/validator.rb
+- lib/romanesco/validators/character_validator.rb
+- lib/romanesco/version.rb
+- ./LICENSE.txt
+- ./README.md
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Parse math expressions and evaluate with injected variables
+test_files: []