charyf 0.1.1

data/lib/charyf/utils/application.rb

@@ -0,0 +1,131 @@
+require_relative 'configuration'
+
+require_relative 'application/configuration'
+require_relative 'application/bootstrap'
+
+require_relative 'app_engine'
+require_relative 'utils'
+
+require_relative '../support'
+
+module Charyf
+  class Application < AppEngine
+
+    include Charyf::Initializable
+
+    class << self
+      attr_accessor :called_from
+
+      def inherited(base)
+        super
+        Charyf.app_class = base
+
+        base.called_from = begin
+          call_stack = caller_locations.map { |l| l.absolute_path || l.path }
+
+          File.dirname(call_stack.detect { |p| p !~ %r[charyf[\w.-]*/lib/utils] })
+        end
+      end
+
+      def instance
+        super.run_load_hooks!
+      end
+
+      def find_root(from)
+        Charyf::Utils.find_root_with_flag 'config/chapp.rb', from
+      end
+
+      def config
+        instance.config
+      end
+
+    end
+
+    def initialize!(group: :default)
+      return self if @initialized
+      @initialized = true
+
+      run_initializers(group, self)
+    end
+
+    def run_load_hooks!
+      return self if @ran_load_hooks
+      @ran_load_hooks = true
+
+      # Todo LOAD Hooks should be here
+      self
+    end
+
+    def config
+      @config ||= Application::Configuration.new(self.class.find_root(self.class.called_from))
+    end
+
+    def configure(&block)
+      instance_eval(&block)
+    end
+
+    # TODO sig, nullable
+    def session_processor
+      # TODO resolve dependency on engine - maybe move the base classes to utils?
+      klass = Charyf::Engine::Session::Processor.list[config.session_processor]
+      raise Charyf::Utils::InvalidConfiguration.new("No storage processor strategy with name '#{config.session_processor}' found") unless klass
+
+      klass
+    end
+
+    def intent_processors
+      # TODO resolve dependency on engine - maybe move the base classes to utils?
+      klasses = config.enabled_intent_processors.map do |processor_name|
+        klass = Charyf::Engine::Intent::Processor.list[processor_name]
+        raise Charyf::Utils::InvalidConfiguration.new("No intent processor strategy with name '#{processor_name}' found") unless klass
+
+        klass
+      end
+
+      raise Charyf::Utils::InvalidConfiguration.new('No intent processor strategies specified') if klasses.empty?
+
+      klasses
+    end
+
+    def dispatcher
+      # TODO resolve dependency on engine - maybe move the base classes to utils?
+      klass = Charyf::Engine::Dispatcher.list[config.dispatcher]
+      raise Charyf::Utils::InvalidConfiguration.new("No dispatcher with name '#{config.dispatcher}' found") unless klass
+
+      klass
+    end
+
+    # TODO sig, nullable
+    def storage_provider
+      klass = Charyf::Utils::StorageProvider.list[config.storage_provider]
+      raise Charyf::Utils::InvalidConfiguration.new("No storage provider with name '#{config.storage_provider}' found") unless klass
+
+      klass
+    end
+
+    def parser
+      klass = Charyf::Utils::Parser.get(config.i18n.locale)
+      raise Charyf::Utils::InvalidConfiguration.new("No parser for locale '#{config.i18n.locale}' found") unless klass
+
+      klass
+    end
+
+    protected
+
+    def run_generators_blocks(app) #:nodoc:
+      extensions.each { |r| r.run_generators_blocks(app) }
+      super
+    end
+
+    def initializers
+      Bootstrap.initializers_for(self)
+    end
+
+    private
+
+    def extensions
+      @extensions ||= Extensions.new
+    end
+
+  end
+end

data/lib/charyf/utils/charyf.rb

