charyf 0.1.1

data/lib/charyf/engine/controller/renderers.rb

@@ -0,0 +1,103 @@
+require 'erb'
+
+require_relative '../../utils'
+
+module Charyf
+  module Controller
+    module Renderers
+
+      class ResponseFileMissingError < StandardError; end
+      class NoResponseFound < StandardError; end
+      class InvalidState < StandardError; end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def auto_reply(only: [], except: [])
+          @_render_filters = Charyf::Utils.create_action_filters(only, except)
+        end
+
+        def _render_on?(action)
+          Charyf::Utils.match_action_filters?(action.to_sym, _render_filters)
+        end
+
+        def _render_filters
+          @_render_filters ||= Charyf::Utils.create_action_filters
+        end
+
+      end # End of ClassMethods
+
+      # TODO sig
+      def response_folder
+        return nil if skill_name.to_s.blank?
+
+        return skill_name.to_s.constantize.skill_root.join('responses', controller_path)
+      end
+
+      def ensure_responses_for(action)
+        unless response_folder
+          raise Charyf::Controller::Renderers::InvalidState.new('Controller without skill can not render views')
+        end
+
+        if responses_for(action).empty?
+          raise Charyf::Controller::Renderers::NoResponseFound.new('No responses files found for action ' + action.to_s + "\n" +
+                                                                       "Expected #{action}.[html|txt].erb in #{response_folder}")
+        end
+      end
+
+      # TODO sig
+      def responses_for(action)
+        Dir[response_folder.join("#{action}**")]
+      end
+
+      # TODO sig
+      def render_text_response(action)
+        file_path = response_folder.join("#{action}.txt.erb")
+
+        return nil unless exists?(file_path)
+
+        _render_sample_response file_path
+      end
+
+      # TODO sig
+      def render_html_response(action)
+        file_path = response_folder.join("#{action}.html.erb")
+
+        return nil unless exists?(file_path)
+
+        _render_response file_path
+      end
+
+      private
+
+      def _render_sample_response(file)
+        sample = File.read(file).split("###").map(&:strip).sample
+        ERB.new(sample).result(binding)
+      end
+
+      def _render_response(file)
+        sample = File.read(file)
+        ERB.new(sample).result(binding)
+      end
+
+
+      # TODO sig
+      def controller_path
+        controller_name.underscore
+      end
+
+      # TODO sig
+      def exists?(path)
+        File.exists?(path)
+      end
+
+      def exists!(path)
+        raise ResponseFileMissingError.new(path) unless exists?(path)
+      end
+
+    end
+  end
+end

data/lib/charyf/engine/dispatcher/base.rb

@@ -0,0 +1,121 @@
+require_relative '../../utils'
+
+require_relative '../context'
+require_relative '../request'
+
+module Charyf
+  module Engine
+    module Dispatcher
+      class Base
+
+        include Charyf::Strategy
+        def self.base
+          Base
+        end
+
+        sig ['Charyf::Engine::Request'], nil,
+        def dispatch(request)
+        end
+
+        def self.setup
+          # Do your setup here
+        end
+
+
+        protected
+
+        def self.intent_processors
+          Charyf.application.intent_processors
+        end
+
+        def self.session_processor
+          Charyf.application.session_processor
+        end
+
+        def intent_processors
+          self.class.intent_processors
+        end
+
+        def session_processor
+          self.class.session_processor
+        end
+
+        sig ['Charyf::Engine::Context'], nil,
+        def spawn_controller(context)
+          begin
+            prepare_context context
+
+            Charyf.logger.flow_request("[FLOW] Dispatching request [#{context.request.inspect}]" +
+                                        ", detected intent: [#{context.intent.inspect}]" +
+                                        ", session : [#{context.session.inspect}]"
+            )
+
+            controller = get_controller(context)
+
+            handle_before_actions(controller)
+            controller.send(context.action_name)
+            handle_after_actions(controller)
+          rescue Exception => e
+            # Dispatch the error to all error handlers
+            Charyf.configuration.error_handlers.handle_exception(e)
+
+            # Catch any error that may occur inside the user controller
+            controller.send(:reply, text: 'There was a problem processing your request. Check the logs please.')
+          end
+
+        end
+
+        private
+
+        def prepare_context(context)
+          context.intent ||= Charyf::Engine::Intent::UNKNOWN
+
+          context
+        end
+
+        def get_controller(context)
+          controller_name = context.full_controller_name +  'Controller'
+
+          Object.const_get(controller_name).new(context)
+        end
+
+        def get_action_name(context)
+          if context.session && context.session.action
+            return context.session.action
+          end
+
+          context.intent.action
+        end
+
+        def handle_before_actions(controller)
+          action = controller.action_name
+
+          # Handle before actions
+          controller.class._before_actions(action).each do |method_name|
+            controller.send(method_name)
+          end
+
+        end
+
+        def handle_after_actions(controller)
+          action = controller.action_name
+
+          # Auto render responses
+          if controller.class._render_on? action
+            controller.send(:reply)
+          end
+        end
+
+      end # End of Base.class
+
+      def self.known
+        Base.known
+      end
+
+      def self.list
+        Base.list
+      end
+
+    end
+  end
+end

