charyf 0.1.1

data/lib/charyf/utils/commands/cli/cli_command.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative '../../command/base'
+require_relative '../../command/environment_argument'
+
+module Charyf
+  class CLI
+
+    def self.start
+      self.new.start
+    end
+
+    def start
+      build_interface
+      print_intro
+
+      begin
+        loop do
+          detect request_input
+        end
+      rescue Interrupt
+        puts "\n"
+        puts 'Exiting CLI'
+      end
+    end
+
+    private
+
+    def print_intro
+      puts <<-EOM
+  Initialized #{Charyf.env} environment (Charyf #{Charyf.version})
+  Welcome to the Charyf CLI Interface.
+  Type ":help" for ist of available commands
+  To exit pres ctrl + c
+      EOM
+    end
+
+    def print_help
+      puts <<-EOM
+  :help             prints this help
+  :exit             quit the charyf cli
+                    alternatively use ctrl + d (EOM)  
+                                   or ctrl + c (KILL)
+      EOM
+    end
+
+    def request_input
+      print '[User]   '
+      input = gets
+      exit unless input
+
+      input.strip
+    end
+
+    def cli_print(obj)
+      print '[Charyf] '
+      puts obj
+      puts ' - - - '
+    end
+
+    def detect(utterance)
+      if utterance[0] == ':'
+        process_command utterance[1..-1]
+        return
+      end
+
+      request = @interface.request
+      request.text = utterance
+
+      @interface.process(request)
+    end
+
+
+    def process_command(command)
+      case command
+        when 'help'
+          print_help
+        when 'exit'
+          exit(0)
+        else
+          puts 'Unknown command'
+          print_help
+      end
+
+    end
+
+    def build_interface
+      # TODO - dependency on bad "package"
+      @interface = Charyf::Interface::Program.create("cli_#{Process.pid}", Proc.new { |response| cli_print(response.text) })
+      $stderr.puts "Created program interface for process ##{Process.pid}."
+    end
+
+  end
+
+  module Command
+    class CliCommand < Base # :nodoc:
+
+      include EnvironmentArgument
+
+      hide_command!
+
+      def perform
+        extract_environment_option
+
+        # CHARYF_ENV needs to be set before application is required.
+        ENV["CHARYF_ENV"] = options[:environment]
+
+        require_application_and_environment!
+
+        Charyf::CLI.start
+      end
+
+    end
+  end
+end

data/lib/charyf/utils/commands/console/console_command.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require 'irb'
+
+require_relative '../../command/base'
+require_relative '../../command/environment_argument'
+
+module Charyf
+
+  class Console
+    def self.start(*args)
+      new(*args).start
+    end
+
+    attr_reader :options, :app, :console
+
+    def initialize(app, options = {})
+      @app     = app
+      @options = options
+
+      @console = app.config.console || IRB
+    end
+
+    def environment
+      options[:environment]
+    end
+
+    alias_method :environment?, :environment
+
+    def set_environment!
+      Charyf.env = environment
+    end
+
+    def start
+      set_environment! if environment?
+
+      puts "Loading #{Charyf.env} environment (Charyf #{Charyf.version})"
+
+      console.start
+    end
+  end
+
+  module Command
+
+    class ConsoleCommand < Base # :nodoc:
+
+      include EnvironmentArgument
+
+      hide_command!
+
+      def initialize(args = [], local_options = {}, config = {})
+        console_options = []
+
+        # For the same behavior as OptionParser, leave only options after "--" in ARGV.
+        termination = local_options.find_index("--")
+        if termination
+          console_options = local_options[termination + 1..-1]
+          local_options = local_options[0...termination]
+        end
+
+        ARGV.replace(console_options)
+        super(args, local_options, config)
+      end
+
+      def perform
+        extract_environment_option
+
+        # CHARYF_ENV needs to be set before application is required.
+        ENV["CHARYF_ENV"] = options[:environment]
+
+        require_application_and_environment!
+
+        Charyf::Console.start(Charyf.application, options)
+      end
+
+    end
+  end
+end

data/lib/charyf/utils/commands/destroy/destroy_command.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Charyf
+  module Command
+    class DestroyCommand < Base # :nodoc:
+      no_commands do
+        def help
+          require_application_and_environment!
+          load_generators
+
+          Charyf::Generators.help self.class.command_name
+        end
+      end
+
+      def perform(*)
+        generator = args.shift
+        return help unless generator
+
+        require_application_and_environment!
+        load_generators
+
+        Charyf::Generators.invoke generator, args, behavior: :revoke, destination_root: Charyf::Command.root
+      end
+    end
+  end
+end

