Shunt 0.1 → 0.2

data/changes.txt

@@ -0,0 +1,8 @@
+0.2: 11th June 2006
+  - Renamed NumericContext to ArithmeticContext
+  - Added Shunt.calculate
+  - Added Shunt::Context.delegate
+  - Changed the Class-level API e.g. renaming opening_bracket to open_with
+
+0.1: 29th May 2006
+  - Initial release

data/lib/shunt.rb

@@ -21,7 +21,7 @@
 
 require 'singleton'
 require 'shunt/context'
-require 'shunt/numeric'
+require 'shunt/arithmetic'
 require 'shunt/algorithm'
 
 class Array

data/lib/shunt/algorithm.rb

@@ -1,31 +1,29 @@
 module Shunt
 
-  def self.convert(infix_expression, context = NumericContext.instance)
+  def self.convert(infix_expression, context = ArithmeticContext.instance)
     output, stack = [], []
     
     infix_expression.each do |token|
-      if context.opening_bracket == token || context.function?(token)
+      if context.opening?(token) || context.function?(token)
         stack << token
-      elsif context.closing_bracket == token
-        until context.opening_bracket == stack.last || stack.empty?
+      elsif context.closing?(token)
+        until context.opening?(stack.last) || stack.empty?
           output << stack.pop
         end
-        if context.opening_bracket == stack.last
+        if context.opening?(stack.last)
           stack.pop
         else
-          raise ConversionError, "missing %p" % context.opening_bracket
+          raise ConversionError, "missing opening symbol"
         end
         if !stack.empty? && context.function?(stack.last)
           output << stack.pop
         end
-      elsif context.function_seperator == token
-        until context.opening_bracket == stack.last || stack.empty?
+      elsif context.seperating?(token)
+        until context.opening?(stack.last) || stack.empty?
           output << stack.pop
         end        
-        unless context.opening_bracket == stack.last
-          raise ConversionError, "missing %p or misplaced %p" % [
-            context.opening_bracket, context.function_seperator
-          ]
+        unless context.opening?(stack.last)
+          raise ConversionError, "missing opening symbol or misplaced seperating symbol"
         end
       elsif context.operator?(token)
         unless stack.empty?
@@ -46,8 +44,8 @@ module Shunt
     return output + stack.reverse
   end
 
-  def self.eval(infix_expression, context = NumericContext.instance)
-    convert(infix_expression, context).inject([]) do |stack, token|
+  def self.calculate(postfix_expression, context = ArithmeticContext.instance)
+    postfix_expression.inject([]) do |stack, token|
       if context.operator?(token)
         context.call_operator(token, stack)
       elsif context.function?(token)
@@ -57,5 +55,9 @@ module Shunt
       end
     end.first
   end
+  
+  def self.eval(infix_expression, context = ArithmeticContext.instance)
+    calculate convert(infix_expression, context), context
+  end
 
 end

data/lib/shunt/{numeric.rb → arithmetic.rb}

@@ -1,5 +1,5 @@
 module Shunt
-  class NumericContext < Context
+  class ArithmeticContext < Context
 
     operator '^', :**
 

data/lib/shunt/context.rb

@@ -3,34 +3,51 @@ module Shunt
 
     include Singleton
 
+    # Methods for declaring expected expression tokens: #
+    
     class <<self
-      def opening_bracket(token)
-        @opening_bracket = token
+
+      # Declare "opening bracket" tokens.
+      def open_with(*tokens)
+        @openers = tokens
       end
-      def closing_bracket(token)
-        @closing_bracket = token
+
+      # Declare "closing bracket" tokens.
+      def close_with(*tokens)
+        @closers = tokens
       end
-      def function_seperator(token)
-        @function_seperator = token
+
+      # Declare function argument seperator tokens.
+      def seperate_with(*tokens)
+        @seperators = tokens
       end
+
+      # Declare a binary operator token.
       def operator(name, equivalent = nil)
         operators << name
         operator_equivalents << (equivalent || name)
       end
+
+      # Delegate functions to another object (given as last argument).
+      def delegate(*functions)
+        receiver = functions.pop
+        functions.each { |f| delegations[f] = receiver }
+      end
+
     end
 
-    # Duck-type from here to private
+    # Methods used internally by the algorithm (duck-type these): #
     
-    def opening_bracket
-      self.class.instance_variable_get('@opening_bracket') || '('
+    def opening?(token)
+      self.class.openers.include? token
     end
 
-    def closing_bracket
-      self.class.instance_variable_get('@closing_bracket') || ')'
+    def closing?(token)
+      self.class.closers.include? token
     end
 
