jaina 0.0.0 → 0.1.0

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module Jaina::Parser::Expression::Operator::Abstract::DSL
+  class << self
+    # @param base_klass [Class]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def included(base_klass)
+      base_klass.instance_variable_set(:@acts_as_group_closener, false)
+      base_klass.instance_variable_set(:@acts_as_group_opener, 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(
+        :@acts_as_group_opener,
+        instance_variable_get(:@acts_as_group_opener)
+      )
+
+      child_klass.instance_variable_set(
+        :@acts_as_group_closener,
+        instance_variable_get(:@acts_as_group_closener)
+      )
+
+      super
+    end
+  end
+
+  # @api private
+  # @since 0.1.0
+  module ClassMethods
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_group_closener
+      @acts_as_group_closener = true
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_group_opener
+      @acts_as_group_opener = true
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_group_closener?
+      @acts_as_group_closener
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_group_opener?
+      @acts_as_group_opener
+    end
+  end
+
+  # @api private
+  # @since 0.1.0
+  module InstanceMethods
+    # @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
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Jaina::Parser::Expression::Operator
+  # @api private
+  # @since 0.1.0
+  class Grouping < Abstract
+    require_relative './grouping/dsl'
+
+    # @since 0.1.0
+    include DSL
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Jaina::Parser::Expression::Operator
+  # @api private
+  # @since 0.1.0
+  class LeftCorner < Grouping
+    acts_as_group_opener
+    token '('
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Jaina::Parser::Expression::Operator
+  # @api private
+  # @since 0.1.0
+  class NonTerminal < Abstract
+    class << self
+      # @return [Boolean]
+      #
+      # @api private
+      # @since 0.1.0
+      def terminal?
+        false
+      end
+
+      # @return [Boolean]
+      #
+      # @api private
+      # @since 0.1.0
+      def non_terminal?
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Jaina::Parser::Expression::Operator
+  # @api private
+  # @since 0.1.0
+  class Not < NonTerminal
+    precedence_level 4
+    associativity_direction :right
+    token 'NOT'
+    acts_as_unary_term
+  end
+end

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

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

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Jaina::Parser::Expression::Operator
+  # @api private
+  # @since 0.1.0
+  class RightCorner < Grouping
+    acts_as_group_closener
+    token ')'
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Jaina::Parser::Expression::Operator
+  # @api private
+  # @since 0.1.0
+  class Terminal < Abstract
+    class << self
+      # @return [Boolean]
+      #
+      # @api private
+      # @since 0.1.0
+      def terminal?
+        true
+      end
+
+      # @return [Boolean]
+      #
+      # @api private
+      # @since 0.1.0
+      def non_temrinal?
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module Jaina::Parser::Expression::Operator
+  require_relative './operator/abstract'
+  require_relative './operator/non_terminal'
+  require_relative './operator/terminal'
+  require_relative './operator/grouping'
+  require_relative './operator/and'
+  require_relative './operator/or'
+  require_relative './operator/not'
+  require_relative './operator/left_corner'
+  require_relative './operator/right_corner'
+end

data/lib/jaina/parser/expression/registry/access_interface_mixin.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Jaina::Parser::Expression
+  class Registry
+    # @api private
+    # @since 0.1.0
+    module AccessInterfaceMixin
+      class << self
+        # @param base_klass [Class]
+        # @return [void]
+        def included(base_klass)
+          base_klass.instance_variable_set(:@__expression_registry__, Registry.new)
+          base_klass.extend(ClassMethods)
+        end
+      end
+
+      # @api private
+      # @since 0.1.0
+      module ClassMethods
+        # @return [Array<String>]
+        #
+        # @api private
+        # @since 0.1.0
+        def expressions
+          @__expression_registry__.expressions
+        end
+
+        # @param extension_token [String]
+        # @return [Class{Jaina::Parser::Expressions::Operator::Abstract}]
+        #
+        # @api private
+        # @since 0.1.0
+        def [](extension_token)
+          @__expression_registry__[extension_token]
+        end
+        alias_method :fetch, :[]
+
+        # @param expression [Class{Jaina::Parser::Expressions::Operator::Abstract}]
+        # @return [void]
+        #
+        # @api private
+        # @since 0.1.0
+        def register(expression)
+          @__expression_registry__.register(expression)
+        end
+      end
+    end
+  end
+end

data/lib/jaina/parser/expression/registry.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class Jaina::Parser::Expression::Registry
+  require_relative './registry/access_interface_mixin'
+
+  # @since 0.1.0
+  Error = Class.new(StandardError)
+  # @since 0.1.0
+  AlreadyRegisteredExpressionError = Class.new(Error)
+  # @since 0.1.0
+  UnregisteredExpressionError = Class.new(Error)
+  # @since 0.1.0
+  IncorrectExpressionObjectError = Class.new(Error)
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize
+    @expression_set = {}
+    @access_lock = Mutex.new
+  end
+
+  # @param expression_token [String]
+  # @return [Class{Jaina::Parser::Operator::Abstract}]
+  #
+  # @api private
+  # @since 0.1.0
+  def [](expression_token)
+    thread_safe { fetch(expression_token) }
+  end
+
+  # @param expression [Class{Jaina::Parser::Operator::Abstract}]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def register(expression)
+    thread_safe { apply(expression) }
+  end
+
+  # @return [Array<String>]
+  #
+  # @api private
+  # @since 0.1.0
+  def expressions
+    thread_safe { expression_names }
+  end
+
+  private
+
+  # @return [Hash<String,Class{Jaina::Parser::Operator::Abstract}>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :expression_set
+
+  # @return [Mutex]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :access_lock
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def thread_safe
+    access_lock.synchronize { yield if block_given? }
+  end
+
+  # @param expression_token [String]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.1.0
+  def registered?(expression_token)
+    expression_set.key?(expression_token)
+  end
+
+  # @return [Array<String>]
+  #
+  # @api private
+  # @since 0.1.0
+  def expression_names
+    expression_set.keys
+  end
+
+  # @param expression [Class{Jaina::Parser::Operator::Abstract}]
+  # @return [void]
+  #
+  # @raise [Jaina::Parser::Expression::Registry::AlreadyRegisteredExpressionError]
+  #
+  # @api private
+  # @since 0.1.0
+  def apply(expression)
+    raise(
+      AlreadyRegisteredExpressionError,
+      "Expression with token `#{expression.token}` already exist"
+    ) if registered?(expression.token)
+
+    raise(
+      IncorrectExpressionObjectError,
+      'Expression should be a subtype of Jaina::Parser::Expression::Operation::Abstract'
+    ) unless expression.is_a?(Class) && expression < Jaina::Parser::Expression::Operator::Abstract
+
+    expression_set[expression.token] = expression
+  end
+
+  # @param expression_token [String]
+  # @return [Class{Jaina::Parser::Operator::Abstract}]
+  #
+  # @raise [Jaina::Parser::Expression::Registry::UnregisteredExpressionError]
+  #
+  # @api private
+  # @since 0.1.0
+  def fetch(expression_token)
+    raise(
+      UnregisteredExpressionError,
+      "Expression with token `#{expression_token}` is not registered"
+    ) unless registered?(expression_token)
+
+    expression_set[expression_token]
+  end
+end

data/lib/jaina/parser/expression.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module Jaina::Parser::Expression
+  require_relative './expression/operator'
+  require_relative './expression/registry'
+
+  # @since 0.1.0
+  include Registry::AccessInterfaceMixin
+
+  # @since 0.1.0
+  register(Operator::And)
+  # @since 0.1.0
+  register(Operator::Not)
+  # @since 0.1.0
+  register(Operator::Or)
+  # @since 0.1.0
+  register(Operator::LeftCorner)
+  # @since 0.1.0
+  register(Operator::RightCorner)
+
+  class << self
+    # @param expression_token [String]
+    # @param arguments [Array<Any>]
+    # @return [Jaina::Parser::Expression::Operator::Abstract]
+    #
+    # @api private
+    # @since 0.1.0
+    def build(expression_token, *arguments)
+      expression = fetch(expression_token)
+      arguments.any? ? expression.new(*arguments) : expression.new
+    end
+
+    # @param expression_token [String]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def terminal?(expression_token)
+      fetch(expression_token).terminal?
+    end
+
+    # @param expression_token [String]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def non_terminal?(expression_token)
+      fetch(expression_token).non_terminal?
+    end
+
+    # @param expression_token [String]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def group_opener?(expression_token)
+      fetch(expression_token).acts_as_group_opener?
+    end
+
+    # @param expression_token [String]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def group_closener?(expression_token)
+      fetch(expression_token).acts_as_group_closener?
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_binary_term?(expression_token)
+      fetch(expression_token).acts_as_binary_term?
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def acts_as_unary_term?(expression_token)
+      fetch(expression_token).acts_as_unary_term?
+    end
+  end
+end

data/lib/jaina/parser/tokenizer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module Jaina::Parser::Tokenizer
+  # @return [Regexp]
+  #
+  # @api private
+  # @since 0.1.0
+  TOKEN_SCAN_PATTERN = /\(|\)|[\w\.\*]+/.freeze
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  TOKEN_SPLITTER = ' '
+
+  class << self
+    # @param program [String]
+    # @return [Array<String>]
+    #
+    # @api private
+    # @since 0.1.0
+    def tokenize(program)
+      program.scan(TOKEN_SCAN_PATTERN)
+    end
+
+    # @param tokens [Array<String>]
+    # @return [String]
+    #
+    # @api private
+    # @since 0.1.0
+    def join(tokens)
+      tokens.join(TOKEN_SPLITTER)
+    end
+  end
+end

data/lib/jaina/parser.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class Jaina::Parser
+  require_relative './parser/expression'
+  require_relative './parser/tokenizer'
+  require_relative './parser/code_converter'
+  require_relative './parser/ast'
+
+  class << self
+    # @param program [String]
+    # @return [Jaina::Parser::AST]
+    #
+    # @api private
+    # @since 0.1.0
+    def parse(program)
+      new(program).parse
+    end
+  end
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :program
+
+  # @param program [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(program)
+    @program = program.dup.tap(&:freeze)
+  end
+
+  # @return [Jaina::Parser::AST]
+  #
+  # @api private
+  # @since 0.1.0
+  def parse
+    AST.build(program)
+  end
+end

data/lib/jaina/version.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
 module Jaina
-  VERSION = '0.0.0'
+  # @return [String]
+  #
+  # @api public
+  # @since 0.0.0
+  VERSION = '0.1.0'
 end

data/lib/jaina.rb

@@ -1,8 +1,62 @@
 # frozen_string_literal: true
 
-require 'jaina/version'
-
+# @api public
+# @since 0.1.0
 module Jaina
-  class Error < StandardError; end
-  # Your code goes here...
+  require_relative './jaina/version'
+  require_relative './jaina/parser'
+
+  # @since 0.1.0
+  extend Forwardable
+
+  TerminalExpr    = Parser::Expression::Operator::Terminal
+  NonTerminalExpr = Parser::Expression::Operator::NonTerminal
+  GroupingExpr    = Parser::Expression::Operator::Grouping
+
+  class << self
+    # @param program [String]
+    # @return [Jaina::Parser::AST]
+    #
+    # @api public
+    # @since 0.1.0
+    def parse(program)
+      Parser.parse(program)
+    end
+
+    # @param program [String]
+    # @return [Any]
+    #
+    # @api public
+    # @since 0.1.0
+    def evaluate(program)
+      parse(program).evaluate
+    end
+
+    # @param expression_klass [Class{Jaina::Parser::Expression::Operator::Abstract}]
+    # @return [void]
+    #
+    # @api public
+    # @since 0.1.0
+    def register_expression(expression_klass)
+      Jaina::Parser::Expression.register(expression_klass)
+    end
+
+    # @return [Array<String>]
+    #
+    # @api public
+    # @since 0.1.0
+    def expressions
+      Jaina::Parser::Expression.expressions
+    end
+
+    # @param expression_token [String]
+    # @return [Class{Jaina::Parser::Expressions::Operator::Abstract}]
+    #
+    # @api public
+    # @since 0.1.0
+    def fetch_expression(expression_token)
+      Jaina::Parser::Expression.fetch(expression_token)
+    end
+    alias_method :[], :fetch_expression
+  end
 end