jaina 0.0.0 → 0.1.0

data/lib/jaina/parser/code_converter/to_postfix_form.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class Jaina::Parser::CodeConverter::ToPostfixForm
+  # @api private
+  # @since 0.1.0
+  extend Forwardable
+
+  class << self
+    # @param program [String]
+    # @return [String]
+    #
+    # @api private
+    # @since 0.1.0
+    def call(program)
+      new(program).call
+    end
+  end
+
+  # @since 0.1.0
+  def_delegators Jaina::Parser::Expression,
+                 :non_terminal?,
+                 :terminal?,
+                 :group_opener?,
+                 :group_closener?
+
+  # @param program [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(program)
+    @program = program.dup.tap(&:freeze)
+    @tokens = Jaina::Parser::Tokenizer.tokenize(program)
+  end
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  def call
+    to_postfix_form
+  end
+
+  private
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :program
+
+  # @return [Array<String>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :tokens
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  def to_postfix_form
+    final_expression = []
+    structure_operators = []
+    token_series = tokens.map(&:dup)
+
+    until token_series.empty?
+      current_token = token_series.shift
+
+      case
+      when non_terminal?(current_token)
+        process_non_terminal_token(final_expression, structure_operators, current_token)
+      when group_opener?(current_token)
+        process_group_opening_token(final_expression, structure_operators, current_token)
+      when group_closener?(current_token)
+        process_group_closing_token(final_expression, structure_operators, current_token)
+      when terminal?(current_token)
+        process_terminal_token(final_expression, structure_operators, current_token)
+      end
+    end
+
+    finish_final_expression(final_expression, structure_operators, current_token)
+
+    # NOTE: build postfixed program string
+    Jaina::Parser::Tokenizer.join(final_expression)
+  end
+
+  # @param final_expression [Array<String>]
+  # @param structure_operators [Array<String>]
+  # @param current_token [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def process_non_terminal_token(final_expression, structure_operators, current_token)
+    if structure_operators.any? # NOTE: check assocaitivity with potential next token
+      potential_second_token = structure_operators.last
+
+      if non_terminal?(potential_second_token)
+        current_expression = Jaina::Parser::Expression.fetch(current_token)
+        next_expression    = Jaina::Parser::Expression.fetch(potential_second_token)
+
+        # NOTE: form infix to postfix form switching
+        final_expression.push(structure_operators.pop) if current_expression.lower?(next_expression)
+      end
+    end
+
+    structure_operators.push(current_token)
+  end
+
+  # @param final_expression [Array<String>]
+  # @param structure_operators [Array<String>]
+  # @param current_token [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def process_group_opening_token(final_expression, structure_operators, current_token)
+    # NOTE: remember group opening operator
+    structure_operators.push(current_token)
+  end
+
+  # @param final_expression [Array<String>]
+  # @param structure_operators [Array<String>]
+  # @param current_token [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def process_group_closing_token(final_expression, structure_operators, current_token)
+    until group_opener?(structure_operators.last)
+      # NOTE: push all tokens to the final expression
+      final_expression.push(structure_operators.pop)
+    end
+
+    # NOTE: drop closing operator
+    structure_operators.pop
+  end
+
+  # @param final_expression [Array<String>]
+  # @param structure_operators [Array<String>]
+  # @param current_token [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def process_terminal_token(final_expression, structure_operators, current_token)
+    # NOTE: push terminal expression to the final expression
+    final_expression.push(current_token)
+  end
+
+  # @param final_expression [Array<String>]
+  # @param structure_operators [Array<String>]
+  # @param current_token [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def finish_final_expression(final_expression, structure_operators, current_token)
+    # NOTE: fill the rest tokens to the final expression
+    until structure_operators.empty?
+      final_expression.push(structure_operators.pop)
+    end
+  end
+end

