charyf 0.1.1

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

@@ -0,0 +1,68 @@
+require 'yaml'
+
+module Charyf
+  module Engine
+    class Session
+
+      attr_reader :uuid, :skill, :controller, :action, :timestamp
+
+      # TODO - mention it could return nil
+      # TODO sig
+      def self.get(uuid)
+        yaml = _storage.get(uuid)
+        yaml ? YAML.load(yaml) : nil
+      end
+
+      def self.init(uuid, skill_name)
+        session = self.new(uuid, skill_name)
+
+        _storage.store(uuid, YAML.dump(session))
+
+        session
+      end
+
+      def route_to(controller, action)
+        @controller = controller
+        @action = action
+      end
+
+      def storage
+        @storage ||= Charyf.application.storage_provider.get_for("#{self.class}_#{@uuid}")
+      end
+
+      def keep!
+        @active = true
+        store!
+      end
+
+      def invalidate!
+        @active = false
+        self.class._storage.remove(@uuid)
+      end
+
+      def store!
+        @timestamp = Time.now
+        self.class._storage.store(@uuid, YAML.dump(self))
+      end
+
+      sig [], ['Symbol', 'String', 'NilClass'],
+      def full_controller_name
+        @controller.blank? ? nil : @skill.camelize + '::' + @controller.camelize
+      end
+
+      private
+
+      def initialize(uuid, skill)
+        @uuid = uuid
+        @skill = skill
+        @active = true
+        @timestamp = Time.now
+      end
+
+      def self._storage
+        @storage ||= Charyf.application.storage_provider.get_for(self)
+      end
+
+    end
+  end
+end

data/lib/charyf/engine/skill/info.rb

@@ -0,0 +1,24 @@
+module Charyf
+  module Skill
+    module Info
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        sig ['String', 'Symbol', 'NilClass'], ['Symbol'],
+        def skill_name(name = nil)
+          if name
+            @_name = name.to_sym
+          end
+
+          @_name || self.name.gsub('::', ' ')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/charyf/engine/skill/routing.rb

@@ -0,0 +1,57 @@
+module Charyf
+  module Skill
+    module Routing
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        sig ['Pathname'], ['Pathname'],
+        def routing_source_dir(abs_path = nil)
+          if abs_path
+            @_routing_source_dir = abs_path
+          end
+
+          @_routing_source_dir || skill_root.join('intents')
+        end
+
+        def public_routing_for(processor_name)
+          _public_routing(processor_name) << Proc.new
+
+          nil
+        end
+
+        def private_routing_for(processor_name)
+          _private_routing(processor_name) << Proc.new
+
+          nil
+        end
+
+
+        def _public_routing(processor)
+          processor = processor.to_sym
+
+          @_public_routing ||= Hash.new
+
+          @_public_routing[processor] ||= []
+
+          @_public_routing[processor]
+        end
+
+        def _private_routing(processor)
+          processor = processor.to_sym
+
+          @_public_routing ||= Hash.new
+
+          @_public_routing[processor] ||= []
+
+          @_public_routing[processor]
+        end
+
+      end # End of ClassMethods
+
+    end
+  end
+end

data/lib/charyf/engine/skill/skill.rb

@@ -0,0 +1,40 @@
+require_relative 'routing'
+require_relative 'info'
+
+module Charyf
+  module Skill
+    class Base
+
+      include Charyf::Skill::Routing
+      include Charyf::Skill::Info
+
+      class << self
+        attr_accessor :_file_path, :_file_name
+
+        def inherited(subclass)
+          Base._subclasses[subclass.name.demodulize] = subclass
+
+          # TODO this should be tested
+          subclass._file_path = Pathname.new(caller.first[/^[^:]+/]).dirname
+          subclass._file_name = Pathname.new(caller.first[/^[^:]+/]).basename
+        end
+
+        def _subclasses
+          @_subclasses ||= Hash.new
+        end
+
+      end
+
+      def self.skill_root
+        self._file_path.join(self._file_name.sub_ext(''))
+      end
+
+
+    end
+
+    def self.list
+      Base._subclasses.values
+    end
+
+  end
+end

data/lib/charyf/engine.rb

@@ -0,0 +1,3 @@
+require_relative 'utils'
+
+require_relative 'engine/all'

data/lib/charyf/support/all.rb

@@ -0,0 +1,4 @@
+require_relative 'hash'
+require_relative 'object'
+require_relative 'string'
+require_relative 'string_inquirer'