data/lib/charyf/engine/dispatcher/default.rb

@@ -0,0 +1,60 @@
+require_relative 'base'
+
+module Charyf
+  module Engine
+    module Dispatcher
+      class BaseDispatcher < Base
+
+        strategy_name :default
+
+        def self.setup
+
+        end
+
+        def dispatch(request)
+          # Find if session exist for this request
+
+          context = Charyf::Engine::Context.new
+          context.request = request
+
+          # TODO process session as well
+          context.session = session_processor.get.process(request)
+
+          # Get intents
+          intents = intent_processors.collect do |processor_klass|
+            processor = processor_klass.get_for(context.session ? context.session.skill : nil)
+
+            processor.determine(
+                request
+            )
+          end.collect do |intent|
+            [intent, intent.alternatives].flatten
+          end.flatten.sort_by do |intent|
+            intent.confidence
+          end.reverse
+
+          # Sort by confidence
+          best_match = intents.shift
+
+          # Return best match with alternatives
+          if best_match
+            context.intent = Charyf::Engine::Intent.new(
+                best_match.skill,
+                best_match.controller,
+                best_match.action,
+                best_match.confidence,
+                best_match.matches,
+                intents
+            )
+
+            context.intent = best_match
+          end
+
+          # TODO
+          spawn_controller(context)
+        end
+
+      end
+    end
+  end
+end

data/lib/charyf/engine/intent/intent.rb

@@ -0,0 +1,54 @@
+module Charyf
+  module Engine
+    class Intent
+
+      sig [['Symbol', 'String', 'NilClass'], ['Symbol', 'String'], ['Symbol', 'String'], 'Numeric', 'Hash', 'Array'], nil,
+      def initialize(skill, controller, action, confidence, matches = Hash.new, alternatives = [])
+        @_skill = skill.to_s
+        @_controller = controller.to_s
+        @_action = action.to_s.downcase
+        @_confidence = confidence
+        @_matches = matches
+        @_alternatives = alternatives
+      end
+
+      sig [], 'Hash',
+      def matches
+        @_matches
+      end
+
+      sig [], 'Numeric',
+      def confidence
+        @_confidence
+      end
+
+      sig [], ['Symbol', 'String'],
+      def full_controller_name
+        @_skill.blank? ? @_controller.camelize : @_skill.camelize + '::' + @_controller.camelize
+      end
+
+      sig [], ['Symbol', 'String'],
+      def controller
+        @_controller
+      end
+
+      sig [], ['Symbol', 'String'],
+      def action
+        @_action
+      end
+
+      sig [], 'Array',
+      def alternatives
+        @_alternatives
+      end
+
+      sig [], ['String', 'Symbol'],
+      def skill
+        @_skill
+      end
+
+      UNKNOWN = Intent.new(nil, :Skill, :unknown, 0)
+
+    end
+  end
+end

data/lib/charyf/engine/intent/processors/dummy.rb