@@ -0,0 +1,44 @@
+require 'fileutils'
+
+module Charyf
+
+  class << self
+    @application = @app_class = nil
+
+    attr_accessor :app_class
+
+    def application
+      @application ||= (@app_class.instance if app_class)
+    end
+
+    def configuration
+      application.config
+    end
+
+    def root
+      application && application.config.root
+    end
+
+    def env
+      @_env ||= Charyf::StringInquirer.new(ENV["CHARYF_ENV"] || "development")
+    end
+
+    def env=(environment)
+      @_env = Charyf::StringInquirer.new(environment)
+    end
+
+    def logger
+      return @logger if @logger
+
+      FileUtils.mkdir_p root.join('log')
+      @logger = Charyf::Logger.new(Charyf.root.join('log', "#{env}.log"))
+    end
+
+    def groups(*groups)
+      # TODO
+      [:default, env]
+    end
+
+  end
+
+end

data/lib/charyf/utils/cli.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'app_loader'
+
+# If we are inside a Charyf application this method performs an exec and thus
+# the rest of this script is not run.
+Charyf::AppLoader.exec_app
+
+require_relative 'ruby_version_check'
+Signal.trap("INT") { puts; exit(1) }
+
+require_relative 'command'
+
+Charyf::Command.invoke :application, ARGV

data/lib/charyf/utils/command/actions.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Charyf
+  module Command
+    module Actions
+
+      # def set_application_directory!
+      #   Dir.chdir(File.expand_path("../..", APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
+      # end
+
+      def require_application_and_environment!
+        if defined?(APP_PATH)
+          require APP_PATH
+          Charyf.application.initialize!
+        end
+      end
+
+      def load_generators
+        Charyf.application.load_generators
+      end
+
+    end
+  end
+end

