rpn-calculator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 63cc0de9b3942ee248de5064c5085419751f6276
+  data.tar.gz: cee536cb6a8babe8603382a12830d7e2793283ca
+SHA512:
+  metadata.gz: f6a86512842f45dab14b521cb701f3dc2d2d288f5d2a03dbd779611e6e12fbd20ce6d62b3acb9fc0ece527a01f9873d4647b532b7cbce2e18a4d3c89b8798048
+  data.tar.gz: 80affa700d36acd2a6fd0782c94a86d0d6a412e39199a6392e4b653141c27e2663e5d50fe6cd132bcc3750c0d5c45b2d18bacf469dbe9a5100161059ee92b61f

data/bin/calculator

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rpn-calculator'
+
+RPNCalculator.start

data/lib/rpn-calculator/input/parser.rb

@@ -0,0 +1,57 @@
+module RPNCalculator
+  module Input
+    class Parser
+      def initialize(allowed_operators)
+        @allowed_operators = allowed_operators
+      end
+
+      def parse(input_string)
+        parsed_input = input_without_whitespace(
+          join_consecutive_numbers(input_string.split(''))
+        )
+        invalid_elements = parsed_input_errors(parsed_input)
+        Result::Parser.new(parsed_input, invalid_elements)
+      end
+
+      private
+
+      attr_reader :allowed_operators
+
+      def input_without_whitespace(split_string)
+        split_string.select { |e| e!= ' ' }
+      end
+
+      def parsed_input_errors(parsed_input)
+        parsed_input.inject([]) do |result, element|
+          result << element unless allowed_operators.include?(element) || is_number?(element)
+          result
+        end
+      end
+
+      def join_consecutive_numbers(split_string)
+        split_string.each_with_index.inject([]) do |result, (element, index)|
+          if index == 0 || any_operator?([split_string[index - 1], element])
+            result << element
+          else
+            result[-1] += element
+          end
+          result
+        end
+      end
+
+      def any_operator?(elements)
+        elements.any? { |e| !is_number_or_period?(e) }
+      end
+
+      def is_number_or_period?(number_string)
+        number_string == '.' || is_number?(number_string)
+      end
+
+      def is_number?(number_string)
+        true if Float(number_string)
+      rescue ArgumentError
+        false
+      end
+    end
+  end
+end

data/lib/rpn-calculator/input/validator.rb

@@ -0,0 +1,18 @@
+module RPNCalculator
+  module Input
+    class Validator
+      def initialize(invalid_arguments_regex)
+        @invalid_arguments_regex = invalid_arguments_regex
+      end
+
+      def validate(input_string)
+        invalid_characters = input_string.scan(invalid_arguments_regex)
+        Result::Validator.new(invalid_characters)
+      end
+
+      private
+
+      attr_reader :invalid_arguments_regex
+    end
+  end
+end

data/lib/rpn-calculator/io_interface/abstract.rb

@@ -0,0 +1,13 @@
+module RPNCalculator
+  module IoInterface
+    class Abstract
+      def read_input
+        raise 'Must implement in subclass'
+      end
+
+      def display_output
+        raise 'Must implement in subclass'
+      end
+    end
+  end
+end

data/lib/rpn-calculator/io_interface/standard.rb

@@ -0,0 +1,15 @@
+module RPNCalculator
+  module IoInterface
+    class Standard < Abstract
+      def read_input
+        print '> '
+        input = STDIN.gets
+        input.chomp unless input.nil? || input == "q\n"
+      end
+
+      def display_output(result)
+        puts result
+      end
+    end
+  end
+end

data/lib/rpn-calculator/io_processor.rb

@@ -0,0 +1,29 @@
+module RPNCalculator
+  class IoProcessor
+    def initialize(io_interface, operation_processor)
+      @io_interface = io_interface
+      @input_stack  = []
+      @operation_processor = operation_processor
+    end
+
+    def start
+      while (input = io_interface.read_input)
+        processor_result = operation_processor.process(input_stack, input)
+        if processor_result.valid?
+          print_result_array(processor_result.result)
+          @input_stack = processor_result.result
+        else
+          io_interface.display_output(processor_result.error)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :io_interface, :operation_processor, :input_stack
+
+    def print_result_array(result)
+      io_interface.display_output(result.join(' '))
+    end
+  end
+end