data/lib/jaina/parser/code_converter/to_prefix_form.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class Jaina::Parser::CodeConverter::ToPrefixForm
+  # @since 0.1.0
+  extend Forwardable
+
+  class << self
+    # @param program [String]
+    # @return [String]
+    #
+    # @api private
+    # @since 0.1.0
+    def call(program)
+      new(program).call
+    end
+  end
+
+  # @since 0.1.0
+  def_delegators Jaina::Parser::Expression, :terminal?, :non_terminal?
+
+  # @param program [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(program)
+    @program = program.dup.tap(&:freeze)
+    @postfix_form = Jaina::Parser::CodeConverter::ToPostfixForm.call(@program)
+    @tokens = Jaina::Parser::Tokenizer.tokenize(@postfix_form)
+  end
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  def call
+    to_prefix_form
+  end
+
+  private
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :program
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :postfix_form
+
+  # @return [Array<String>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :tokens
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  def to_prefix_form
+    token_series = tokens.map(&:dup)
+    expression_stack = []
+
+    until token_series.empty?
+      current_token = token_series.shift
+
+      case
+      when terminal?(current_token)
+        process_terminal_token(current_token, expression_stack)
+      when non_terminal?(current_token)
+        process_non_terminal_token(current_token, expression_stack)
+      end
+    end
+
+    # NOTE: build prefixed program string
+    Jaina::Parser::Tokenizer.join(expression_stack)
+  end
+
+  # @param current_token [String]
+  # @param expression_stack [Array<String>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def process_terminal_token(current_token, expression_stack)
+    expression_stack.push(current_token)
+  end
+
+  # @param current_token [String]
+  # @param expression_stack [Array<String>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def process_non_terminal_token(current_token, expression_stack)
+    expression = Jaina::Parser::Expression.fetch(current_token)
+
+    case # TODO: dry
+    when expression.acts_as_binary_term?
+      first_operand  = expression_stack.pop
+      second_operand = expression_stack.pop
+
+      prefixed_expression_parts = [expression.token, second_operand, first_operand]
+      prefixed_expression = Jaina::Parser::Tokenizer.join(prefixed_expression_parts)
+
+      expression_stack.push(prefixed_expression)
+    when expression.acts_as_unary_term?
+      operand = expression_stack.pop
+
+      prefixed_expression_parts = [expression.token, operand]
+      prefixed_expression = Jaina::Parser::Tokenizer.join(prefixed_expression_parts)
+
+      expression_stack.push(prefixed_expression)
+    end
+  end
+end

data/lib/jaina/parser/code_converter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class Jaina::Parser::CodeConverter
+  require_relative './code_converter/to_postfix_form'
+  require_relative './code_converter/to_prefix_form'
+
+  class << self
+    # @param program [String]
+    # @return [String]
+    #
+    # @api private
+    # @since 0.1.0
+    def to_postfix_form(program)
+      ToPrefixForm.call(program)
+    end
+
+    # @param program [String]
+    # @return [String]
+    #
+    # @api private
+    # @since 0.1.0
+    def to_prefix_form(program)
+      ToPrefixForm.call(program)
+    end
+  end
+end