data/lib/charyf/support/hash.rb

@@ -0,0 +1,43 @@
+class Hash
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  #
+  #   h1 = { a: true, b: { c: [1, 2, 3] } }
+  #   h2 = { a: false, b: { x: [3, 4, 5] } }
+  #
+  #   h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+  #
+  # Like with Hash#merge in the standard library, a block can be provided
+  # to merge values:
+  #
+  #   h1 = { a: 100, b: 200, c: { c1: 100 } }
+  #   h2 = { b: 250, c: { c1: 200 } }
+  #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
+  #   # => { a: 100, b: 450, c: { c1: 300 } }
+  def deep_merge(other_hash, options = {}, &block)
+    dup.deep_merge!(other_hash, options, &block)
+  end
+
+  # Same as +deep_merge+, but modifies +self+.
+  def deep_merge!(other_hash, options = {}, &block)
+    other_hash.each_pair do |current_key, other_value|
+      this_value = self[current_key]
+
+      self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+                            this_value.deep_merge(other_value, options, &block)
+                          elsif options[:union_arrays] && (this_value.is_a?(Array) || other_value.is_a?(Array))
+                            this_values = this_value.is_a?(Array) ? this_value : [this_value]
+                            other_values = other_value.is_a?(Array) ? other_value : [other_value]
+
+                            this_values | other_values
+                          else
+                            if block_given? && key?(current_key)
+                              block.call(current_key, this_value, other_value)
+                            else
+                              other_value
+                            end
+                          end
+    end
+
+    self
+  end
+end

data/lib/charyf/support/object.rb

@@ -0,0 +1,7 @@
+class Object
+
+  def blank?
+    respond_to?(:empty?) ? !!empty? : !self
+  end
+
+end

data/lib/charyf/support/string.rb