data/lib/charyf/utils/commands/generate/generate_command.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../../command/base'
+
+module Charyf
+  module Command
+    class GenerateCommand < Base # :nodoc:
+
+      no_commands do
+        def help
+          require_application_and_environment!
+          load_generators
+
+          Charyf::Generators.help self.class.command_name
+        end
+      end
+
+      def perform(*)
+        generator = args.shift
+        return help unless generator
+
+        require_application_and_environment!
+        load_generators
+
+        ARGV.shift
+
+        Charyf::Generators.invoke generator, args, behavior: :invoke, destination_root: Charyf::Command.root
+      end
+    end
+  end
+end

data/lib/charyf/utils/commands/help/USAGE

@@ -0,0 +1,9 @@
+The most common Charyf commands are:
+ console      Start the Charyf console (short-cut alias: "c")
+ cli          Start the Charyf command line interface. Command line
+              interface allows to chat with charyf application on
+              the base of text messages.
+
+All commands can be run with -h (or --help) for more information.
+In addition to those commands, there are:
+

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../../command/base'
+
+module Charyf
+  module Command
+    class HelpCommand < Base # :nodoc:
+
+      hide_command!
+      desc_file File.expand_path('USAGE', __dir__)
+
+      def help(*)
+        puts self.class.desc
+
+        Charyf::Command.print_commands
+      end
+
+    end
+  end
+end

data/lib/charyf/utils/commands.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+
+aliases = {
+    'c' => 'console',
+    's' => 'server',
+    'g' => 'generate',
+    'd' => 'destroy'
+}
+
+command = ARGV.shift
+command = aliases[command] || command
+
+Charyf::Command.invoke command, ARGV

data/lib/charyf/utils/configuration.rb

@@ -0,0 +1,36 @@
+module Charyf
+  module Configuration
+
+    class Generators #:nodoc:
+      attr_accessor :options
+      attr_reader :hidden_namespaces
+
+      def initialize
+        @hidden_namespaces = []
+        @options = Hash.new { |h, k| h[k] = {} }
+      end
+
+      def hide_namespace(namespace)
+        @hidden_namespaces << namespace
+      end
+
+      def method_missing(method, *args)
+        method = method.to_s.sub(/=$/, "").to_sym
+
+        return @options[method] if args.empty?
+
+        if method == :charyf || args.first.is_a?(Hash)
+          namespace, configuration = method, args.shift
+        else
+          namespace, configuration = args.shift, args.shift
+          namespace = namespace.to_sym if namespace.respond_to?(:to_sym)
+          @options[:charyf][method] = namespace
+        end
+
+        if configuration
+          @options[namespace].merge!(configuration)
+        end
+      end
+    end
+  end
+end

data/lib/charyf/utils/error_handler.rb

@@ -0,0 +1,26 @@
+module Charyf
+  module ErrorHandlers
+
+    extend self
+
+    def<<(handler)
+      handlers << handler
+    end
+
+    def handle_exception(e)
+      Charyf.logger.error "#{e.class}: #{e}".red
+      Charyf.logger.error "\n\tBacktrace: #{e.backtrace.join("\n\t")}"
+
+      handlers.map { |h| h.handle_exception(e) }
+
+      e
+    end
+
+    private
+
+    def handlers
+      @handles ||= []
+    end
+
+  end
+end

