Shunt 0.1

data/lib/shunt/algorithm.rb

@@ -0,0 +1,61 @@
+module Shunt
+
+  def self.convert(infix_expression, context = NumericContext.instance)
+    output, stack = [], []
+    
+    infix_expression.each do |token|
+      if context.opening_bracket == token || context.function?(token)
+        stack << token
+      elsif context.closing_bracket == token
+        until context.opening_bracket == stack.last || stack.empty?
+          output << stack.pop
+        end
+        if context.opening_bracket == stack.last
+          stack.pop
+        else
+          raise ConversionError, "missing %p" % context.opening_bracket
+        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?
+          output << stack.pop
+        end        
+        unless context.opening_bracket == stack.last
+          raise ConversionError, "missing %p or misplaced %p" % [
+            context.opening_bracket, context.function_seperator
+          ]
+        end
+      elsif context.operator?(token)
+        unless stack.empty?
+          until stack.empty?
+            if context.operator?(stack.last) && context.precedence(token) <= context.precedence(stack.last)
+              output << stack.pop
+            else
+              break
+            end
+          end
+        end
+        stack << token
+      else
+        output << token
+      end
+    end
+
+    return output + stack.reverse
+  end
+
+  def self.eval(infix_expression, context = NumericContext.instance)
+    convert(infix_expression, context).inject([]) do |stack, token|
+      if context.operator?(token)
+        context.call_operator(token, stack)
+      elsif context.function?(token)
+        context.call_function(token, stack)
+      else
+        stack << token
+      end
+    end.first
+  end
+
+end

data/lib/shunt/context.rb

@@ -0,0 +1,80 @@
+module Shunt
+  class Context
+
+    include Singleton
+
+    class <<self
+      def opening_bracket(token)
+        @opening_bracket = token
+      end
+      def closing_bracket(token)
+        @closing_bracket = token
+      end
+      def function_seperator(token)
+        @function_seperator = token
+      end
+      def operator(name, equivalent = nil)
+        operators << name
+        operator_equivalents << (equivalent || name)
+      end
+    end
+
+    # Duck-type from here to private
+    
+    def opening_bracket
+      self.class.instance_variable_get('@opening_bracket') || '('
+    end
+
+    def closing_bracket
+      self.class.instance_variable_get('@closing_bracket') || ')'
+    end
+
+    def function_seperator
+      self.class.instance_variable_get('@function_seperator') || ','
+    end
+
+    def operator?(token)
+      self.class.operators.include? token
+    end
+
+    def function?(token)
+      token.is_a?(String) && respond_to?(token)
+    end
+
+    def precedence(operator_token)
+      self.class.operators.size - self.class.operators.index(operator_token)
+    end
+
+    def call_operator(operator_token, stack)
+      stack << stack.delete_at(-2).send(ruby_equivalent_of(operator_token), stack.pop)
+    end
+
+    def call_function(function_token, stack)
+      stack << case arity = method(function_token).arity
+        when 0
+          send function_token
+        when -1                 
+          send function_token, *stack.last!(stack.size)
+        else                    
+          send function_token, *stack.last!(arity)
+      end
+    end
+
+
+    private
+
+    class <<self
+      def operators
+        @operators ||= []
+      end
+      def operator_equivalents
+        @operator_equivalents ||= []
+      end
+    end
+    
+    def ruby_equivalent_of(operator_token)
+      self.class.operator_equivalents[self.class.operators.index(operator_token)]
+    end
+
+  end
+end

data/lib/shunt/numeric.rb

@@ -0,0 +1,31 @@
+module Shunt
+  class NumericContext < Context
+
+    operator '^', :**
+
+    operator '*'
+    
+    operator '/'
+    
+    operator '+'
+    
+    operator '-'
+
+    def abs(number)
+      number.abs
+    end
+
+    def mean(*numbers)
+      numbers.inject { |sum, n| sum + n } / numbers.size
+    end
+
+    def mod(a, b)
+      a % b
+    end
+
+    def pi
+      Math::PI
+    end
+
+  end
+end

data/lib/shunt.rb

@@ -0,0 +1,33 @@
+# Shunt - A Ruby implementation of Dijkstra's Shunting Yard Algorithm.
+#
+# Copyright (c) 2006 Tim Fletcher <twoggle@gmail.com>
+#
+# 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.
+
+require 'singleton'
+require 'shunt/context'
+require 'shunt/numeric'
+require 'shunt/algorithm'
+
+class Array
+  def last!(n = 1); slice!(size - n, n) end
+end
+
+module Shunt
+  class ConversionError < StandardError; end
+end