data/lib/charyf/utils/command/base.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'erb'
+
+require_relative 'actions'
+
+module Charyf
+  module Command
+    class Base < Thor
+      class Error < Thor::Error # :nodoc:
+      end
+
+      include Actions
+
+      class << self
+
+        # Tries to get the description from a USAGE file one folder above the command
+        # root.
+        def desc(usage = nil, description = nil, options = {})
+          if usage
+            super
+          else
+            @desc ||= ERB.new(File.read(desc_file)).result(binding) if desc_file
+          end
+        end
+
+        def desc_file(desc_file = nil)
+          @desc_file = desc_file if desc_file
+
+          @desc_file if @desc_file && File.exist?(@desc_file)
+        end
+
+        # Convenience method to get the namespace from the class name. It's the
+        # same as Thor default except that the Command at the end of the class
+        # is removed.
+        def namespace(name = nil)
+          if name
+            super
+          else
+            @namespace ||= super.chomp("_command").sub(/:command:/, ":")
+          end
+        end
+
+        # Convenience method to hide this command from the available ones when
+        # running charyf help command.
+        def hide_command!
+          Charyf::Command.hidden_commands << self
+        end
+
+        def inherited(base) #:nodoc:
+          super
+
+          if base.name && base.name !~ /Base$/
+            Charyf::Command.subclasses << base
+          end
+        end
+
+        def perform(command, args, config) # :nodoc:
+          if Charyf::Command::HELP_MAPPINGS.include?(args.first)
+            command, args = "help", []
+          end
+
+          dispatch(command, args.dup, nil, config)
+        end
+
+        def printing_commands
+          namespaced_commands
+        end
+
+        def executable
+          "bin/charyf #{command_name}"
+        end
+
+        def banner(*)
+          "#{executable} #{arguments.map(&:usage).join(' ')} [options]".squish
+        end
+
+        # Sets the base_name taking into account the current class namespace.
+        #
+        #   Charyf::Command::TestCommand.base_name # => 'charyf'
+        def base_name
+          @base_name ||= begin
+            if base = name.to_s.split("::").first
+              base.underscore
+            end
+          end
+        end
+
+        # Return command name without namespaces.
+        #
+        #   Charyf::Command::TestCommand.command_name # => 'test'
+        def command_name
+          @command_name ||= begin
+            if command = name.to_s.split("::").last
+              command.chomp!("Command")
+              command.underscore
+            end
+          end
+        end
+
+        private
+        # Allow the command method to be called perform.
+        def create_command(meth)
+          if meth == "perform"
+            alias_method command_name, meth
+          else
+            # Prevent exception about command without usage.
+            # Some commands define their documentation differently.
+            @usage ||= ""
+            @desc ||= ""
+
+            super
+          end
+        end
+
+        def command_root_namespace
+          (namespace.split(":") - %w( charyf )).first
+        end
+
+        def namespaced_commands
+          commands.keys.map do |key|
+            key == command_root_namespace ? key : "#{command_root_namespace}:#{key}"
+          end
+        end
+      end
+
+      def help
+        if command_name = self.class.command_name
+          self.class.command_help(shell, command_name)
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/charyf/utils/command/behavior.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require_relative '../../support'
+
+module Charyf
+  module Command
+    module Behavior #:nodoc:
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        # Track all subclasses.
+        def subclasses
+          @subclasses ||= []
+        end
+
+        # Remove the color from output.
+        def no_color!
+          Thor::Base.shell = Thor::Shell::Basic
+        end
+
+        private
+
+        # This code is based dir
+        # Prints a list of generators.
+        def print_list(base, namespaces)
+          return if namespaces.nil? ||namespaces.empty?
+          puts "#{base.camelize}:"
+
+          namespaces.each do |namespace|
+            puts("  #{namespace}")
+          end
+
+          puts
+        end
+
+        # This code is based directly on the Text gem implementation.
+        # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
+        #
+        # Returns a value representing the "cost" of transforming str1 into str2.
+        def levenshtein_distance(str1, str2) # :doc:
+          s = str1
+          t = str2
+          n = s.length
+          m = t.length
+
+          return m if (0 == n)
+          return n if (0 == m)
+
+          d = (0..m).to_a
+          x = nil
+
+          # avoid duplicating an enumerable object in the loop
+          str2_codepoint_enumerable = str2.each_codepoint
+
+          str1.each_codepoint.with_index do |char1, i|
+            e = i + 1
+
+            str2_codepoint_enumerable.with_index do |char2, j|
+              cost = (char1 == char2) ? 0 : 1
+              x = [
+                  d[j + 1] + 1, # insertion
+                  e + 1,      # deletion
+                  d[j] + cost # substitution
+              ].min
+              d[j] = e
+              e = x
+            end
+
+            d[m] = x
+          end
+
+          x
+        end
+
+      end
+    end
+  end
+end