-    def function_seperator
-      self.class.instance_variable_get('@function_seperator') || ','
+    def seperating?(token)
+      self.class.seperators.include? token
     end
 
     def operator?(token)
@@ -38,25 +55,30 @@ module Shunt
     end
 
     def function?(token)
-      token.is_a?(String) && respond_to?(token)
+      unless token.is_a?(String) || token.is_a?(Symbol)
+        return false
+      end
+      respond_to?(token) || self.class.delegations.has_key?(token)
     end
 
-    def precedence(operator_token)
-      self.class.operators.size - self.class.operators.index(operator_token)
+    def precedence(token)
+      self.class.operators.size - self.class.operators.index(token)
     end
 
-    def call_operator(operator_token, stack)
-      stack << stack.delete_at(-2).send(ruby_equivalent_of(operator_token), stack.pop)
+    def call_operator(token, stack)
+      stack << stack.delete_at(-2).send(ruby_equivalent_of(token), stack.pop)
     end
 
-    def call_function(function_token, stack)
-      stack << case arity = method(function_token).arity
+    def call_function(token, stack)
+      receiver = self.class.delegations[token] || self
+
+      stack << case arity = receiver.method(token).arity
         when 0
-          send function_token
+          receiver.send token
         when -1                 
-          send function_token, *stack.last!(stack.size)
+          receiver.send token, *stack.last!(stack.size)
         else                    
-          send function_token, *stack.last!(arity)
+          receiver.send token, *stack.last!(arity)
       end
     end
 
@@ -64,12 +86,24 @@ module Shunt
     private
 
     class <<self
+      def openers
+        @openers ||= ['(']
+      end
+      def closers
+        @closers ||= [')']
+      end
+      def seperators
+        @seperators ||= [',']
+      end
       def operators
         @operators ||= []
       end
       def operator_equivalents
         @operator_equivalents ||= []
       end
+      def delegations
+        @delegations ||= {}
+      end
     end
     
     def ruby_equivalent_of(operator_token)

data/rakefile.rb

@@ -9,7 +9,7 @@ require 'spec/rake/spectask'
 
 gemspec = Gem::Specification.new do |s|
   s.name = 'Shunt'
-  s.version = '0.1'
+  s.version = '0.2'
   s.summary = "A Ruby implementation of Dijkstra's Shunting Yard Algorithm"
   s.files = FileList['{lib,spec}/**/*.rb', '*.txt', 'rakefile.rb']
   s.require_path = 'lib'

data/readme.txt

@@ -23,28 +23,23 @@ Remember to require 'mathn' if you want precise answers.
 
 == Contexts
 
-The default context (used in the examples above) is numeric i.e. it expects an
-array of Numeric objects, brackets/parentheses (as Strings), binary operators
-(as Strings), and function symbols (as Strings or Symbols).
+The default context (used in the examples above) is arithmetic i.e. it expects an
+array of Numeric objects, brackets/parentheses, function symbols and binary operators.
 
 Other contexts can be defined by subclassing Shunt::Context, e.g.
 
   class MyContext < Shunt::Context
   
-    # Declare a binary operator, '&',
-    # with a natural equivalent Ruby method:
+    # Declare binary operators:
 
-    operator '&'
+    operator '&' # assumes equivalent method in Ruby
     
-    # Declare a binary operator, 'or',
-    # with :| as the equivalent Ruby method:
+    operator 'or', :| # explicitly specifies the equivalent Ruby method
 
-    operator 'or', :|
-    
     # Operators are given precedence in the order that they are declared,
     # so in this example '&' has higher precedence than 'or'.
 
-    # Functions can be defined, as ordinary Ruby methods:
+    # Declare functions as ordinary Ruby methods:
 
     def foo; end
 
@@ -52,9 +47,13 @@ Other contexts can be defined by subclassing Shunt::Context, e.g.
 
     def blah(*roles); end
     
+    # Delegate functions to other objects:
+    
+    delegate 'sin', 'cos', 'tan', Math
+    
   end
 
-This can then be used to evaluate an appropriate expression, e.g.
+This context can then be used to evaluate appropriate expressions, e.g.
 
   permissions = Shunt.eval([User,'&','(',Admin,'or',Moderator,')'], MyContext.instance)
 

data/spec/context_spec.rb

@@ -9,64 +9,74 @@ context 'A (Shunt) Context' do
     @instance = @class.instance
   end
   
