shunting_yard 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 825936faa9f1c872f460b25d5e988e418abe6b98a2bd167af2c83fe13b25bf03
+  data.tar.gz: 2c91cb879600cc2dc260475ae03d3f1d763d0173f77a9060f43f1dd7609a9029
+SHA512:
+  metadata.gz: d4484b313d0106bb9279290fab1f86413701a673d0e4d2f43521f8f1cb95bb5fb62feb773f1d6e2abc921fc0711939ebca3ae8b9e6f2225c0cbdfe4d9114c504
+  data.tar.gz: ad729d6a29a484d3c3c77ba36e9080a3bf90c7f64d4ef8c021112d7817efd3732f0ce7d264431187ea73528b5f035d3820962d3f50867575043febea69fc7743

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+.byebug_history
+.vscode

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in shunting_yard.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: .
+  specs:
+    shunting_yard (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.1.3)
+    coderay (1.1.2)
+    debase (0.2.4.1)
+      debase-ruby_core_source (>= 0.10.2)
+    debase-ruby_core_source (0.10.9)
+    diff-lcs (1.3)
+    method_source (1.0.0)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
+      byebug (~> 11.0)
+      pry (~> 0.13.0)
+    rake (12.3.2)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    ruby-debug-ide (0.7.2)
+      rake (>= 0.8.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  debase
+  pry
+  pry-byebug
+  rake (~> 12.0)
+  rspec (~> 3.0)
+  ruby-debug-ide
+  shunting_yard!
+
+BUNDLED WITH
+   2.1.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Artem Rashev
+
+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,147 @@
+# ShuntingYard
+
+## TL;DR Usage
+
+```ruby
+parser = ShuntingYard::Parser.new
+
+parser.add_pattern :space, /\s+/, -> (_) { nil }
+parser.add_pattern :argument_separator, /\,/
+parser.add_pattern :operator, /[\+\-\*\/\^]/
+parser.add_pattern :parenthesis, /[\(\)]/
+parser.add_pattern :function, /(?:min|max)/
+parser.add_pattern :operand, /d+/, -> (lexeme) { Integer(lexeme) }
+
+parser.add_operator "+", 0, :left, -> (left, right) { left + right }
+parser.add_operator "-", 0, :left, -> (left, right) { left - right }
+parser.add_operator "*", 1, :left, -> (left, right) { left * right }
+parser.add_operator "/", 1, :left, -> (left, right) { left / right }
+parser.add_operator "^", 2, :right, -> (left, right) { left ** right }
+
+parser.add_function "min", -> (left, right) { [left, right].min }
+parser.add_function "max", -> (left, right) { [left, right].max }
+
+input = "min(max(3, 4 / 2) * 2 ^ 3, 25)"
+
+parser.to_rpn(input).to_s #=> 3 4 2 / max 2 3 ^ * 25 min
+parser.evaluate(input) #=> 24
+```
+
+## Lexer
+
+`ShuntingYard::Lexer` is responsible for splitting source string into tokens.
+To recognize each possible token it needs to know corresponding patterns represented as regular expressions.
+
+If substring is matched to multiple patterns, **the longest match** wil be used.
+
+After matching a token, its lexeme is evaluated with provided function. If function is not provided - it returns the lexeme itself.
+
+Tokens values evaluated to `nil` will not be included into output sequence.
+
+```ruby
+lexer = ShuntingYard::Lexer.new
+
+lexer.add_pattern :operator, /\+/
+lexer.add_pattern :space, /\s+/, -> (_) { nil }
+lexer.add_pattern :operand, /\d+/, -> (lexeme) { Integer(lexeme) }
+
+puts lexer.tokenize("3 + 5").inspect
+```
+
+```
+[
+  #<struct ShuntingYard::Token name=:operand, lexeme="3", value=3>,
+  #<struct ShuntingYard::Token name=:operator, lexeme="+", value="+">,
+  #<struct ShuntingYard::Token name=:operand, lexeme="5", value=5>
+]
+```
+
+First argument in `#add_pattern` is a token name. It can have any value since `Lexer` doesn't make assumptions about names.
+
+## Interpterer
+
+Once we have token list, it needs to be converted to [Revese Polish Notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation) before evalutation and here Shunting Yard algorithm comes in.
+
+```ruby
+...
+
+interpreter = ShuntingYard::Interpreter.new
+interpreter.add_operator "+", 0, :left, -> (left, right) { left + right }
+
+tokens = lexer.tokenize("3 + 5")
+puts interpreter.to_rpn(tokens).inspect
+```
+
+```
+[
+  #<struct ShuntingYard::Operand value=3>,
+  #<struct ShuntingYard::Operand value=5>,
+  #<struct ShuntingYard::Operator value="+", precedence=0, associativity=:left, evaluator=#<Proc:...>>
+]
+```
+
+Interpreter defines **strict names list that are accepted in tokens**:
+
+* `:operand` - arbitrary value, passed as argument operators and functions
+* `:parenthesis` - currently interpreter accepts only "(" and ")" parentheses
+* `:operator` - token value must match to one of registered in interpreter operators
+* `:function` - token value must match to one of registered in interpreter functions
+* `:argument_separator` - pattern that defines argument separation in functions (usually comma)
+
+All other token types will not be recognized and interpreter throws `ShuntingYard::UnknownTokenError`.
+
+### Registering functions
+
+`#add_function(name, evaluator)`
+
+* `name` - function name that must match to corresponding token value
+* `evaluator` - a function that accepts fixed number of arguments and returns single value
+
+### Registering operations
+
+`#add_operator(name, precedence, associativity, evaluator)`
+
+* `name` - function name that must match to corresponding token value
+* `precedence` - operator precedence, can be any integer value
+* `associativity` - [operator associativity](https://en.wikipedia.org/wiki/Operator_associativity), can be either `:left` or `:right`
+* `evaluator` - a function that accepts fixed number of arguments and returns single value
+
+
+### Evaluators
+
+Evaluators for operators and functions can be defined as `proc` or `lambda` with at least one argument.
+**Default arguments are not allowed** because interpreter uses `#arity` method to get number of operands required by function / operator.
+
+```ruby
+# Expected format
+interpreter.add_operator "%", 0, :left, -> (left, right) { left % right }
+interpreter.add_operator "~", 0, :left, proc { |left, right| left % right }
+
+# Will not work
+interpreter.add_operator "%", 0, :left, -> (left, right = 5) { left % right }
+interpreter.add_function "max", -> (*args) { args.max }
+```
+
+## Parser
+
+`ShuntingYard::Parser` is a proxy class for Lexer and Interpreter.
+
+When you need to recognize and evaluate an expression in one go, Parser object is a single entry point for all actions.
+
+```ruby
+parser = ShuntingYard::Parser.new
+
+# Add patterns to parser's lexer
+parser.add_pattern :space, /\s+/, -> (_) { nil }
+parser.add_pattern :operator, /[\+\-]/
+parser.add_pattern :operand, /d+/, -> (lexeme) { Integer(lexeme) }
+
+# Add operators to parser's interpreter
+parser.add_operator "+", 0, :left, -> (left, right) { left + right }
+parser.add_operator "-", 0, :left, -> (left, right) { left - right }
+
+input = "5 + 3 - 2"
+
+# Tokenize, convert to RPN and evaluate the expression
+parser.evaluate(input) #=> 6
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/shunting_yard.rb

@@ -0,0 +1,10 @@
+require "shunting_yard/structs"
+require "shunting_yard/errors"
+require "shunting_yard/reverse_polish_notation"
+require "shunting_yard/interpreter"
+require "shunting_yard/lexer"
+require "shunting_yard/parser"
+require "shunting_yard/version"
+
+module ShuntingYard
+end

data/lib/shunting_yard/errors.rb

@@ -0,0 +1,45 @@
+module ShuntingYard
+  class Error < StandardError; end
+
+  class InvalidArgumentsCountError < Error
+    def initialize
+      super "Invalid arguments count passed to one of functions or operators"
+    end
+  end
+
+  class MismatchedParenthesesError < Error
+    def initialize
+      super "Mismatched parentheses"
+    end
+  end
+
+  class UnknownTokenError < Error
+    def initialize(token, position)
+      super "Unknown token '#{token}' at position #{position}"
+    end
+  end
+
+  class UnknownOperatorError < Error
+    def initialize(token)
+      super "Unknown operator '#{token.lexeme}'"
+    end
+  end
+
+  class UnknownFunctionError < Error
+    def initialize(token)
+      super "Unknown function '#{token}'"
+    end
+  end
+
+  class UnknownParenthesisError < Error
+    def initialize(token)
+      super "Token '#{token}' is not a parenthesis"
+    end
+  end
+
+  class UnknownTokenTypeError < Error
+    def initialize(name)
+      super "Token '#{name}' is not defined"
+    end
+  end
+end

data/lib/shunting_yard/interpreter.rb

@@ -0,0 +1,132 @@
+module ShuntingYard
+  class Interpreter
+    attr_accessor :functions
+    attr_accessor :operators
+
+    def initialize
+      @functions = []
+      @operators = []
+    end
+
+    def add_function(*args)
+      functions << Function.new(*args)
+    end
+
+    def add_operator(*args)
+      operators << Operator.new(*args)
+    end
+
+    def to_rpn(source_tokens)
+      tokens = source_tokens.dup
+      output = ReversePolishNotation.new
+      op_stack = []
+
+      while tokens.any?
+        current = match_token(tokens.shift)
+
+        case current
+        when ArgumentSeparator
+          while op_stack.any? &&
+                op_stack.last.class != Parenthesis
+            output << op_stack.pop
+          end
+        when Function
+          op_stack << current
+        when Parenthesis
+          case current.side
+          when :left
+            op_stack << current
+          when :right
+            while op_stack.last.class != Parenthesis
+              raise MismatchedParenthesesError if op_stack.empty?
+
+              output << op_stack.pop
+            end
+
+            op_stack.pop
+          end
+        when Operand
+          output << current
+        when Operator
+          while op_stack.any? &&
+                op_stack.last.class != Parenthesis &&
+                (op_stack.last.class == Function ||
+                  op_stack.last.precedence > current.precedence ||
+                  op_stack.last.precedence == current.precedence && current.associativity == :left)
+            output << op_stack.pop
+          end
+
+          op_stack << current
+        end
+      end
+
+      while op_stack.any?
+        current = op_stack.pop
+        raise MismatchedParenthesesError if current.class == Parenthesis
+
+        output << current
+      end
+
+      output
+    end
+
+    def evaluate(rpn_tokens)
+      rpn = rpn_tokens.dup
+      stack = []
+
+      while rpn.any?
+        current = rpn.shift
+
+        case current
+        when Function, Operator
+          arity = current.evaluator.arity
+          raise InvalidArgumentsCountError if stack.size < arity
+
+          operands = stack.pop(arity)
+          stack << current.evaluator.(*operands)
+        when Operand
+          stack << current.value
+        end
+      end
+
+      raise InvalidArgumentsCountError if stack.size > 1
+
+      stack[0]
+    end
+
+    private
+
+    def match_token(token)
+      matched =
+        case token.name
+        when :argument_separator
+          ArgumentSeparator.new(token.value)
+        when :function
+          function = functions.find { |f| f.value == token.value }
+          raise UnknownFunctionError, token.lexeme unless function
+
+          function
+        when :parenthesis
+          case token.value
+          when "("
+            Parenthesis.new(:left)
+          when ")"
+            Parenthesis.new(:right)
+          else
+            raise UnknownParenthesisError, token.lexeme
+          end
+        when :operand
+          Operand.new(token.value)
+        when :operator
+          operator = operators.find { |op| binding.pry if op.kind_of?(Array); op.value == token.value }
+          raise UnknownOperatorError, token unless operator
+
+          operator
+        else
+          raise UnknownTokenTypeError, token.name
+        end
+
+      matched
+    end
+  end
+end

data/lib/shunting_yard/lexer.rb

@@ -0,0 +1,58 @@
+require "strscan"
+
+module ShuntingYard
+  class Lexer
+    SPACE_OR_EOL = /(\s|$)/.freeze
+
+    attr_accessor :patterns
+    attr_accessor :separator_pattern
+
+    def initialize
+      @patterns = []
+      @separator_pattern = SPACE_OR_EOL
+    end
+
+    def add_pattern(name, regex, evaluator = -> (lexeme) { lexeme })
+      @patterns << [name, regex, evaluator]
+    end
+
+    def tokenize(input)
+      sc = StringScanner.new(input)
+      matches = []
+
+      until sc.eos?
+        match = nil
+        last_match = nil
+        longest_match_size = 0
+
+        @patterns.each do |name, regex, evaluator|
+          match = sc.check(regex)
+          next if match.nil?
+
+          longest_match_size = [longest_match_size, match.size].max
+
+          value = evaluator.(match)
+          next if value.nil?
+
+          last_match = [name, match, value] if last_match.nil? || last_match[1].size < match.size
+        end
+
+        if longest_match_size == 0
+          unknown_token = sc.check_until(separator_pattern).sub(separator_pattern, "")
+          raise UnknownTokenError.new(unknown_token, sc.pos + 1)
+        end
+
+        sc.pos += longest_match_size
+        matches << build_token(last_match) unless last_match.nil?
+      end
+
+      matches
+    end
+
+    private
+
+    def build_token(args)
+      Token.new(*args)
+    end
+  end
+end

data/lib/shunting_yard/parser.rb

@@ -0,0 +1,28 @@
+require "forwardable"
+
+module ShuntingYard
+  class Parser
+    extend Forwardable
+
+    attr_accessor :lexer
+    attr_accessor :interpreter
+
+    def initialize(lexer: nil, interpreter: nil)
+      @lexer = lexer || Lexer.new
+      @interpreter = interpreter || Interpreter.new
+    end
+
+    def_delegators :@lexer, :add_pattern, :separator_pattern, :separator_pattern=, :tokenize
+    def_delegators :@interpreter, :add_function, :add_operator
+
+    def evaluate(input)
+      rpn_tokens = to_rpn(input)
+      interpreter.evaluate(rpn_tokens)
+    end
+
+    def to_rpn(input)
+      tokens = tokenize(input)
+      interpreter.to_rpn(tokens)
+    end
+  end
+end

data/lib/shunting_yard/reverse_polish_notation.rb

@@ -0,0 +1,7 @@
+module ShuntingYard
+  class ReversePolishNotation < Array
+    def to_s
+      self.map(&:value).join(" ")
+    end
+  end
+end

data/lib/shunting_yard/structs.rb

@@ -0,0 +1,10 @@
+module ShuntingYard
+  Token = Struct.new(:name, :lexeme, :value)
+
+  # Matched tokens
+  ArgumentSeparator = Struct.new(:value)
+  Function = Struct.new(:value, :evaluator)
+  Operand = Struct.new(:value)
+  Operator = Struct.new(:value, :precedence, :associativity, :evaluator)
+  Parenthesis = Struct.new(:side)
+end

data/lib/shunting_yard/version.rb

@@ -0,0 +1,3 @@
+module ShuntingYard
+  VERSION = "0.1.0"
+end

data/shunting_yard.gemspec

@@ -0,0 +1,34 @@
+require_relative 'lib/shunting_yard/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "shunting_yard"
+  spec.version       = ShuntingYard::VERSION
+  spec.authors       = ["Donkey Kong"]
+  spec.email         = ["584951-highaf@users.noreply.gitlab.com"]
+
+  spec.summary       = "ShuntingYard algorithm implementation"
+  spec.description   = ""
+  spec.homepage      = "https://gitlab.com/hodlhodl-public/shunting_yard"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://gitlab.com/hodlhodl-public/shunting_yard"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "debase"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "ruby-debug-ide"
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: shunting_yard
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Donkey Kong
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debase
+  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: pry
+  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: pry-byebug
+  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: ruby-debug-ide
+  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: ''
+email:
+- 584951-highaf@users.noreply.gitlab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/shunting_yard.rb
+- lib/shunting_yard/errors.rb
+- lib/shunting_yard/interpreter.rb
+- lib/shunting_yard/lexer.rb
+- lib/shunting_yard/parser.rb
+- lib/shunting_yard/reverse_polish_notation.rb
+- lib/shunting_yard/structs.rb
+- lib/shunting_yard/version.rb
+- shunting_yard.gemspec
+homepage: https://gitlab.com/hodlhodl-public/shunting_yard
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://gitlab.com/hodlhodl-public/shunting_yard
+  source_code_uri: https://gitlab.com/hodlhodl-public/shunting_yard
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: ShuntingYard algorithm implementation
+test_files: []