data/lib/charyf/utils/command/environment_argument.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Charyf
+  module Command
+    module EnvironmentArgument #:nodoc:
+
+
+      def self.included(base)
+        base.class_option :environment, aliases: "-e", type: :string,
+                     desc: "Specifies the environment to run this console under (test/development/production)."
+      end
+
+      private
+      def extract_environment_option
+        if options[:environment]
+          self.options = options.merge(environment: acceptable_environment(options[:environment]))
+        else
+          self.options = options.merge(environment: Charyf::Command.environment)
+        end
+      end
+
+      def acceptable_environment(env = nil)
+        if available_environments.include? env
+          env
+        else
+          %w( production development test ).detect { |e| e =~ /^#{env}/ } || env
+        end
+      end
+
+      def available_environments
+        if Object.const_defined? 'APP_PATH'
+          app_path = File.expand_path("..", APP_PATH)
+          return Dir[app_path + "/environments/*.rb"].map { |fname| File.basename(fname, ".*") }
+        end
+
+        []
+      end
+    end
+  end
+end

data/lib/charyf/utils/command.rb

@@ -0,0 +1,106 @@
+require_relative '../support/object'
+require_relative 'command/base'
+require_relative 'command/behavior'
+
+module Charyf
+  module Command
+
+    HELP_MAPPINGS = %w(-h -? --help)
+
+    include Behavior
+
+    class << self
+
+      def environment # :nodoc:
+        ENV['CHARYF_ENV'] ? ENV['CHARYF_ENV'] : 'development'
+      end
+
+      def hidden_commands # :nodoc:
+        @hidden_commands ||= []
+      end
+
+      def load_commands!
+        require_relative 'commands/all'
+      end
+
+      # Receives a namespace, arguments and the behavior to invoke the command.
+      def invoke(full_namespace, args = [], **config)
+        load_commands!
+
+        namespace = full_namespace = full_namespace.to_s
+
+        if char = namespace =~ /:(\w+)$/
+          command_name, namespace = $1, namespace.slice(0, char)
+        else
+          command_name = namespace
+        end
+
+        command_name, namespace = "help", "help" if command_name.blank? || HELP_MAPPINGS.include?(command_name)
+        command_name, namespace = "version", "version" if %w( -v --version ).include?(command_name)
+
+        command = find_by_namespace(namespace, command_name)
+
+        # if command && command.all_commands[command_name]
+        if command
+          command.perform(command_name, args, config)
+        else
+          $stderr.puts "Unknown command #{full_namespace}\n\n"
+          command_name, namespace = "help", "help"
+          command = find_by_namespace(namespace, command_name)
+          command.perform(command_name, args, config)
+        end
+
+        # else
+        #   find_by_namespace("rake").perform(full_namespace, args, config)
+        # end
+      end
+
+      def find_by_namespace(namespace, command_name = nil) # :nodoc:
+        lookups = [namespace]
+        lookups << "#{namespace}:#{command_name}" if command_name
+        lookups.concat lookups.map {|lookup| "charyf:#{lookup}"}
+
+        namespaces = subclasses.inject(Hash.new) {|h, n| h[n.namespace] = n; h}
+        namespaces[(lookups & namespaces.keys).first]
+      end
+
+      def print_commands # :nodoc:
+        sorted_groups.each {|b, n| print_list(b, n)}
+      end
+
+      def sorted_groups # :nodoc:
+        groups = (subclasses - hidden_commands).group_by {|c| c.namespace.split(":").first}
+
+        groups.keys.each do |key|
+          groups[key] = groups[key].flat_map(&:printing_commands).sort
+        end
+
+        charyf = groups.delete('charyf')
+        [['charyf', charyf]] + groups.sort.to_a
+      end
+
+      # Returns the root of the Charyf engine or app running the command.
+      def root
+        if defined?(APP_PATH)
+          Pathname.new(File.expand_path("../..", APP_PATH))
+        end
+      end
+
+      private
+
+      def command_type # :doc:
+        @command_type ||= "command"
+      end
+
+      def lookup_paths # :doc:
+        @lookup_paths ||= %w( charyf/commands commands charyf/commands )
+      end
+
+      def file_lookup_paths # :doc:
+        @file_lookup_paths ||= ["{#{lookup_paths.join(',')}}", "**", "*_command.rb"]
+      end
+
+    end # End of self
+
+  end
+end

data/lib/charyf/utils/commands/all.rb

@@ -0,0 +1,6 @@
+require_relative 'application/application_command'
+require_relative 'cli/cli_command'
+require_relative 'console/console_command'
+require_relative 'generate/generate_command'
+require_relative 'destroy/destroy_command'
+require_relative 'help/help'

data/lib/charyf/utils/commands/application/application_command.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../../generators'
+require_relative '../../generators/app/app_generator'
+
+module Charyf
+  module Command
+    class ApplicationCommand < Base # :nodoc:
+      hide_command!
+
+      def help
+        perform # Punt help output to the generator.
+      end
+
+      def perform(*args)
+        Charyf::Generators::AppGenerator.start \
+          Charyf::Generators::ARGVScrubber.new(args).prepare!
+      end
+    end
+  end
+end