quecto_calc 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20adbf781b1eb596029581cca4444cb87ee04d5c9e5b821027789486f6f38b65
-  data.tar.gz: 1acc1509de74d7f7f5681bd86c24d90433dd8bfc43706600c9d60bfadff78290
+  metadata.gz: 44bae8aee9c0431cfd4ea0b75aefe914bdc55f3e0ea4565c889ad608c7f67b64
+  data.tar.gz: 8a2a5b6e5e59304c184e2aa0eea67b36fdb9a90ccfa23fd19f71065a241fb135
 SHA512:
-  metadata.gz: f25a9e6c5a2630528ff65aa83f46043ab1d0076dfe8b1c617cea9dfe23af4f9ea966f50b276e08c13236e1ccc715b6d9e06eb973d6bc090167609b3e23b136a9
-  data.tar.gz: bdaac5eb72f9ace46f008759c07037b396af76e29e6984e6c7d6e6310b24e6437b77d0e48e134ddab417a128a07fd078b78ddcdecfa61a3055d2f4c245f48151
+  metadata.gz: 5decd805cf29de3744f18b161ea4cd0557df6ee6886f6a7f68527ce791083640ce8a29f92e4f5a3e0985bf19c21cf2dd4a4297c58f06ce9da1d8bfecbe6d1cb1
+  data.tar.gz: 78025741efc21e5957ccbab21ca3fab3963ddb47eb50b6e08f9c116d289b8d20d995f7357e9113141af9829fed8bd9419d871b787c688eae3d2567dbe5e5e178

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+### 0.2.0 / 2023-02-20
+
+* Lexer/parser separated in a it's own gem 'quecto_parser';
+* Bug fixes.
+
 ### 0.1.1 / 2023-02-19
 
 * Added constants interface.

data/Gemfile

@@ -10,3 +10,5 @@ gem "rake", "~> 13.0"
 gem "minitest", "~> 5.0"
 
 gem "rubocop", "~> 0.80"
+
+gem "quecto_parser", "~> 0.1.0"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quecto_calc (0.1.0)
+    quecto_calc (0.1.1)
 
 GEM
   remote: https://rubygems.org/

data/lib/quecto_calc/evaluator.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "quecto_error"
-require_relative "token_types"
+require_relative "quecto_calc_error"
 
 #
 # Evaluates expression from the abstract syntax tree.
 #
 class Evaluator
-  include TokenTypes
-
   #
   # Initialize an evaluator instance.
   #
@@ -20,10 +17,27 @@ class Evaluator
   end
 
   #
-  # @param [BinOpNode, NumberNode] node
+  # @param [QuectoParser::BinOpNode, QuectoParser::NumberNode] node
   #
   def visit(node)
-    send("_visit_#{node.class}", node)
+    method_name = "_visit_#{node.class}"
+    send(method_name, node)
+  end
+
+  #
+  # @param [String] _method_name
+  #
+  # @param [Object] node
+  #
+  # @raise [NoMethodError]
+  #
+  def method_missing(_method_name, node)
+    error_msg = "unsupported node type: #{node.class}. Plase check parser's output for correct node types."
+    raise NoMethodError, error_msg
+  end
+
+  def respond_to_missing?(*)
+    true
   end
 
   private
@@ -31,7 +45,7 @@ class Evaluator
   #
   # Retrieve result of a binary operation node.
   #
-  # @param [BinOpNode] node
+  # @param [QuectoParser::BinOpNode] node
   #
   # @return [Numeric]
   #   Result of the binary operation.
@@ -41,9 +55,9 @@ class Evaluator
     right = visit(node.right_node)
 
     case node.operator.type
-    when TT_PLUS
+    when TokenTypes::TT_PLUS
       left + right
-    when TT_MINUS
+    when TokenTypes::TT_MINUS
       left - right
     end
   end
@@ -51,15 +65,15 @@ class Evaluator
   #
   # Retrieve value of a number node.
   #
-  # @param [NumberNode] node
+  # @param [QuectoParser::NumberNode] node
   #
   # @return [Numeric]
   #
   def _visit_NumberNode(node)
     case node.token.type
-    when TT_INT
+    when TokenTypes::TT_INT
       node.token.value
-    when TT_CONST
+    when TokenTypes::TT_CONST
       _init_constant(node)
     end
   end