data/lib/rpn-calculator/operation/addition.rb

@@ -0,0 +1,19 @@
+require 'rpn-calculator/operation/base'
+
+module RPNCalculator
+  module Operation
+    class Addition < Base
+      def result
+        return invalid_operation_result(operation_string) unless valid?
+
+        Result::Operation.new(operation_string, float_operands.reduce(&:+))
+      end
+
+      private
+
+      def operation_string
+        '+'
+      end
+    end
+  end
+end

data/lib/rpn-calculator/operation/base.rb

@@ -0,0 +1,29 @@
+module RPNCalculator
+  module Operation
+    class Base
+      def initialize(operands)
+        @operands = operands
+      end
+
+      def result
+        raise 'must implement in subclass'
+      end
+
+      private
+
+      attr_reader :operands
+
+      def valid?
+        operands.size == 2
+      end
+
+      def float_operands
+        operands.map { |operator| Float(operator) }
+      end
+
+      def invalid_operation_result(operation)
+        Result::Operation.new(operation, [], operands)
+      end
+    end
+  end
+end

data/lib/rpn-calculator/operation/division.rb

@@ -0,0 +1,19 @@
+require 'rpn-calculator/operation/base'
+
+module RPNCalculator
+  module Operation
+    class Division < Base
+      def result
+        return invalid_operation_result(operation_string) unless valid?
+
+        Result::Operation.new(operation_string, float_operands.reduce(&:/))
+      end
+
+      private
+
+      def operation_string
+        '/'
+      end
+    end
+  end
+end

data/lib/rpn-calculator/operation/multiplication.rb

@@ -0,0 +1,19 @@
+require 'rpn-calculator/operation/base'
+
+module RPNCalculator
+  module Operation
+    class Multiplication < Base
+      def result
+        return invalid_operation_result(operation_string) unless valid?
+
+        Result::Operation.new(operation_string, float_operands.reduce(&:*))
+      end
+
+      private
+
+      def operation_string
+        '*'
+      end
+    end
+  end
+end

data/lib/rpn-calculator/operation/subtraction.rb

@@ -0,0 +1,19 @@
+require 'rpn-calculator/operation/base'
+
+module RPNCalculator
+  module Operation
+    class Subtraction < Base
+      def result
+        return invalid_operation_result(operation_string) unless valid?
+
+        Result::Operation.new(operation_string, float_operands.reduce(&:-))
+      end
+
+      private
+
+      def operation_string
+        '-'
+      end
+    end
+  end
+end

data/lib/rpn-calculator/operation_processor.rb

@@ -0,0 +1,43 @@
+module RPNCalculator
+  class OperationProcessor
+    def initialize(operation_classes, input_validator, input_parser)
+      @input_validator   = input_validator
+      @input_parser      = input_parser
+      @operation_classes = operation_classes
+      @operation_symbols = @operation_classes.keys
+    end
+
+    def process(previous_operations, input)
+      validator_result = input_validator.validate(input)
+      return Result::Processor.new([], validator_result.error) unless validator_result.valid?
+
+      parser_result = input_parser.parse(input)
+      return Result::Processor.new([], parser_result.error) unless parser_result.valid?
+      process_operations(previous_operations + parser_result.parsed_elements)
+    end
+
+    private
+
+    attr_reader :input_validator, :input_parser, :operation_classes, :operation_symbols
+
+    def process_operations(operations)
+      operation_stack = []
+      while operations.size > 0
+        element = operations.shift
+        if operation_symbols.include?(element)
+          result = operation_classes.fetch(element).new(operation_stack).result
+          return invalid_processor_result(result) unless result.valid?
+
+          operation_stack = [result.result]
+        else
+          operation_stack.push(element)
+        end
+      end
+      Result::Processor.new(operation_stack)
+    end
+
+    def invalid_processor_result(result)
+      Result::Processor.new([], result.error)
+    end
+  end
+end

data/lib/rpn-calculator/result/operation.rb

@@ -0,0 +1,29 @@
+module RPNCalculator
+  module Result
+    class Operation
+      def initialize(operation, result, invalid_operation_elements = [])
+        @operation                  = operation
+        @result                     = result
+        @invalid_operation_elements = invalid_operation_elements
+      end
+
+      def valid?
+        invalid_operation_elements.empty?
+      end
+
+      def error
+        "Invalid operation: #{invalid_operation}" unless valid?
+      end
+
+      attr_reader :result
+
+      private
+
+      attr_reader :invalid_operation_elements, :operation
+
+      def invalid_operation
+        invalid_operation_elements.join(' ') + " #{operation}"
+      end
+    end
+  end
+end