@@ -0,0 +1,94 @@
+class String
+  def camelize
+    self.split('_').collect(&:capitalize).join
+  end
+
+  def underscore
+    self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+  end
+
+  def constantize
+    camel_cased_word = self
+
+    names = camel_cased_word.split('::')
+
+    # Trigger a built-in NameError exception including the ill-formed constant in the message.
+    Object.const_get(camel_cased_word) if names.empty?
+
+    # Remove the first blank element in case of '::ClassName' notation.
+    names.shift if names.size > 1 && names.first.empty?
+
+    names.inject(Object) do |constant, name|
+      if constant == Object
+        constant.const_get(name)
+      else
+        candidate = constant.const_get(name)
+        next candidate if constant.const_defined?(name, false)
+        next candidate unless Object.const_defined?(name)
+
+        # Go down the ancestors to check if it is owned directly. The check
+        # stops when we reach Object or the end of ancestors tree.
+        constant = constant.ancestors.inject do |const, ancestor|
+          break const    if ancestor == Object
+          break ancestor if ancestor.const_defined?(name, false)
+          const
+        end
+
+        # owner is in Object, so raise
+        constant.const_get(name, false)
+      end
+    end
+  end
+
+  def deconstantize
+    self.to_s[0, self.rindex("::") || 0]
+  end
+
+  def demodulize
+    if (i = self.rindex("::"))
+      self[(i + 2)..-1]
+    else
+      self
+    end
+  end
+
+  def squish
+    dup.squish!
+  end
+
+  def squish!
+    gsub!(/\A[[:space:]]+/, '')
+    gsub!(/[[:space:]]+\z/, '')
+    gsub!(/[[:space:]]+/, ' ')
+    self
+  end
+
+  def trim(str=nil)
+    return self.ltrim(str).rtrim(str)
+  end
+
+  def ltrim(str=nil)
+    if (!str)
+      return self.lstrip
+    else
+      escape = Regexp.escape(str)
+    end
+
+    return self.gsub(/^#{escape}+/, "")
+  end
+
+  def rtrim(str=nil)
+    if (!str)
+      return self.rstrip
+    else
+      escape = Regexp.escape(str)
+    end
+
+    return self.gsub(/#{escape}+$/, "")
+  end
+
+end

data/lib/charyf/support/string_inquirer.rb

@@ -0,0 +1,17 @@
+module Charyf
+  class StringInquirer < String
+    private
+
+    def respond_to_missing?(method_name, include_private = false)
+      (method_name[-1] == "?") || super
+    end
+
+    def method_missing(method_name, *arguments)
+      if method_name[-1] == "?"
+        self == method_name[0..-2]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/charyf/support.rb

@@ -0,0 +1 @@
+require_relative 'support/all'

data/lib/charyf/utils/all.rb

@@ -0,0 +1,13 @@
+require_relative 'parser/parser'
+require_relative 'parser/en_parser'
+
+require_relative 'storage/provider'
+
+require_relative 'application'
+require_relative 'charyf'
+require_relative 'error_handler'
+require_relative 'initializable'
+require_relative 'logger'
+require_relative 'machine'
+require_relative 'strategy'
+require_relative 'utils'

data/lib/charyf/utils/app_engine/extensions.rb

@@ -0,0 +1,21 @@
+module Charyf
+  class AppEngine < Extension
+    class Extensions
+      include Enumerable
+      attr_reader :_all
+
+      def initialize
+        @_all ||= ::Charyf::Extension.subclasses.map(&:instance) +
+            ::Charyf::AppEngine.subclasses.map(&:instance)
+      end
+
+      def each(*args, &block)
+        _all.each(*args, &block)
+      end
+
+      def -(others)
+        _all - others
+      end
+    end
+  end
+end

data/lib/charyf/utils/app_engine.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'extension'
+require_relative 'app_engine/extensions'
+
+module Charyf
+  class AppEngine < Extension
+
+    # Load Charyf generators and invoke the registered hooks.
+    # Check <tt>Charyf::Extension.generators</tt> for more info.
+    def load_generators(app = self)
+      require_relative 'generators'
+      Charyf::Generators.configure!(app.config.generators)
+
+      require_relative 'generators/app/app_generator'
+      require_relative 'generators/skill/skill_generator'
+      require_relative 'generators/intents/intents_generator'
+
+      run_generators_blocks(app)
+      self
+    end
+
+  end
+end

data/lib/charyf/utils/app_loader.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Charyf
+  module AppLoader # :nodoc:
+    extend self
+
+    RUBY = Gem.ruby
+    EXECUTABLES = %w(bin/charyf charyf/bin/charyf)
+
+    def exec_app
+      original_cwd = Dir.pwd
+
+      loop do
+        if exe = find_executable
+          contents = File.read(exe)
+
+          if contents =~ /(APP|ENGINE)_PATH/
+            exec RUBY, exe, *ARGV
+            break # non reachable, hack to be able to stub exec in the test suite
+          end
+        end
+
+        # If we exhaust the search there is no executable, this could be a
+        # call to generate a new application, so restore the original cwd.
+        Dir.chdir(original_cwd) && return if Pathname.new(Dir.pwd).root?
+
+        # Otherwise keep moving upwards in search of an executable.
+        Dir.chdir("..")
+      end
+    end
+
+    def find_executable
+      EXECUTABLES.find { |exe| File.file?(exe) }
+    end
+  end
+end

data/lib/charyf/utils/application/bootstrap.rb

@@ -0,0 +1,176 @@
+require_relative '../app_engine'
+require_relative '../initializable'
+require_relative '../utils'
+require 'i18n'
+
+module Charyf
+  class Application < AppEngine
+    # noinspection RubyResolve
+    module Bootstrap
+
+      class SkillLoadError < StandardError
+        def initialize(e, skill_name, skill_path)
+          super(e)
+
+          @_name = skill_name
+          @_path = skill_path.dirname
+        end
+
+        def message
+          _message + super
+        end
+
+        def _message
+          <<-EOS
+          
+          Unable to load skill #{@_name}
+          Expected to find: '#{@_name}.rb'
+                Located at: '#{@_path}'
+
+EOS
+        end
+      end
+
+      include Charyf::Initializable
+
+      class InitializationError < StandardError; end
+
+      #
+      # Load app environment configuration files
+      # Default application configuration is when a command is triggered
+      # Nothing loaded unless environment file exists
+      #
+      initializer :load_environment, group: :all do
+        Charyf.logger.info "Charyf starting in #{Charyf.env} mode."
+
+        env_file = self.config.root.join('config', 'environments', "#{Charyf.env}.rb")
+
+        if FileTest.exists?(env_file)
+          require env_file
+        end
+      end
+
+      initializer :set_load_paths, group: :all do
+        libdir = File.expand_path(self.config.root.join('lib'))
+        $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+      end
+
+      #
+      # Loads I18N
+      #
+      initializer :load_i18n, group: :all do
+        I18n.load_path << Dir[Charyf._gem_source.join('locale', '**', '*.yml').to_s]
+      end
+
+      #
+      # Validates that all required strategies are fulfilled and the application can load
+      #
+      initializer :validate_strategies, group: :all do
+        Charyf.application.session_processor
+        Charyf.application.intent_processors
+        Charyf.application.dispatcher
+      end
+
+      #
+      # Load APP default files
+      #
+      initializer :load_defaults, group: :all do
+        require self.config.root.join('app', 'skill_controller.rb')
+
+      end
+
+      #
+      # Find all skills located in [YourApp]/app/skills/
+      #
+      initializer :load_skill_dir, group: :all do
+        # TODO revisit this
+        condition = lambda do |path|
+          in_root_dir = path.dirname.basename.to_s == 'skills'
+          contain_skill = Dir[path.dirname.join('**', '**')].any? { |p| p.include?('/controllers') } &&
+                          Dir[path.dirname.join('**', '**')].any? { |p| p.include?('/intents') }
+          return in_root_dir || contain_skill
+        end
+
+        # Require skill level files
+        Charyf::Utils.require_recursive self.config.root.join('app', 'skills'),
+                                        condition: condition
+
+        # Require controllers
+        Charyf::Skill.list.each do |skill_klass|
+          # Load initializers
+          root = skill_klass.skill_root
+
+          Dir[root.join('controllers', '**', '*.rb')].each do |controller|
+            require controller
+          end
+        end
+      end
+
+      #
+      # Load all intents
+      #
+      initializer :load_skill_intents, groups: :all do
+        # Require Skill intents
+        Charyf::Skill.list.each do |skill_klass|
+          Dir[skill_klass.routing_source_dir.join('**', '*.rb')].each do |file|
+            require file
+          end
+        end
+
+        Charyf::Skill.list.each do |skill_klass|
+          skill_name = skill_klass.skill_name
+
+          Charyf.application.intent_processors.each do |processor|
+            # Public routing
+            skill_klass._public_routing(processor.strategy_name).each do |block|
+              processor.get_global.load skill_name, block
+            end
+
+            # Private routing
+            skill_klass._private_routing(processor.strategy_name).each do |block|
+              processor.get_for(skill_name).load skill_name, block
+            end
+
+          end
+        end
+      end
+
+      #
+      # Load all user skill files
+      #  - controllers
+      #
+      initializer :load_skill_controllers, group: :all do
+
+        Charyf::Skill.list.each do |skill_klass|
+
+          # Load controllers
+          root = skill_klass.skill_root
+
+          Dir[root.join('controllers', '**', '*.rb')].each do |controller|
+            require controller
+          end
+
+        end
+      end
+
+      #
+      # Load user initializer files
+      #
+      initializer :run_initializers, group: :all do
+        Dir[self.config.root.join('config', 'initializers', '**', '**.rb')].each do |initializer|
+          require initializer
+        end
+
+        Charyf::Skill.list.each do |skill_klass|
+          # Load initializers
+          root = skill_klass.skill_root
+
+          Dir[root.join('initializers', '**', '*.rb')].each do |initializer|
+            require initializer
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/charyf/utils/application/configuration.rb

@@ -0,0 +1,51 @@
+require_relative '../app_engine'
+require_relative '../extension/configuration'
+
+module Charyf
+  class Application < AppEngine
+    class Configuration < Extension::Configuration
+
+      attr_reader :root
+
+      attr_accessor :console
+
+      attr_accessor :session_processor, :storage_provider, :dispatcher
+      attr_accessor :enabled_intent_processors
+
+      def initialize(root)
+
+        @root = root
+
+      end
+
+      def i18n
+        I18n
+      end
+
+      def error_handlers
+        Charyf::ErrorHandlers
+      end
+
+      sig [], ['Symbol', 'NilClass'],
+      def dispatcher
+        (@dispatcher || 'default').to_sym
+      end
+
+      sig [], ['Symbol'],
+      def session_processor
+        (@session_processor || 'default').to_sym
+      end
+
+      sig [], [Array],
+      def enabled_intent_processors
+        (@enabled_intent_processors || []).map(&:to_sym)
+      end
+
+      sig [], ['Symbol', 'NilClass'],
+      def storage_provider
+        @storage_provider ? @storage_provider.to_sym : nil
+      end
+
+    end
+  end
+end