kanal 0.3.0

data/lib/kanal/core/output/output_creator.rb

@@ -0,0 +1,17 @@
+module Kanal
+  module Core
+    module Output
+      # This class helps creating output with the help
+      # of handy dsl format
+      class OutputCreator
+        def initialize(input)
+          @input = input
+        end
+
+        def create(&block)
+          
+        end
+      end
+    end
+  end
+end

data/lib/kanal/core/plugins/plugin.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "rake"
+
+module Kanal
+  module Core
+    module Plugins
+      # Base class for plugins that can be registered in the core
+      class Plugin
+        #
+        # Name of the plugin, for it to be available
+        # for finding and getting
+        #
+        # @return [Symbol] <description>
+        #
+        def name
+          raise NotImplementedError
+        end
+
+        #
+        # This method is for the setting up, it will be executed when plugin
+        # is being added to the core
+        #
+        # @param [Kanal::Core::Core] core <description>
+        #
+        # @return [void] <description>
+        #
+        def setup(core)
+          raise NotImplementedError
+        end
+
+        #
+        # If plugins does have rake tasks available for execution,
+        # require them here. They will be used 
+        #
+        # @return [Array<Rake::TaskLib>] <description>
+        #
+        def rake_tasks
+          []
+        end
+      end
+    end
+  end
+end

data/lib/kanal/core/router/router.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "./router_node"
+
+module Kanal
+  module Core
+    module Router
+      # Router serves as a container class for
+      # root node of router nodes, also as somewhat
+      # namespace. Basically class router stores all the
+      # router nodes and have a name.
+      class Router
+        attr_reader :name,
+                    :core
+
+        def initialize(name, core)
+          @name = name
+          @core = core
+          @root_node = nil
+          @default_node = nil
+        end
+
+        def configure(&block)
+          # Root node does not have parent
+          @root_node ||= RouterNode.new router: self, parent: nil, root: true
+
+          @root_node.instance_eval(&block)
+        end
+
+        def default_response(&block)
+          raise "default node for router #{@name} already defined" if @default_node
+
+          @default_node = RouterNode.new parent: nil, router: self, default: true
+
+          @default_node.respond(&block)
+        end
+
+        # Main method for creating output if it is found or going to default output
+        def create_output_for_input(input)
+          # Checking if default node with output exists throw error if not
+          raise "Please provide default response for router before you try and throw input against it ;)" unless @default_node
+
+          raise "You did not actually .configure router, didn't you? There is no even root node! Use .configure method" unless @root_node
+
+          unless @root_node.children?
+            raise "Hey your router actually does not have ANY routes to work with. Did you even try adding them?"
+          end
+
+          @core.hooks.call :input_before_router, input
+
+          node = test_input_against_router_node input, @root_node
+
+          # No result means no route node was found for that input
+          # using default response
+          node ||= @default_node
+
+          output = node.construct_response input
+
+          @core.hooks.call :output_before_returned, input, output
+
+          output
+        end
+
+        # Recursive method for searching router nodes
+        def test_input_against_router_node(input, router_node)
+          # Allow root node because it does not have any conditions and does not have
+          # any responses, but it does have children. Well, it should have children...
+          # Basically:
+          # if router_node is root - proceed with code
+          # if router_node is not root and condition is not met - stop right here.
+          # Cannot proceed inside of this node.
+          return if !router_node.root? && !router_node.condition_met?(input, @core)
+
+          # Check if node has children first. Router node with children SHOULD NOT HAVE RESPONSE.
+          # There is an exception for this case so don't worry, it's not protected only by
+          # this comment
+          if router_node.children?
+            node = nil
+
+            router_node.children.each do |c|
+              node = test_input_against_router_node input, c
+
+              break if node
+            end
+
+            node
+          elsif router_node.response?
+            # Router node without children can have response
+            router_node
+          end
+        end
+
+        private :test_input_against_router_node
+      end
+    end
+  end
+end