@@ -67,12 +81,12 @@ class Evaluator
   #
   # Replace constant with an associated value.
   #
-  # @param [NumberNode] node
+  # @param [QuectoParser::NumberNode] node
   #   A numeric node with @token of TT_CONST type.
   #
   # @return [Numeric]
   #
-  # @raise [CalcError]
+  # @raise [CalcError::RunTimeError]
   #   Raises if constant is not found in the @consts.
   #
   def _init_constant(node)

data/lib/quecto_calc/quecto_calc_error.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+#
+# Errors rised by the quecto_calc.
+#
+class QuectoCalcError < ::StandardError
+  attr_reader :message
+
+  def initialize(message)
+    @message = message
+    super()
+  end
+end
+
+#
+# Raised by the evaluator on an illegal operation.
+#
+class CalcError < QuectoCalcError
+  attr_reader :message
+
+  def initialize(message = "")
+    super(message)
+  end
+end

data/lib/quecto_calc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class QuectoCalc
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/quecto_calc.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
+require "quecto_parser"
+
 require_relative "quecto_calc/evaluator"
-require_relative "quecto_calc/const_interface"
-require_relative "quecto_calc/lexer"
-require_relative "quecto_calc/parser"
 require_relative "quecto_calc/version"
 
 #
@@ -21,47 +20,26 @@ require_relative "quecto_calc/version"
 # @ https://github.com/davidcallanan/py-myopl-code
 #
 class QuectoCalc
-  include ConstInterface
-
   #
   # Evaluate an expression.
   #
   # @param [String] expr
-  #   Expression to parse and evaluate.
+  #   Expression (in a text form) to parse and evaluate.
   #
   # @option [Hash{ String => Numeric }] consts
   #   List on constants and their values to put in the expression.
   #
   def evaluate(expr, consts = {})
-    tokens = build_tokens(expr)
-    ast = build_ast(tokens)
-    evaluate_ast(ast, consts)
-  rescue QuectoError => e
-    puts "#{e.error_name} #{e.message}"
-  end
-
-  #
-  # Get a list of tokens from the string.
-  #
-  # @param [String] expr
-  #
-  def build_tokens(expr)
-    Lexer.new(expr).build_tokens
-  end
+    parser = QuectoParser.new
 
-  #
-  # Build an abstract syntax tree from a list of tokens.
-  #
-  # @param [Array<Token>] tokens
-  #
-  def build_ast(tokens)
-    Parser.new(tokens).parse
+    ast = parser.parse_expr(expr)
+    evaluate_ast(ast, consts) if ast
   end
 
   #
   # Evaluate expression from the AST.
   #
-  # @param [NumberNode, BinOpNode] ast
+  # @param [QuectoParser::NumberNode, QuectoParser::BinOpNode] ast
   #   Expression (in a form of AST) to evaluate.
   #
   # @option [Hash{ String => Numeric }] consts
@@ -70,5 +48,7 @@ class QuectoCalc
   def evaluate_ast(ast, consts = {})
     evaluator = Evaluator.new(consts)
     evaluator.visit(ast)
+  rescue QuectoCalcError, NoMethodError => e
+    puts "[#{e.class}] #{e.message}"
   end
 end

data/quecto_calc.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "quecto_parser", "~> 0.1.0"
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: quecto_calc
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Mate
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-02-19 00:00:00.000000000 Z
-dependencies: []
+date: 2023-02-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: quecto_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 description: Evaluates primitive arithmetic expressions represented in a text form.
 email: 
 executables: []
@@ -27,16 +41,8 @@ files:
 - bin/console
 - bin/setup
 - lib/quecto_calc.rb
-- lib/quecto_calc/bin_op_node.rb
-- lib/quecto_calc/char_rules.rb
-- lib/quecto_calc/const_interface.rb
 - lib/quecto_calc/evaluator.rb
-- lib/quecto_calc/lexer.rb
-- lib/quecto_calc/number_node.rb
-- lib/quecto_calc/parser.rb
-- lib/quecto_calc/quecto_error.rb
-- lib/quecto_calc/token.rb
-- lib/quecto_calc/token_types.rb
+- lib/quecto_calc/quecto_calc_error.rb
 - lib/quecto_calc/version.rb
 - quecto_calc.gemspec
 homepage: https://github.com/8bit-mate/quecto_calc.rb/