@@ -0,0 +1,30 @@
+require_relative '../../../utils'
+
+require_relative '../intent'
+require_relative 'processor'
+
+module Charyf
+  module Engine
+    class Intent
+      module Processor
+        class Dummy < Base
+
+          strategy_name :dummy
+
+          def self.get_for(skill_name = nil)
+            self.new
+          end
+
+          def determine(request)
+            unknown
+          end
+
+          def load(skill_name, block)
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/charyf/engine/intent/processors/helpers.rb

@@ -0,0 +1,32 @@
+module Charyf
+  module Engine
+    class Intent
+      module Processor
+        module Helpers
+
+          def self.included(base)
+            base.extend(ClassMethods)
+          end
+
+          module ClassMethods
+
+            def scoped_name(skill_name, *args)
+              ([skill_name.to_s] + args).join('_')
+            end
+
+            def unscope_name(skill_name, name)
+              name.start_with?(skill_name.to_s) ? name.sub("#{skill_name.to_s}_", '') : name
+            end
+
+          end # End of ClassMethods
+
+          sig [], 'Charyf::Engine::Intent',
+          def unknown
+            Charyf::Engine::Intent::UNKNOWN
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/charyf/engine/intent/processors/processor.rb

@@ -0,0 +1,56 @@
+require_relative '../../../utils'
+
+require_relative 'helpers'
+require_relative '../intent'
+
+module Charyf
+  module Engine
+    class Intent
+      module Processor
+        class Base
+
+          include Charyf::Strategy
+          include Charyf::Engine::Intent::Processor::Helpers
+
+          def self.base
+            Base
+          end
+
+          sig ['Charyf::Engine::Request'], 'Charyf::Engine::Intent',
+          def determine(request)
+            raise Charyf::Utils::NotImplemented.new
+          end
+
+          #
+          # Load single block of intent definitions
+          #
+          sig_self ['Symbol', 'Proc'], nil,
+          def load(skill_name, block)
+            raise Charyf::Utils::NotImplemented.new
+          end
+
+          sig_self ['Symbol'], 'Charyf::Engine::Intent::Processor::Base',
+          def self.get_for(skill = nil)
+            raise Charyf::Utils::NotImplemented.new
+          end
+
+          sig_self [], 'Charyf::Engine::Intent::Processor::Base',
+          def self.get_global
+            get_for(nil)
+          end
+
+        end
+
+
+        def self.known
+          Base.known
+        end
+
+        def self.list
+          Base.list
+        end
+
+      end
+    end
+  end
+end

data/lib/charyf/engine/interface/interface.rb

@@ -0,0 +1,35 @@
+require_relative '../../utils'
+
+require_relative '../response'
+require_relative '../dispatcher/base'
+
+module Charyf
+  module Interface
+    class Base
+
+      include Charyf::Strategy
+      def self.base
+        Base
+      end
+
+      sig_self [], 'Charyf::Engine::Dispatcher::Base',
+      def self.dispatcher
+        Charyf.application.dispatcher.new
+      end
+
+      sig_self ['String', 'Charyf::Engine::Response'], nil,
+      def self.reply(conversation_id, response)
+        raise Charyf::Utils::NotImplemented.new
+      end
+
+    end
+
+    def self.known
+      Base.known
+    end
+
+    def self.list
+      Base.list
+    end
+  end
+end

data/lib/charyf/engine/interface/program.rb