data/lib/kanal/core/router/router_node.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "../output/output"
+
+module Kanal
+  module Core
+    # This module stores RouterNode and helper classes which are
+    # important for building router nodes tree
+    module Router
+      # This class is used as a node in router
+      # tree, containing conditions and responses
+      class RouterNode
+        include Output
+
+        attr_reader :parent,
+                    :children
+
+        # parameter default: is for knowing that this node
+        # is for default response
+        # default response cannot have child nodes
+        def initialize(*args, router:, parent:, default: false, root: false)
+          @router = router
+          @parent = parent
+
+          @children = []
+
+          @response_block = nil
+
+          @condition_pack_name = nil
+          @condition_name = nil
+          @condition_argument = nil
+
+          # We omit setting conditions because default router node does not need any conditions
+          # Also root node does not have conditions so we basically omit them if arguments are empty
+          return if default || root
+
+          # With this we attach names of condition pack and condition to this router
+          # node, so we will be able to find them later at runtime and use them
+          assign_condition_pack_and_condition_names_from_args!(*args)
+        end
+
+        def on(*args, &block)
+          raise "You cannot add children to nodes with response ready. Response is a final line" if response?
+
+          child = RouterNode.new(*args, router: @router, parent: self)
+          add_child child
+
+          child.instance_eval(&block)
+        end
+
+        def construct_response(input)
+          raise "no response block configured for this node. router: #{@router.name}. debug: #{debug_info}" unless @response_block
+
+          output = Output::Output.new @router.core.output_parameter_registrator, input, @router.core
+
+          output.instance_eval(&@response_block)
+
+          output
+        end
+
+        def respond(&block)
+          raise "Router node with children cannot have response" unless @children.empty?
+
+          @response_block = block
+        end
+
+        def response?
+          !@response_block.nil?
+        end
+
+        # This method processes args to populate condition and condition pack
+        # in this router node
+        def assign_condition_pack_and_condition_names_from_args!(*args)
+          condition_pack_name = args[0]
+          condition_name = args[1]
+
+          # We assume we got condition that requires argument
+          if condition_name.is_a? Hash
+            # We search for arguments inside kwargs
+            @condition_argument = condition_name.values.first
+
+            condition_name = condition_name.keys.first
+          end
+
+          # This calls will raise errors if there is problem with pack or condition
+          # inside of it
+          pack = @router.core.condition_storage.get_condition_pack_by_name! condition_pack_name
+          condition = pack.get_condition_by_name! condition_name
+
+          if condition.with_argument? && !@condition_argument
+            raise "Condition requires argument, though you wrote it as :symbol, not as positional_arg:
+            Please check route with condition pack: #{condition_pack_name} and condition: #{condition_name}"
+          end
+
+          @condition_pack_name = condition_pack_name
+          @condition_name = condition_name
+        end
+
+        def debug_info
+          "RouterNode with condition pack: #{@condition_pack_name}, condition: #{@condition_name}, condition argument: #{@condition_argument}"
+        end
+
+        def condition_met?(input, core)
+          c = condition
+
+          c.met? input, core, @condition_argument
+        end
+
+        def condition
+          pack = @router.core.condition_storage.get_condition_pack_by_name! @condition_pack_name
+
+          pack.get_condition_by_name! @condition_name
+        end
+
+        def root?
+          parent.nil?
+        end
+
+        def children?
+          !@children.empty?
+        end
+
+        def add_child(node)
+          @children.append node
+        end
+
+        private :add_child
+      end
+    end
+  end
+end

data/lib/kanal/core/router/router_storage.rb

@@ -0,0 +1,33 @@
+require_relative "./router"
+
+module Kanal
+  module Core
+    module Router
+      # Class with helper methods for creating and getting routers
+      class RouterStorage
+        def initialize(core)
+          @routers = []
+          @core = core
+        end
+
+        #
+        # Creates router by name and stores it for further access
+        #
+        # @param [Symbol] name <description>
+        #
+        # @return [Kanal::Core::Router::Router] <description>
+        #
+        def get_or_create_router(name)
+          router = @routers.find { |r| r.name == name }
+
+          unless router
+            router = Router.new name, @core
+            @routers.append router
+          end
+
+          router
+        end
+      end
+    end
+  end
+end

data/lib/kanal/core/services/service_container.rb

@@ -0,0 +1,97 @@
+module Kanal
+  module Core
+    module Services
+      # Stores info about service registration
+      class ServiceRegistration
+        attr_reader :service_class,
+                    :type,
+                    :block
+
+        def initialize(service_class, type, block)
+          @service_class = service_class
+          @type = type
+          @block = block
+        end
+
+        def block?
+          !@block.nil?
+        end
+      end
+
+      #
+      # Container allows service registration as well as
+      # getting those services. You can register service with different
+      # lifespan types.
+      #
+      class ServiceContainer
+        TYPE_SINGLETON = :singleton
+        TYPE_TRANSIENT = :transient
+
+        def initialize
+          @registrations = {}
+          @services = {}
+        end
+
+        #
+        # Registering service so container knows about it and it's type and it's
+        # optional initialization block
+        #
+        # @param [Symbol] name <description>
+        # @param [class] service_class <description>
+        # @param [Symbol] type <description>
+        # @yield Initialization block. It should be used if your service
+        #   requires postponed initialization
+        #
+        # @return [void] <description>
+        #
+        def register_service(name, service_class, type: TYPE_SINGLETON, &block)
+          return if @registrations.key? name
+
+          raise "Unrecognized service type #{type}. Allowed types: #{allowed_types}" unless allowed_types.include? type
+
+          registration = ServiceRegistration.new service_class, type, block
+
+          @registrations[name] = registration
+        end
+
+        #
+        # Gets the registered service by name
+        #
+        # @param [Symbol] name <description>
+        #
+        # @return [Object] <description>
+        #
+        def get(name)
+          raise "Service named #{name} was not registered in container" unless @registrations.key? name
+
+          registration = @registrations[name]
+
+          if registration.type == TYPE_SINGLETON
+            # Created once and reused after creation
+            if @services[name].nil?
+              @services[name] = create_service_from_registration registration
+            end
+
+            @services[name]
+          elsif registration.type == TYPE_TRANSIENT
+            # Created every time
+            create_service_from_registration registration
+          end
+        end
+
+        def create_service_from_registration(registration)
+          return registration.block.call if registration.block?
+
+          registration.service_class.new
+        end
+
+        def allowed_types
+          [TYPE_SINGLETON, TYPE_TRANSIENT]
+        end
+
+        private :create_service_from_registration,
+                :allowed_types
+      end
+    end
+  end
+end