data/lib/quecto_calc/bin_op_node.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Stores a node with a binary operation (between two numbers).
-#
-class BinOpNode
-  attr_reader :left_node, :operator, :right_node
-
-  def initialize(left_node, operator, right_node)
-    @left_node = left_node
-    @operator = operator
-    @right_node = right_node
-  end
-end

data/lib/quecto_calc/char_rules.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Provides character rules that are used by the lexer.
-#
-module CharRules
-  NUM_CHAR = /[[:digit:]]/.freeze # characters that could form a number: digits only
-  CONST_FIRST_CHAR = /[[:alpha:]]/.freeze # characters that could be used as a 1st char. in the constant name
-  CONTS_CHAR = /[[:alpha:][:digit:]_]/.freeze # characters that could form a constant: letters, digits, underscore char.
-
-  ADD_CHAR = "+"  # character that marks an addition operator
-  SUB_CHAR = "-"  # character that marks an subtraction operator
-
-  IGNOR_CHAR = /\s/.freeze # characters that are ignored: all whitespace
-end

data/lib/quecto_calc/const_interface.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "token_types"
-
-#
-# Provides an interface to retrieve token types constants to the outer world.
-#
-module ConstInterface
-  include TokenTypes
-
-  def tt_int
-    TT_INT
-  end
-
-  def tt_const
-    TT_CONST
-  end
-
-  def tt_plus
-    TT_PLUS
-  end
-
-  def tt_minus
-    TT_MINUS
-  end
-
-  def tt_eof
-    TT_EOF
-  end
-end

data/lib/quecto_calc/lexer.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "char_rules"
-require_relative "quecto_error"
-require_relative "token"
-require_relative "token_types"
-
-#
-# Performs lexical analysis of a given string.
-#
-class Lexer
-  include TokenTypes
-  include CharRules
-
-  #
-  # Initialize a lexer instance.
-  #
-  # @param [String] str
-  #   String to parse.
-  #
-  def initialize(str)
-    @str = str
-    @pos = 0
-    @cur_char = nil
-
-    _next_char
-  end
-
-  #
-  # Create a list of tokens from a string.
-  #
-  # @return [Array<Token>] tokens
-  #
-  # @raise [IllegalCharError]
-  #   Raises when @str has an unsupported character.
-  #
-  def build_tokens
-    tokens = []
-
-    until @cur_char.nil?
-      if @cur_char == ADD_CHAR
-        tokens.append(Token.new(type: TT_PLUS))
-      elsif @cur_char == SUB_CHAR
-        tokens.append(Token.new(type: TT_MINUS))
-      elsif @cur_char.match?(NUM_CHAR)
-        num = Token.new(type: TT_INT, value: _build_word(NUM_CHAR).to_i)
-        tokens.append(num)
-      elsif @cur_char.match?(CONST_FIRST_CHAR)
-        num = Token.new(type: TT_CONST, value: _build_word(CONTS_CHAR))
-        tokens.append(num)
-      elsif @cur_char.match?(IGNOR_CHAR)
-        # Ignore whitespace.
-      else
-        error_msg = "illegal character '#{@cur_char}' at the position: #{@pos - 1}"
-        raise IllegalCharError, error_msg
-      end
-      _next_char
-    end
-
-    tokens.append(Token.new(type: TT_EOF))
-
-    tokens
-  end
-
-  private
-
-  #
-  # Build a 'word' out of a sequence of characters.
-  #
-  # A 'word' is a sequence of characters followed one by another without break characters (e.g. a space or a supported
-  # math operator: '+', '-', etc).
-  #
-  # A 'word' could be represented in a form of:
-  #
-  # 1. a sequence of alphabetical characters optionally mixed with digits and joined into one string using a connective
-  # character '_'. Examples:
-  #   - 'ruby' (a sequence of alphabetical characters only);
-  #   - 'foobar9000' (a mix of alphabetical characters and digits);
-  #   - 'this_is_a_3rd_example' (long string joined with a connective character).
-  #
-  # 2. an integer number, e.g.: '31337' (a sequence of digits without break characters).
-  #
-  # @param [Regexp] regexp
-  #   Defines that kind of character sequence the method should be looking for: NUM_CHAR (search for a digit) or
-  #   CONTS_CHAR (search for a constant).
-  #
-  # @return [String] word
-  #
-  def _build_word(regexp)
-    word = ""
-
-    until @cur_char.nil?
-      break unless @cur_char.match?(regexp)
-
-      word += @cur_char
-      _next_char
-    end
-    _next_char
-
-    @pos -= 1
-    word
-  end
-
-  #
-  # Process next character in the string.
-  #
-  def _next_char
-    @cur_char = @pos < @str.length ? @str[@pos] : nil
-    @pos += 1
-  end
-end

