hanami 0.0.0 → 0.7.0

data/lib/hanami/cli_sub_commands/generate.rb

@@ -0,0 +1,127 @@
+require 'hanami/routing/route'
+require 'hanami/commands/generate/action'
+require 'hanami/commands/generate/mailer'
+
+module Hanami
+  class CliSubCommands
+    # A set of generator subcommands
+    #
+    # It is run with:
+    #
+    #   `bundle exec hanami generate`
+    #
+    # @since 0.6.0
+    # @api private
+    class Generate < Thor
+      include Thor::Actions
+
+      namespace :generate
+
+      # @since 0.6.0
+      # @api private
+      desc 'action APPLICATION_NAME CONTROLLER_NAME#ACTION_NAME', 'generate a hanami action'
+      long_desc <<-EOS
+        `hanami generate action` generates an an action, view and template along with specs and a route.
+
+        For Application architecture the application name is 'app'. For Container architecture the default application is called 'web'.
+
+        > $ hanami generate action app cars#index
+
+        > $ hanami generate action other-app cars#index
+
+        > $ hanami generate action web cars#create --method=post
+      EOS
+      method_option :method, desc: "The HTTP method to be used for the generated route. Must be one of (#{Hanami::Routing::Route::VALID_HTTP_VERBS.join('/')})", default: Hanami::Commands::Generate::Action::DEFAULT_HTTP_METHOD
+      method_option :url, desc: 'Relative URL for action, will be used for the route', default: nil
+      method_option :test, desc: 'Defines the testing Framework to be used. Default is defined through your .hanamirc file.'
+      method_option :skip_view, desc: 'Skip the generation of the view. Also skips template generation.', default: false, type: :boolean
+      method_option :template, desc: 'Extension to be used for the generated template. Default is defined through your .hanamirc file.'
+      def actions(application_name = nil, controller_and_action_name)
+        if Hanami::Environment.new(options).container? && application_name.nil?
+          msg = "ERROR: \"hanami generate action\" was called with arguments [\"#{controller_and_action_name}\"]\n" \
+                "Usage: \"hanami action APPLICATION_NAME CONTROLLER_NAME#ACTION_NAME\""
+          fail Error, msg
+        end
+
+        if options[:help]
+          invoke :help, ['action']
+        else
+          Hanami::Commands::Generate::Action.new(options, application_name, controller_and_action_name).start
+        end
+      end
+
+      desc 'migration NAME', 'generate a migration'
+      long_desc <<-EOS
+      `hanami generate migration` will generate an empty migration file.
+
+      > $ hanami generate migration do_something
+      EOS
+      def migration(name)
+        if options[:help]
+          invoke :help, ['migration']
+        else
+          require 'hanami/commands/generate/migration'
+          Hanami::Commands::Generate::Migration.new(options, name).start
+        end
+      end
+
+      desc 'model NAME', 'generate an entity'
+      long_desc <<-EOS
+        `hanami generate model` will generate an entity along with repository
+        and corresponding tests. The name of the model can contain slashes to
+        indicate module names.
+
+        > $ hanami generate model car
+
+        > $ hanami generate model vehicles/car
+      EOS
+      method_option :test, desc: 'Defines the testing Framework to be used. Default is defined through your .hanamirc file.'
+      def model(name)
+        if options[:help]
+          invoke :help, ['model']
+        else
+          require 'hanami/commands/generate/model'
+          Hanami::Commands::Generate::Model.new(options, name).start
+        end
+      end
+
+      desc 'mailer NAME', 'generate a mailer'
+      long_desc <<-EOS
+      `hanami generate mailer` will generate an empty mailer, along with templates and specs.
+
+      > $ hanami generate mailer forgot_password
+      > $ hanami generate mailer forgot_password --to "'log@bookshelf.com'" --from "'support@bookshelf.com'" --subject "'New Password'"
+      EOS
+      method_option :to, desc: 'sender email', default: Hanami::Commands::Generate::Mailer::DEFAULT_TO
+      method_option :from, desc: 'sendee email', default: Hanami::Commands::Generate::Mailer::DEFAULT_FROM
+      method_option :subject, desc: 'email subject', default: Hanami::Commands::Generate::Mailer::DEFAULT_SUBJECT
+      def mailer(name)
+        if options[:help]
+          invoke :help, ['mailer']
+        else
+          Hanami::Commands::Generate::Mailer.new(options, name).start
+        end
+      end
+
+      desc 'app APPLICATION_NAME', 'generate an app'
+      long_desc <<-EOS
+        `hanami generate app` creates a new app inside the 'apps' directory.
+
+        It can only be called for hanami applications with container architecture.
+
+        > $ hanami generate app admin
+
+        > $ hanami generate app reporting --application_base_url=/reports
+      EOS
+      method_option :application_base_url, desc: 'Base URL for the new app. If missing, then it is inferred from APPLICATION_NAME'
+      def app(application_name)
+        if options[:help]
+          invoke :help, ['app']
+        else
+          require 'hanami/commands/generate/app'
+          Hanami::Commands::Generate::App.new(options, application_name).start
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/assets/precompile.rb