data/lib/charyf/utils/extension/configurable.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Charyf
+  class Extension
+    module Configurable
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def config
+          instance.config
+        end
+
+        def inherited(base)
+          raise "You cannot inherit from a #{superclass.name} child"
+        end
+
+        def instance
+          @instance ||= new
+        end
+
+        def respond_to?(*args)
+          super || instance.respond_to?(*args)
+        end
+
+        def configure(&block)
+          class_eval(&block)
+        end
+
+        private
+
+        def method_missing(*args, &block)
+          instance.send(*args, &block)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+require_relative '../configuration'
+
+
+module Charyf
+  class Extension
+    class Configuration
+
+      def initialize
+        @@options ||= {}
+      end
+
+      # Holds generators configuration:
+      def generators
+        @@generators ||= Charyf::Configuration::Generators.new
+        yield(@generators) if block_given?
+        @@generators
+      end
+      #
+      # # First configurable block to run. Called before any initializers are run.
+      # def before_configuration(&block)
+      #   ActiveSupport.on_load(:before_configuration, yield: true, &block)
+      # end
+      #
+      # # Second configurable block to run. Called before frameworks initialize.
+      # def before_initialize(&block)
+      #   ActiveSupport.on_load(:before_initialize, yield: true, &block)
+      # end
+      #
+      # # Last configurable block to run. Called after frameworks initialize.
+      # def after_initialize(&block)
+      #   ActiveSupport.on_load(:after_initialize, yield: true, &block)
+      # end
+      #
+      # # Array of callbacks defined by #to_prepare.
+      # def to_prepare_blocks
+      #   @@to_prepare_blocks ||= []
+      # end
+      #
+      # # Defines generic callbacks to run before #after_initialize. Useful for
+      # # Charyf::Extension subclasses.
+      # def to_prepare(&blk)
+      #   to_prepare_blocks << blk if blk
+      # end
+      #
+      # def respond_to?(name, include_private = false)
+      #   super || @@options.key?(name.to_sym)
+      # end
+      #
+      private
+
+      def method_missing(name, *args, &blk)
+        if name.to_s =~ /=$/
+          @@options[$`.to_sym] = args.first
+        elsif @@options.key?(name)
+          @@options[name]
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/charyf/utils/extension.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative 'initializable'
+require_relative '../support'
+
+module Charyf
+  class Extension
+    include Initializable
+
+    ABSTRACT = %w(Charyf::Extension Charyf::AppEngine Charyf::Application)
+
+    class << self
+      private :new
+
+      def abstract?
+        ABSTRACT.include?(name)
+      end
+
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(base)
+        unless base.abstract?
+          subclasses << base
+        end
+      end
+
+      def generators(&blk)
+        register_block_for(:generators, &blk)
+      end
+
+      # Since Charyf::Extension cannot be instantiated, any methods that call
+      # +instance+ are intended to be called only on subclasses of a Extension.
+      def instance
+        @instance ||= new
+      end
+
+      def extension_name(name = nil)
+        @extension_name = name.to_s if name
+        @extension_name ||= generate_extension_name(self.name)
+      end
+
+      private
+
+      def generate_extension_name(string)
+        string.underscore.tr('/', '_')
+      end
+
+      # Allows you to configure the Extension. This is the same method seen in
+      # Extension::Configurable, but this module is no longer required for all
+      # subclasses of Extension so we provide the class method here.
+      def configure(&block)
+        instance.configure(&block)
+      end
+
+      def config
+        instance.config
+      end
+
+      def respond_to_missing?(name, _)
+        instance.respond_to?(name) || super
+      end
+
+      # If the class method does not have a method, then send the method call
+      # to the Extension instance.
+      def method_missing(name, *args, &block)
+        if instance.respond_to?(name)
+          instance.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      # receives an instance variable identifier, set the variable value if is
+      # blank and append given block to value, which will be used later in
+      # `#each_registered_block(type, &block)`
+      def register_block_for(type, &blk)
+        var_name = "@#{type}"
+        blocks = instance_variable_defined?(var_name) ? instance_variable_get(var_name) : instance_variable_set(var_name, [])
+        blocks << blk if blk
+        blocks
+      end
+    end # End of self
+
+    def initialize #:nodoc:
+      if self.class.abstract?
+        raise "#{self.class.name} is abstract, you cannot instantiate it directly."
+      end
+    end
+
+    def extension_name(name)
+      self.class.extension_name(name)
+    end
+
+    def configure(&block) #:nodoc:
+      instance_eval(&block)
+    end
+
+    def extension_namespace #:nodoc:
+      @extension_namespace ||= self.class.parents.detect { |n| n.respond_to?(:extension_namespace) }
+    end
+
+    # This is used to create the <tt>config</tt> object on Extensions, an instance of
+    # Extension::Configuration, that is used by Extensions and Application to store
+    # related configuration.
+    def config
+      @config ||= Charyf::Extension::Configuration.new
+    end
+
+    protected
+
+    def run_generators_blocks(app) #:nodoc:
+      each_registered_block(:generators) { |block| block.call(app) }
+    end
+
+    private
+
+    # run `&block` in every registered block in `#register_block_for`
+    def each_registered_block(type, &block)
+      klass = self.class
+      while klass.respond_to?(type)
+        klass.public_send(type).each(&block)
+        klass = klass.superclass
+      end
+    end
+
+  end
+end