@@ -0,0 +1,59 @@
+require_relative 'interface'
+require_relative '../request'
+
+module Charyf
+  module Interface
+    class Program < Charyf::Interface::Base
+
+      class InvalidConversationError < StandardError; end
+
+      strategy_name :program
+
+      attr_reader :handler, :conversation_id
+
+      sig_self ['String', 'Charyf::Engine::Response'], nil,
+      def self.reply(conversation_id, response)
+        interface = _interfaces[conversation_id]
+        raise InvalidConversationError.new("No program interface found for conversation #{conversation_id}") unless interface
+
+        interface.reply(response)
+      end
+
+      sig_self ['String', 'Proc'], 'Charyf::Interface::Program',
+      def self.create(conversation_id, handler)
+        interface = self.new(conversation_id, handler)
+
+        _interfaces[conversation_id] = interface
+
+        interface
+      end
+
+      def self._interfaces
+        @_interfaces ||= Hash.new
+      end
+
+      sig [nil, 'Proc'],
+      def initialize(conversation_id, handler)
+
+        @handler = handler
+        @conversation_id = conversation_id.to_s
+      end
+
+      sig ['Charyf::Engine::Request'],
+      def process(request)
+        self.class.dispatcher.dispatch(request)
+      end
+
+      sig ['Charyf::Engine::Response'],
+      def reply(response)
+        handler.call(response)
+      end
+
+      sig [], 'Charyf::Engine::Request',
+      def request
+        Charyf::Engine::Request.new(self.class, conversation_id)
+      end
+
+    end
+  end
+end

data/lib/charyf/engine/request.rb

@@ -0,0 +1,32 @@
+module Charyf
+  module Engine
+    class Request
+
+      attr_accessor :text
+
+      # Module -> anything of type Charyf::Interface::Base
+      sig ['Module', 'String'], nil,
+      def initialize(referer, conversation_id)
+        @referer = referer
+        @conversation_id = conversation_id
+      end
+
+      # Module -> Charyf::Interface::Base
+      sig [], 'Module',
+      def referer
+        @referer
+      end
+
+      sig [], 'String',
+      def conversation_id
+        @conversation_id
+      end
+
+      sig [], 'String',
+      def id
+        @referer.strategy_name.to_s + '_#_' + @conversation_id
+      end
+
+    end
+  end
+end

data/lib/charyf/engine/response.rb

@@ -0,0 +1,41 @@
+module Charyf
+  module Engine
+    class Response
+
+      attr_accessor :text, :html
+
+      sig [['String', 'NilClass'], ['String', 'NilClass']], nil,
+      def initialize(text, html)
+        @text = text
+        @html = html
+      end
+
+      def empty?
+        text.blank? && html.blank?
+      end
+
+      # Attr methods for type-checking
+
+      sig ['String', 'NilClass'], ['String', 'NilClass'],
+      def text=(text)
+        @text = text
+      end
+
+      sig [], ['String', 'NilClass'],
+      def text
+        @text
+      end
+
+      sig ['String', 'NilClass'], ['String', 'NilClass'],
+      def html=(html)
+        @html = html
+      end
+
+      sig [], ['String', 'NilClass'],
+      def html
+        @html
+      end
+
+    end
+  end
+end

data/lib/charyf/engine/session/processors/default.rb

@@ -0,0 +1,42 @@
+require_relative '../../../utils'
+
+require_relative '../session'
+require_relative 'processor'
+
+module Charyf
+  module Engine
+    class Session
+      module Processor
+        class Default < Base
+
+          # 10 Minute
+          # TODO - move to config?
+          SESSION_TIMEOUT = 10 * 60
+
+          strategy_name :default
+
+          def process(request)
+            # session = Charyf::Engine::Session.get(request.id)
+            #
+            # return unless session
+            #
+            # if session && Time.now - session.timestamp > SESSION_TIMEOUT
+            #   session.destroy!
+            #   return nil
+            # end
+            #
+            # session.invalidate!
+            # session
+
+            nil
+          end
+
+          def self.get
+            self.new
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/charyf/engine/session/processors/processor.rb

@@ -0,0 +1,39 @@
+require_relative '../../../utils'
+
+module Charyf
+  module Engine
+    class Session
+      module Processor
+        class Base
+
+          include Charyf::Strategy
+          def self.base
+            Base
+          end
+
+
+          sig ['Charyf::Engine::Request'], ['Charyf::Engine::Session', 'NilClass'],
+          def process(request)
+            raise Charyf::Utils::NotImplemented.new
+          end
+
+          sig_self [], ['Charyf::Engine::Session::Processor::Base'],
+          def self.get
+            raise Charyf::Utils::NotImplemented.new
+          end
+
+        end
+
+
+        def self.known
+          Base.known
+        end
+
+        def self.list
+          Base.list
+        end
+
+      end
+    end
+  end
+end