-  specify 'should allow overriding of function_seperator' do
-    @instance.function_seperator.should_equal ','
-    lambda { @class.function_seperator ';' }.should_not_raise
-    @instance.function_seperator.should_equal ';'
+  specify 'should allow alternative function seperators' do
+    @instance.should_be_seperating(',')
+    lambda { @class.seperate_with ';' }.should_not_raise
+    @instance.should_not_be_seperating(',')
+    @instance.should_be_seperating(';')
   end
     
-  specify 'should allow overriding of opening_bracket' do
-    @instance.opening_bracket.should_equal '('
-    lambda { @class.opening_bracket '[' }.should_not_raise
-    @instance.opening_bracket.should_equal '['
+  specify 'should allow alternative opening symbols' do
+    @instance.should_be_opening('(')
+    lambda { @class.open_with '[' }.should_not_raise
+    @instance.should_not_be_opening('(')
+    @instance.should_be_opening('[')
   end
   
-  specify 'should allow overriding of closing_bracket' do
-    @instance.closing_bracket.should_equal ')'
-    lambda { @class.closing_bracket ']' }.should_not_raise
-    @instance.closing_bracket.should_equal ']'
+  specify 'should allow alternative closing symbols' do
+    @instance.should_be_closing(')')
+    lambda { @class.close_with ']' }.should_not_raise
+    @instance.should_not_be_closing(')')
+    @instance.should_be_closing(']')
   end
   
   specify 'should allow operators that are also ruby methods' do
-    @instance.operator?('+').should_be false
+    @instance.should_not_be_operator('+')
     lambda { @class.operator '+' }.should_not_raise
-    @instance.operator?('+').should_be true
+    @instance.should_be_operator('+')
     @instance.call_operator('+', [1, 2]).should_equal [3]
   end
 
   specify 'should allow operators that are aliases of ruby methods' do
-    @instance.operator?('plus').should_be false
+    @instance.should_not_be_operator('plus')
     lambda { @class.operator 'plus', :+ }.should_not_raise
-    @instance.operator?('plus').should_be true
+    @instance.should_be_operator('plus')
     @instance.call_operator('plus', [1, 2]).should_equal [3]
   end
 
   specify 'should allow definition and call of a function with arity 0' do
-    @instance.function?('ans').should_be false
+    @instance.should_not_be_function('ans')
     lambda { @class.class_eval { define_method(:ans) { 42 } } }.should_not_raise
+    @instance.should_be_function('ans')
     @instance.call_function('ans', []).should_equal [42]
-    @instance.function?('ans').should_be true
   end
 
   specify 'should allow definition and call of a function with arity 1' do
-    @instance.function?('inc').should_be false
+    @instance.should_not_be_function('inc')
     lambda { @class.class_eval { define_method(:inc) { |x| x + 1 } } }.should_not_raise
+    @instance.should_be_function('inc')
     @instance.call_function('inc', [0]).should_equal [1]
-    @instance.function?('inc').should_be true
   end
 
   specify 'should allow definition and call of a function with arity 2' do
-    @instance.function?('add').should_be false
+    @instance.should_not_be_function('add')
     lambda { @class.class_eval { define_method(:add) { |one, two| one + two } } }.should_not_raise
+    @instance.should_be_function('add')
     @instance.call_function('add', [1, 2]).should_equal [3]
-    @instance.function?('add').should_be true
   end
 
   specify 'should allow definition and call of a function with arity -1' do
-    @instance.function?('min').should_be false
+    @instance.should_not_be_function('min')
     lambda { @class.class_eval { define_method(:min) { |*args| args.min } } }.should_not_raise
+    @instance.should_be_function('min')
     @instance.call_function('min', [10, 1, 2]).should_equal [1]
-    @instance.function?('min').should_be true
+  end
+
+  specify 'should allow delegation of functions to other objects' do
+    @instance.should_not_be_function('sin')
+    lambda { @class.class_eval { delegate 'sin', Math } }.should_not_raise
+    @instance.should_be_function('sin')
+    @instance.call_function('sin', [Math::PI / 2]).should_equal [1]
   end
 
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: Shunt
 version: !ruby/object:Gem::Version 
-  version: "0.1"
-date: 2006-05-29 00:00:00 +01:00
+  version: "0.2"
+date: 2006-06-11 00:00:00 +01:00
 summary: A Ruby implementation of Dijkstra's Shunting Yard Algorithm
 require_paths: 
 - lib
@@ -30,10 +30,11 @@ authors:
 files: 
 - lib/shunt.rb
 - lib/shunt/algorithm.rb
+- lib/shunt/arithmetic.rb
 - lib/shunt/context.rb
-- lib/shunt/numeric.rb
 - spec/algorithm_spec.rb
 - spec/context_spec.rb
+- changes.txt
 - readme.txt
 - rakefile.rb
 test_files: []