data/lib/quecto_calc/number_node.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Stores a node with a numeric value.
-#
-class NumberNode
-  attr_reader :token
-
-  def initialize(token)
-    @token = token
-  end
-end

data/lib/quecto_calc/parser.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "bin_op_node"
-require_relative "number_node"
-require_relative "quecto_error"
-require_relative "token_types"
-
-#
-# Parses list of tokens to build an abstract syntax tree.
-#
-class Parser
-  include TokenTypes
-
-  #
-  # Initialize a parser instance.
-  #
-  # @param [Array<Token>] tokens
-  #   List of tokens to parse.
-  #
-  def initialize(tokens)
-    @tokens = tokens
-    @cur_token = @tokens[0]
-    @idx = 0
-  end
-
-  #
-  # Parse list of tokens.
-  #
-  def parse
-    _expr
-  end
-
-  private
-
-  #
-  # Buid a node for the expression.
-  #
-  # @return [BinOpNode, NumberNode] left
-  #   Node for an expression. The left.class corresponds to the expression type: a single number or a binary operation
-  #   (an operation between two numbers).
-  #
-  def _expr
-    # retrieve left part of the expression:
-    left = _term
-
-    while BIN_OPS.include?(@cur_token.type)
-      # retrieve operator between two number nodes:
-      op_tok = @cur_token
-
-      # retrieve right part of the expression:
-      _next_token
-      right = _term
-
-      left = BinOpNode.new(left, op_tok, right)
-    end
-
-    left
-  end
-
-  #
-  # Search for a term in the expression.
-  #
-  # @return [NumberNode] token
-  #   Found term.
-  #
-  # @raise [InvalidSyntaxError]
-  #
-  def _term
-    if TERMS.include?(@cur_token.type)
-      token = NumberNode.new(@cur_token)
-    else
-      error_msg = "expected TT_INT or TT_LBL, but got #{@cur_token.type}"
-      raise InvalidSyntaxError, error_msg
-    end
-
-    _next_token
-    token
-  end
-
-  #
-  # Process next token.
-  #
-  def _next_token
-    @idx += 1
-    @cur_token = @tokens[@idx] if @idx < @tokens.length
-  end
-end

data/lib/quecto_calc/quecto_error.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Errors rised by the quecto_calc.
-#
-class QuectoError < ::StandardError
-  attr_reader :error_name, :message
-
-  def initialize(error_name, message)
-    @error_name = error_name
-    @message = message
-  end
-end
-
-#
-# Raised by the lexer if an illegal character is found.
-#
-class IllegalCharError < QuectoError
-  attr_reader :message
-
-  def initialize(message = "")
-    super("Illegal Character:", message)
-  end
-end
-
-#
-# Raised by the parser if an illegal syntax is found.
-#
-class InvalidSyntaxError < QuectoError
-  attr_reader :message
-
-  def initialize(message = "")
-    super("Syntax Error:", message)
-  end
-end
-
-#
-# Raised by the evaluator on an illegal operation.
-#
-class CalcError < QuectoError
-  attr_reader :message
-
-  def initialize(message = "")
-    super("Runtime Error:", message)
-  end
-end

data/lib/quecto_calc/token.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Stores a token generated by the lexer.
-#
-class Token
-  attr_reader :type, :value
-
-  def initialize(type:, value: nil)
-    @type = type
-    @value = value
-  end
-end

data/lib/quecto_calc/token_types.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Provides supported token types.
-#
-module TokenTypes
-  TT_INT = :TT_INT     # integer number
-  TT_CONST = :TT_CONST # constant (placeholder for a numeric value)
-  TT_PLUS = :TT_PLUS   # addition operator
-  TT_MINUS = :TT_MINUS # subtraction operator
-  TT_EOF = :TT_EOF     # end of input
-
-  TERMS = [TT_INT, TT_CONST].freeze
-
-  BIN_OPS = [TT_PLUS, TT_MINUS].freeze
-end