@@ -0,0 +1,35 @@
+require 'hanami/assets'
+
+module Hanami
+  module Commands
+    class Assets
+      class Precompile
+        def initialize(options, environment)
+          @options     = options
+          @environment = environment
+        end
+
+        def start
+          preload_applications
+          precompile
+        end
+
+        private
+
+        def preload_applications
+          @environment.require_application_environment
+
+          if @environment.container?
+            Hanami::Container.new
+          else
+            Hanami::Application.preload!
+          end
+        end
+
+        def precompile
+          Hanami::Assets.deploy
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/console.rb

@@ -0,0 +1,90 @@
+module Hanami
+  module Commands
+    # REPL that supports different engines.
+    #
+    # It is run with:
+    #
+    #   `bundle exec hanami console`
+    #
+    # @since 0.1.0
+    # @api private
+    class Console
+      module Methods
+        def reload!
+          puts 'Reloading...'
+          Kernel.exec "#{$0} console"
+        end
+      end
+
+      ENGINES = {
+        'pry'  => 'Pry',
+        'ripl' => 'Ripl',
+        'irb'  => 'IRB'
+      }.freeze
+
+      DEFAULT_ENGINE = 'irb'.freeze
+
+      # @since 0.1.0
+      attr_reader :options
+
+      # @param options [Hash] Environment's options
+      #
+      # @since 0.1.0
+      # @see Hanami::Environment#initialize
+      def initialize(options)
+        @environment = Hanami::Environment.new(options)
+        @options     = @environment.to_options
+      end
+
+      # @since 0.1.0
+      def start
+        # Clear out ARGV so Pry/IRB don't attempt to parse the rest
+        ARGV.shift until ARGV.empty?
+        @environment.require_application_environment
+
+        # Add convenience methods to the main:Object binding
+        TOPLEVEL_BINDING.eval('self').send(:include, Methods)
+
+        load_application
+        engine.start
+      end
+
+      # @since 0.1.0
+      # @api private
+      def engine
+        load_engine options.fetch(:engine) { engine_lookup }
+      end
+
+      private
+
+      # @since 0.1.0
+      # @api private
+      def engine_lookup
+        (ENGINES.find { |_, klass| Object.const_defined?(klass) } || DEFAULT_ENGINE).first
+      end
+
+      # @since 0.1.0
+      # @api private
+      def load_engine(engine)
+        require engine
+      rescue LoadError
+      ensure
+        return Object.const_get(
+          ENGINES.fetch(engine) {
+            raise ArgumentError.new("Unknown console engine: #{ engine }")
+          }
+        )
+      end
+
+      # @since 0.1.0
+      # @api private
+      def load_application
+        if @environment.container?
+          Hanami::Container.new
+        else
+          Hanami::Application.preload_applications!
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/db/abstract.rb

@@ -0,0 +1,19 @@
+module Hanami
+  module Commands
+    class DB
+      class Abstract
+        attr_reader :environment
+
+        def initialize(options)
+          @options = options
+          @environment = Hanami::Environment.new(options)
+          @environment.require_application_environment
+        end
+
+        def start
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/db/apply.rb

@@ -0,0 +1,14 @@
+require 'hanami/commands/db/abstract'
+
+module Hanami
+  module Commands
+    class DB
+      class Apply < Abstract
+        def start
+          require 'hanami/model/migrator'
+          Hanami::Model::Migrator.apply
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/db/console.rb