data/lib/kanal/interfaces/simple_cli/simple_cli_interface.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../../core/interfaces/interface"
+require_relative "../../plugins/batteries/batteries_plugin"
+
+module Kanal
+  module Interfaces
+    module SimpleCli
+      # This interface provides input/output with the cli
+      class SimpleCliInterface < Kanal::Core::Interfaces::Interface
+        #
+        # <Description>
+        #
+        # @param [Kanal::Core::Core] core <description>
+        #
+        def initialize(core)
+          super
+
+          # For simple cli we need body
+          @core.register_plugin Kanal::Plugins::Batteries::BatteriesPlugin.new
+
+          @core.register_output_parameter :quit
+        end
+
+        def start
+          loop do
+            puts ">>>"
+            input = @core.create_input
+            input.body = gets
+
+            output = router.create_output_for_input input
+
+            if output.quit
+              puts "Undestood! Quitting"
+              break
+            end
+
+            puts "[bot]: #{output.body}"
+          rescue Interrupt
+            puts "Got it! Hard stop. Bye bye!"
+            break
+          end
+
+          puts "End of conversation!"
+        end
+
+        def stop; end
+      end
+    end
+  end
+end

data/lib/kanal/plugins/batteries/batteries_plugin.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "kanal/core/plugins/plugin"
+
+module Kanal
+  module Plugins
+    # This module stores needed classes and helpers for batteries plugin
+    module Batteries
+      # Plugin with some batteries like .body property etc
+      class BatteriesPlugin < Core::Plugins::Plugin
+        def name
+          :batteries
+        end
+
+        def setup(core)
+          source_batteries core
+          body_batteries core
+          flow_batteries core
+        end
+
+        def flow_batteries(core)
+          core.add_condition_pack :flow do
+            add_condition :any do
+              met? do |_, _, _|
+                true
+              end
+            end
+          end
+        end
+
+        def source_batteries(core)
+          # This parameter can be filled by different plugins/interfaces
+          # to point from which source message came
+          core.register_input_parameter :source
+
+          core.add_condition_pack :source do
+            add_condition :from do
+              with_argument
+
+              met? do |input, _, argument|
+                input.source == argument
+              end
+            end
+          end
+        end
+
+        def body_batteries(core)
+          core.register_input_parameter :body
+          core.register_output_parameter :body
+
+          core.add_condition_pack :body do
+            add_condition :starts_with do
+              with_argument
+
+              met? do |input, _, argument|
+                if input.body.is_a? String
+                  input.body.start_with? argument
+                else
+                  false
+                end
+              end
+            end
+
+            add_condition :ends_with do
+              with_argument
+
+              met? do |input, _, argument|
+                if input.body.is_a? String
+                  input.body.end_with? argument
+                else
+                  false
+                end
+              end
+            end
+
+            add_condition :contains do
+              with_argument
+
+              met? do |input, _, argument|
+                if input.body.is_a? String
+                  input.body.include? argument
+                else
+                  false
+                end
+              end
+            end
+
+            add_condition :contains_one_of do
+              with_argument
+
+              met? do |input, _, argument|
+                met = false
+
+                argument.each do |word|
+                  met = input.body.include? word
+
+                  break if met
+                end
+
+                met
+              end
+            end
+
+            add_condition :equals do
+              with_argument
+
+              met? do |input, _, argument|
+                input.body == argument
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanal/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kanal
+  VERSION = "0.3.0"
+end

data/lib/kanal.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "kanal/version"
+require_relative "kanal/core/core"
+require_relative "kanal/core/plugins/plugin"
+
+# This module used as a main entry point into kanal-core library
+module Kanal
+end

data/sig/kanal/core/conditions/condition_pack.rbs

@@ -0,0 +1,9 @@
+module Kanal
+  module Core
+    module Conditions
+      class ConditionPack
+
+      end
+    end
+  end
+end

data/sig/kanal/core/conditions/condition_storage.rbs

@@ -0,0 +1,9 @@
+module Kanal
+  module Core
+    module Conditions
+      class ConditionStorage
+        def get_condition_pack_by_name: (name: String) -> ConditionPack
+      end
+    end
+  end
+end

data/sig/kanal.rbs

@@ -0,0 +1,4 @@
+module Kanal
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end