data/lib/rpn-calculator/result/parser.rb

@@ -0,0 +1,26 @@
+module RPNCalculator
+  module Result
+    class Parser
+      def initialize(parsed_elements = [], invalid_elements = [])
+        @parsed_elements  = parsed_elements
+        @invalid_elements = invalid_elements
+      end
+
+      def valid?
+        invalid_elements.empty?
+      end
+
+      def error
+        "Invalid operators or numbers: #{invalid_element_list}" unless valid?
+      end
+
+      attr_reader :parsed_elements, :invalid_elements
+
+      private
+
+      def invalid_element_list
+        invalid_elements.join(', ')
+      end
+    end
+  end
+end

data/lib/rpn-calculator/result/processor.rb

@@ -0,0 +1,16 @@
+module RPNCalculator
+  module Result
+    class Processor
+      def initialize(result = [], error = nil)
+        @result = result
+        @error  = error
+      end
+
+      def valid?
+        error.nil?
+      end
+
+      attr_reader :result, :error
+    end
+  end
+end

data/lib/rpn-calculator/result/validator.rb

@@ -0,0 +1,25 @@
+module RPNCalculator
+  module Result
+    class Validator
+      def initialize(invalid_characters = [])
+        @invalid_characters = invalid_characters
+      end
+
+      def valid?
+        invalid_characters.empty?
+      end
+
+      def error
+        "Invalid characters: #{invalid_character_list}" unless valid?
+      end
+
+      private
+
+      attr_reader :invalid_characters
+
+      def invalid_character_list
+        invalid_characters.join(', ')
+      end
+    end
+  end
+end

data/lib/rpn-calculator/version.rb

@@ -0,0 +1,3 @@
+module RPNCalculator
+  VERSION = '0.1.0'.freeze
+end

data/lib/rpn-calculator.rb

@@ -0,0 +1,29 @@
+Dir.glob('lib/**/*.rb').each do |file|
+  require file.gsub('lib/', '').gsub('.rb', '')
+end
+
+module RPNCalculator
+  OPERATION_CLASSES = {
+    '+' => Operation::Addition,
+    '-' => Operation::Subtraction,
+    '*' => Operation::Multiplication,
+    '/' => Operation::Division
+  }.freeze
+  ALLOWED_OPERATORS       = OPERATION_CLASSES.keys.freeze
+  INVALID_ARGUMENTS_REGEX = /[^\d\s\+\-\/\*\.]/.freeze
+
+  module_function
+
+  def start
+    operation_processor = OperationProcessor.new(
+      OPERATION_CLASSES,
+      Input::Validator.new(INVALID_ARGUMENTS_REGEX),
+      Input::Parser.new(ALLOWED_OPERATORS)
+    )
+
+    # Here is where we could read and write to another input
+    # using stdin and stdout by default
+    processor = IoProcessor.new(IoInterface::Standard.new, operation_processor)
+    processor.start
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: rpn-calculator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mario Celi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: 
+email:
+- mcelicalderon@gmail.com
+executables:
+- calculator
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/calculator
+- lib/rpn-calculator.rb
+- lib/rpn-calculator/input/parser.rb
+- lib/rpn-calculator/input/validator.rb
+- lib/rpn-calculator/io_interface/abstract.rb
+- lib/rpn-calculator/io_interface/standard.rb
+- lib/rpn-calculator/io_processor.rb
+- lib/rpn-calculator/operation/addition.rb
+- lib/rpn-calculator/operation/base.rb
+- lib/rpn-calculator/operation/division.rb
+- lib/rpn-calculator/operation/multiplication.rb
+- lib/rpn-calculator/operation/subtraction.rb
+- lib/rpn-calculator/operation_processor.rb
+- lib/rpn-calculator/result/operation.rb
+- lib/rpn-calculator/result/parser.rb
+- lib/rpn-calculator/result/processor.rb
+- lib/rpn-calculator/result/validator.rb
+- lib/rpn-calculator/version.rb
+homepage: https://github.com/mcelicalderon/rpn-calculator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Basic RPN Calculator
+test_files: []