@@ -0,0 +1,50 @@
+require 'hanami/utils/class'
+require 'hanami/commands/db/abstract'
+
+module Hanami
+  module Commands
+    class DB
+      class Console < Abstract
+        attr_reader :name, :env_options
+
+        def initialize(options, name)
+          super(options)
+          @name        = name
+          @env_options = environment.to_options
+        end
+
+        def start
+          exec connection_string
+        end
+
+        private
+
+        def config
+          if name
+            app_constant = Hanami::Utils::Class.load_from_pattern!(Hanami::Utils::String.new(name).classify)
+            Hanami::Utils::Class.load_from_pattern!("#{app_constant}::Application").load!
+            Hanami::Utils::Class.load_from_pattern!("#{app_constant}::Model").configuration
+          else
+            Hanami::Model.configuration
+          end
+        end
+
+        def adapter_config
+          config.adapter_config
+        end
+
+        def mapper
+          config.mapper
+        end
+
+        def adapter_class
+          Hanami::Utils::Class.load_from_pattern!(adapter_config.class_name, Hanami::Model::Adapters)
+        end
+
+        def connection_string
+          adapter_class.new(mapper, adapter_config.uri).connection_string
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/db/create.rb

@@ -0,0 +1,14 @@
+require 'hanami/commands/db/abstract'
+
+module Hanami
+  module Commands
+    class DB
+      class Create < Abstract
+        def start
+          require 'hanami/model/migrator'
+          Hanami::Model::Migrator.create
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/db/drop.rb

@@ -0,0 +1,14 @@
+require 'hanami/commands/db/abstract'
+
+module Hanami
+  module Commands
+    class DB
+      class Drop < Abstract
+        def start
+          require 'hanami/model/migrator'
+          Hanami::Model::Migrator.drop
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/db/migrate.rb

@@ -0,0 +1,19 @@
+require 'hanami/commands/db/abstract'
+
+module Hanami
+  module Commands
+    class DB
+      class Migrate < Abstract
+        def initialize(environment, version)
+          super(environment)
+          @version = version
+        end
+
+        def start
+          require 'hanami/model/migrator'
+          Hanami::Model::Migrator.migrate(version: @version)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/db/prepare.rb

@@ -0,0 +1,14 @@
+require 'hanami/commands/db/abstract'
+
+module Hanami
+  module Commands
+    class DB
+      class Prepare < Abstract
+        def start
+          require 'hanami/model/migrator'
+          Hanami::Model::Migrator.prepare
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/db/version.rb

@@ -0,0 +1,14 @@
+require 'hanami/commands/db/abstract'
+
+module Hanami
+  module Commands
+    class DB
+      class Version < Abstract
+        def start
+          require 'hanami/model/migrator'
+          puts Hanami::Model::Migrator.version
+        end
+      end
+    end
+  end
+end

data/lib/hanami/commands/generate/abstract.rb

@@ -0,0 +1,63 @@
+require 'hanami/environment'
+require 'hanami/generators/generatable'
+require 'hanami/generators/test_framework'
+require 'hanami/version'
+require 'hanami/utils/string'
+
+module Hanami
+  module Commands
+    class Generate
+      class Abstract
+
+        include Hanami::Generators::Generatable
+
+        attr_reader :options, :target_path
+
+        def initialize(options)
+          @options = Hanami::Utils::Hash.new(options).symbolize!
+          assert_options!
+
+          @target_path = Pathname.pwd
+        end
+
+        def template_source_path
+          generator = self.class.name.split('::').last.downcase
+          Pathname.new(::File.dirname(__FILE__) + "/../../generators/#{generator}/").realpath
+        end
+
+        private
+
+        def test_framework
+          @test_framework ||= Hanami::Generators::TestFramework.new(hanamirc, options[:test])
+        end
+
+        def hanamirc_options
+          hanamirc.options
+        end
+
+        def hanamirc
+          @hanamirc ||= Hanamirc.new(target_path)
+        end
+
+        def environment
+          @environment ||= Hanami::Environment.new(options)
+        end
+
+        def template_engine
+          options.fetch(:template, default_template_engine)
+        end
+
+        def default_template_engine
+          hanamirc_options.fetch(:template)
+        end
+
+        def assert_options!
+          if options.nil?
+            raise ArgumentError.new('options must not be nil')
+          end
+        end
+
+      end
+    end
+  end
+end