data/lib/jaina/parser/expression/operator/abstract/dsl.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module Jaina::Parser::Expression::Operator::Abstract::DSL
+  # @since 0.1.0
+  Error = Class.new(StandardError)
+  # @since 0.1.0
+  IncorrectTokenError = Class.new(Error)
+  # @since 0.1.0
+  IncorrectPrecedenceLevelError = Class.new(Error)
+  # @since 0.1.0
+  IncorrectAssociativityDirectionError = Class.new(Error)
+
+  # @return [Symbol]
+  #
+  # @api private
+  # @since 0.1.0
+  LEFT_ASSOC = :left
+
+  # @return [Symbol]
+  #
+  # @api private
+  # @since 0.1.0
+  RIGHT_ASSOC = :right
+
+  class << self
+    # @param base_klass [Class]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def included(base_klass)
+      base_klass.instance_variable_set(:@token, nil)
+      base_klass.instance_variable_set(:@precedence_level, nil)
+      base_klass.instance_variable_set(:@associativity_direction, nil)
+      base_klass.instance_variable_set(:@acts_as_binary_term, false)
+      base_klass.instance_variable_set(:@acts_as_unary_term, false)
+
+      base_klass.extend ClassMethods
+      base_klass.include InstanceMethods
+      base_klass.singleton_class.prepend(ClassInheritance)
+    end
+  end
+
+  # @api private
+  # @since 0.1.0
+  module ClassInheritance
+    # @param child_klass [Class]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def inherited(child_klass)
+      child_klass.instance_variable_set(
+        :@token,
+        instance_variable_get(:@token)
+      )
+
+      child_klass.instance_variable_set(
+        :@precedence_level,
+        instance_variable_get(:@precedence_level)
+      )
+
+      child_klass.instance_variable_set(
+        :@associativity_direction,
+        instance_variable_get(:@associativity_direction)
+      )
+
+      child_klass.instance_variable_set(
+        :@acts_as_binary_term,
+        instance_variable_get(:@acts_as_binary_term)
+      )
+
+      child_klass.instance_variable_set(
+        :@acts_as_unary_term,
+        instance_variable_get(:@acts_as_unary_term)
+      )
+
+      super
+    end
+  end
+
+  # @api private
+  # @since 0.1.0
+  module ClassMethods
+    # @param term [String, NilClass]
+    # @return [String, NilClass]
+    #
+    # @api private
+    # @since 0.1.0
+    def token(term = nil)
+      unless term.is_a?(String) || term.is_a?(NilClass)
+        raise IncorrectTokenError, 'Token should be a type of string'
+      end
+
+      @token = term unless term.nil?
+      @token
+    end
+
+    # @param level [Integer, NilClass]
+    # @return [Integer, NilClass]
+    #
+    # @api private
+    # @since 0.1.0
+    def precedence_level(level = nil)
+      unless level.is_a?(Integer) || level.is_a?(NilClass)
+        raise IncorrectPrecedenceLevelError, 'Precendence level should be a type of integer'
+      end
+
+      @precedence_level = level unless level.nil?
+      @precedence_level
+    end
+
+    # @param assoc [String, NilClass]
+    # @return [String, NilClass]
+    #
+    # @api private
+    # @since 0.1.0
+    def associativity_direction(assoc = nil)
+      unless assoc.is_a?(NilClass) || assoc == LEFT_ASSOC || assoc == RIGHT_ASSOC
+        raise(
+          IncorrectAssociativityDirectionError,
+          "Associativity direction can be :#{LEFT_ASSOC} or :#{RIGHT_ASSOC}"
+        )
+      end
+
+      @associativity_direction = assoc unless assoc.nil?
+      @associativity_direction
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_binary_term
+      @acts_as_binary_term = true
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_unary_term
+      @acts_as_unary_term = true
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_binary_term?
+      @acts_as_binary_term
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_unary_term?
+      @acts_as_unary_term
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def terminal?
+      false
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def non_terminal?
+      false
+    end
+  end
+
+  # @api private
+  # @since 0.1.0
+  module InstanceMethods
+    # @return [String, NilClass]
+    #
+    # @api private
+    # @since 0.1.0
+    def token
+      self.class.token
+    end
+
+    # @return [Integer, NilClass]
+    #
+    # @api private
+    # @since 0.1.0
+    def precedence_level
+      self.class.precedence_level
+    end
+
+    # @return [Symbol, NilClass]
+    #
+    # @api private
+    # @since 0.1.0
+    def associativity_direction
+      self.class.associativity_direction
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_group_closener?
+      self.class.acts_as_group_closener?
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_group_opener?
+      self.class.acts_as_group_opener?
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_binary_term?
+      self.class.acts_as_binary_term?
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_unary_term?
+      self.class.acts_as_unary_term?
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def terminal?
+      self.class.terminal?
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def non_terminal?
+      self.class.non_terminal?
+    end
+  end
+end

data/lib/jaina/parser/expression/operator/abstract.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class Jaina::Parser::Expression::Operator::Abstract
+  require_relative './abstract/dsl'
+
+  # @since 0.1.0
+  include DSL
+  # @since 0.1.0
+  Error = Class.new(StandardError)
+  # @since 0.1.0
+  InompatibleDirectionComparisonError = Class.new(Error)
+
+  class << self
+    # @param another_operator [Class<Jaina::Parser::Expression::Operator::Abstract>]
+    # @return [Boolean]
+    #
+    # @raise [InompatibleDirectionComparisonError]
+    #
+    # @api private
+    # @since 0.1.0
+    def lower?(another_operator)
+      raise(
+        InompatibleDirectionComparisonError,
+        "Trying to compare non-comparable terms `#{token}` and `#{another_operator.token}`"
+      ) if associativity_direction.nil? || another_operator.associativity_direction.nil?
+
+      if associativity_direction == Jaina::Parser::Expression::Operator::Abstract::DSL::LEFT_ASSOC
+        associativity_direction <= another_operator.associativity_direction
+      else
+        associativity_direction < another_operator.associativity_direction
+      end
+    end
+  end
+
+  # @return [Array<Jaina::Parser::Expressions::Operator::Abstract>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :expressions
+
+  # @param expressions [Array<Jaina::Parser::Expression::Operator::Abstract>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(*expressions)
+    @expressions = expressions
+  end
+
+  # @param context [Any]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def evaluate(context); end
+
+  # @param another_operator [Class<Jaina::Parser::Expression::Operator::Abstract>]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.1.0
+  def lower(another_operator)
+    self.class.lower(another_operator)
+  end
+end

data/lib/jaina/parser/expression/operator/and.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Jaina::Parser::Expression::Operator
+  # @api private
+  # @since 0.1.0
+  class And < NonTerminal
+    precedence_level 3
+    associativity_direction :left
+    token 'AND'
+    acts_as_binary_term
+  end
+end