data/rakefile.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+
+require 'spec'
+require 'spec/rake/spectask'
+
+gemspec = Gem::Specification.new do |s|
+  s.name = 'Shunt'
+  s.version = '0.1'
+  s.summary = "A Ruby implementation of Dijkstra's Shunting Yard Algorithm"
+  s.files = FileList['{lib,spec}/**/*.rb', '*.txt', 'rakefile.rb']
+  s.require_path = 'lib'
+  s.autorequire = 'shunt'
+  s.has_rdoc = false
+  s.rubyforge_project = 'shunt'
+  s.homepage = 'http://shunt.rubyforge.org/'
+  s.author = 'Tim Fletcher'
+  s.email = 'twoggle@gmail.com'
+end
+
+Rake::GemPackageTask.new(gemspec) { |t| t.package_dir = 'gems' }
+
+Spec::Rake::SpecTask.new# { |t| t.spec_opts = ['-f s'] }
+
+task :default => :spec

data/readme.txt

@@ -0,0 +1,61 @@
+= Shunt
+
+A Ruby implementation of Dijkstra's "Shunting Yard Algorithm", for converting
+tokens from infix notation to postfix notation (aka Reverse Polish Notation).
+ 
+Find out more at [Wikipedia](http://en.wikipedia.org/wiki/Reverse_Polish_notation).
+
+== Usage
+
+An expression (array of tokens) can be converted from infix to postfix like so:
+
+  Shunt.convert([3,'+',4,'*',2,'/','(',1,'-',5,')','^',2])  # => [3,4,2,'*',1,5,'-',2,'^','/','+']
+
+The expression can be evaluated (with implicit conversion) like so:
+
+  Shunt.eval([3,'+',4,'*',2,'/','(',1,'-',5,')','^',2])  # => 7/2
+
+Some (not all) invalid expressions can be detected:
+
+  Shunt.eval([1,'+',2,'*',3,')'])  # raises Shunt::ConversionError
+
+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).
+
+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:
+
+    operator '&'
+    
+    # Declare a binary operator, 'or',
+    # with :| as 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:
+
+    def foo; end
+
+    def bar(role); end
+
+    def blah(*roles); end
+    
+  end
+
+This can then be used to evaluate an appropriate expression, e.g.
+
+  permissions = Shunt.eval([User,'&','(',Admin,'or',Moderator,')'], MyContext.instance)
+
+Context's are singletons (remember .instance), and are easily duck-typed.

data/spec/algorithm_spec.rb

@@ -0,0 +1,19 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'shunt'
+require 'mathn'
+
+context 'Algorithm' do
+
+  specify 'should correctly accept Wikipedia example' do
+    expression = [3,'+',4,'*',2,'/','(',1,'-',5,')','^',2]
+    Shunt.convert(expression).should_equal [3,4,2,'*',1,5,'-',2,'^','/','+']
+    Shunt.eval(expression).should_equal 7/2
+  end
+
+  specify 'should correctly fail on invalid expressions' do
+    lambda { Shunt.eval([1,'+',2,'*',3,')']) }.should_raise Shunt::ConversionError
+    lambda { Shunt.eval([1,',',2]) }.should_raise Shunt::ConversionError
+  end
+
+end

data/spec/context_spec.rb

@@ -0,0 +1,72 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'shunt'
+
+context 'A (Shunt) Context' do
+  
+  setup do
+    @class = Class.new(Shunt::Context)
+    @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 ';'
+  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 '['
+  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 ']'
+  end
+  
+  specify 'should allow operators that are also ruby methods' do
+    @instance.operator?('+').should_be false
+    lambda { @class.operator '+' }.should_not_raise
+    @instance.operator?('+').should_be true
+    @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
+    lambda { @class.operator 'plus', :+ }.should_not_raise
+    @instance.operator?('plus').should_be true
+    @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
+    lambda { @class.class_eval { define_method(:ans) { 42 } } }.should_not_raise
+    @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
+    lambda { @class.class_eval { define_method(:inc) { |x| x + 1 } } }.should_not_raise
+    @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
+    lambda { @class.class_eval { define_method(:add) { |one, two| one + two } } }.should_not_raise
+    @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
+    lambda { @class.class_eval { define_method(:min) { |*args| args.min } } }.should_not_raise
+    @instance.call_function('min', [10, 1, 2]).should_equal [1]
+    @instance.function?('min').should_be true
+  end
+
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification 
+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
+summary: A Ruby implementation of Dijkstra's Shunting Yard Algorithm
+require_paths: 
+- lib
+email: twoggle@gmail.com
+homepage: http://shunt.rubyforge.org/
+rubyforge_project: shunt
+description: 
+autorequire: shunt
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Tim Fletcher
+files: 
+- lib/shunt.rb
+- lib/shunt/algorithm.rb
+- lib/shunt/context.rb
+- lib/shunt/numeric.rb
+- spec/algorithm_spec.rb
+- spec/context_spec.rb
+- readme.txt
+- rakefile.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+