lotusrb 0.5.0 → 0.6.0

data/lib/lotus/cli_sub_commands/assets.rb

@@ -0,0 +1,29 @@
+module Lotus
+  class CliSubCommands
+    # A set of subcommands related to assets
+    #
+    # It is run with:
+    #
+    #   `bundle exec lotus assets`
+    #
+    # @since 0.6.0
+    # @api private
+    class Assets < Thor
+      namespace :assets
+
+      desc 'precompile', 'precompile assets for deployment'
+      def precompile
+        require 'lotus/commands/assets/precompile'
+        Lotus::Commands::Assets::Precompile.new(options, environment).start
+      end
+
+      private
+
+      # @since 0.6.0
+      # @api private
+      def environment
+        Lotus::Environment.new(options)
+      end
+    end
+  end
+end

data/lib/lotus/{commands → cli_sub_commands}/db.rb

@@ -1,116 +1,109 @@
 module Lotus
-  module Commands
+  class CliSubCommands
+    # A set of subcommands related to DB
+    #
+    # It is run with:
+    #
+    #   `bundle exec lotus db`
+    #
+    # @since 0.6.0
+    # @api private
     class DB < Thor
       namespace :db
 
-      desc 'db console', 'start DB console'
-
       desc 'console', 'start DB console'
       method_option :environment, desc: 'path to environment configuration (config/environment.rb)'
-
       def console(name = nil)
         if options[:help]
           invoke :help, ['console']
         else
           require 'lotus/commands/db/console'
-          Lotus::Commands::DB::Console.new(name, environment).start
+          Lotus::Commands::DB::Console.new(options, name).start
         end
       end
 
-      desc 'db create', 'create database'
-
       desc 'create', 'create database for current environment'
       method_option :environment, desc: 'path to environment configuration (config/environment.rb)'
-
       def create
         if options[:help]
           invoke :help, ['create']
         else
           assert_allowed_environment!
           require 'lotus/commands/db/create'
-          Lotus::Commands::DB::Create.new(environment).start
+          Lotus::Commands::DB::Create.new(options).start
         end
       end
 
-      desc 'db drop', 'drop database'
-
       desc 'drop', 'drop database for current environment'
       method_option :environment, desc: 'path to environment configuration (config/environment.rb)'
-
       def drop
         if options[:help]
           invoke :help, ['drop']
         else
           assert_allowed_environment!
           require 'lotus/commands/db/drop'
-          Lotus::Commands::DB::Drop.new(environment).start
+          Lotus::Commands::DB::Drop.new(options).start
         end
       end
 
-      desc 'db migrate', 'migrate database'
-
       desc 'migrate', 'migrate database for current environment'
       method_option :environment, desc: 'path to environment configuration (config/environment.rb)'
-
       def migrate(version = nil)
         if options[:help]
           invoke :help, ['migrate']
         else
           require 'lotus/commands/db/migrate'
-          Lotus::Commands::DB::Migrate.new(environment, version).start
+          Lotus::Commands::DB::Migrate.new(options, version).start
         end
       end
 
-      desc 'db apply', 'apply database changes'
-
       desc 'apply', 'migrate, dump schema, delete migrations (experimental)'
       method_option :environment, desc: 'path to environment configuration (config/environment.rb)'
-
       def apply
         if options[:help]
           invoke :help, ['apply']
         else
           assert_development_environment!
           require 'lotus/commands/db/apply'
-          Lotus::Commands::DB::Apply.new(environment).start
+          Lotus::Commands::DB::Apply.new(options).start
         end
       end
 
-      desc 'db prepare', 'prepare database'
-
       desc 'prepare', 'create and migrate database'
       method_option :environment, desc: 'path to environment configuration (config/environment.rb)'
-
       def prepare
         if options[:help]
           invoke :help, ['prepare']
         else
           assert_allowed_environment!
           require 'lotus/commands/db/prepare'
-          Lotus::Commands::DB::Prepare.new(environment).start
+          Lotus::Commands::DB::Prepare.new(options).start
         end
       end
 
-      desc 'db version', 'database version'
-
+      # @since 0.6.0
+      # @api private
       desc 'version', 'current database version'
       method_option :environment, desc: 'path to environment configuration (config/environment.rb)'
-
       def version
         if options[:help]
           invoke :help, ['version']
         else
           require 'lotus/commands/db/version'
-          Lotus::Commands::DB::Version.new(environment).start
+          Lotus::Commands::DB::Version.new(options).start
         end
       end
 
       private
 
+      # @since 0.6.0
+      # @api private
       def environment
         Lotus::Environment.new(options)
       end
 
+      # @since 0.6.0
+      # @api private
       def assert_allowed_environment!
         if environment.environment?(:production)
           puts "Can't run this command in production mode"
@@ -118,6 +111,8 @@ module Lotus
         end
       end
 
+      # @since 0.6.0
+      # @api private
       def assert_development_environment!
         unless environment.environment?(:development)
           puts "This command can be ran only in development mode"

data/lib/lotus/cli_sub_commands/destroy.rb

@@ -0,0 +1,102 @@
+require 'lotus/routing/route'
+require 'lotus/commands/generate/action'
+
+module Lotus
+  class CliSubCommands
+    class Destroy < Thor
+      include Thor::Actions
+      namespace :destroy
+
+      desc 'action APPLICATION_NAME CONTROLLER_NAME#ACTION_NAME', 'destroy a lotus action'
+      long_desc <<-EOS
+        `lotus destroy action` will destroy 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'.
+
+        > $ lotus destroy action app cars#index
+
+        > $ lotus destroy action other-app cars#index
+
+        > $ lotus destroy action web cars#create --method=post
+      EOS
+
+      method_option :method, desc: "The HTTP method used when the route was generated. Must be one of (#{Lotus::Routing::Route::VALID_HTTP_VERBS.join('/')})", default: Lotus::Commands::Generate::Action::DEFAULT_HTTP_METHOD
+      method_option :url, desc: 'Relative URL for action, will be used for the route', default: nil
+      method_option :template, desc: 'Extension used when the template was generated. Default is defined through your .lotusrc file.'
+
+      def actions(application_name, controller_and_action_name)
+        if options[:help]
+          invoke :help, ['action']
+        else
+          Lotus::Commands::Generate::Action.new(options, application_name, controller_and_action_name).destroy.start
+        end
+      end
+
+      desc 'migration NAME', 'destroy a migration'
+      long_desc <<-EOS
+      `lotus destroy migration` will destroy a migration file.
+
+      > $ lotus destroy migration create_books
+      EOS
+
+      def migration(name)
+        if options[:help]
+          invoke :help, ['migration']
+        else
+          require 'lotus/commands/generate/migration'
+          Lotus::Commands::Generate::Migration.new(options, name).destroy.start
+        end
+      end
+
+      desc 'model NAME', 'destroy an entity'
+      long_desc <<-EOS
+        `lotus destroy model` will destroy an entity along with repository
+        and corresponding tests
+
+        > $ lotus generate model car
+      EOS
+
+      def model(name)
+        if options[:help]
+          invoke :help, ['model']
+        else
+          require 'lotus/commands/generate/model'
+          Lotus::Commands::Generate::Model.new(options, name).destroy.start
+        end
+      end
+
+      desc 'application NAME', 'destroy an application'
+      long_desc <<-EOS
+      `lotus destroy application` will destroy an application, along with templates and specs.
+
+      > $ lotus destroy application api
+      EOS
+      def application(name)
+        if options[:help]
+          invoke :help, ['app']
+        else
+          require 'lotus/commands/generate/app'
+          Lotus::Commands::Generate::App.new(options, name).destroy.start
+        end
+      end
+
+      desc 'mailer NAME', 'destroy a mailer'
+      long_desc <<-EOS
+      `lotus destroy mailer` will destroy a mailer, along with templates and specs.
+
+      > $ lotus destroy mailer forgot_password
+      EOS
+
+      def mailer(name)
+        if options[:help]
+          invoke :help, ['mailer']
+        else
+          require 'lotus/commands/generate/mailer'
+
+          options[:behavior] = :revoke
+          Lotus::Commands::Generate::Mailer.new(options, name).destroy.start
+        end
+      end
+    end
+  end
+end

data/lib/lotus/cli_sub_commands/generate.rb

@@ -0,0 +1,127 @@
+require 'lotus/routing/route'
+require 'lotus/commands/generate/action'
+require 'lotus/commands/generate/mailer'
+
+module Lotus
+  class CliSubCommands
+    # A set of generator subcommands
+    #
+    # It is run with:
+    #
+    #   `bundle exec lotus 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 lotus action'
+      long_desc <<-EOS
+        `lotus 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'.
+
+        > $ lotus generate action app cars#index
+
+        > $ lotus generate action other-app cars#index
+
+        > $ lotus 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 (#{Lotus::Routing::Route::VALID_HTTP_VERBS.join('/')})", default: Lotus::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 .lotusrc 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 .lotusrc file.'
+      def actions(application_name = nil, controller_and_action_name)
+        if Lotus::Environment.new(options).container? && application_name.nil?
+          msg = "ERROR: \"lotus generate action\" was called with arguments [\"#{controller_and_action_name}\"]\n" \
+                "Usage: \"lotus action APPLICATION_NAME CONTROLLER_NAME#ACTION_NAME\""
+          fail Error, msg
+        end
+
+        if options[:help]
+          invoke :help, ['action']
+        else
+          Lotus::Commands::Generate::Action.new(options, application_name, controller_and_action_name).start
+        end
+      end
+
+      desc 'migration NAME', 'generate a migration'
+      long_desc <<-EOS
+      `lotus generate migration` will generate an empty migration file.
+
+      > $ lotus generate migration do_something
+      EOS
+      def migration(name)
+        if options[:help]
+          invoke :help, ['migration']
+        else
+          require 'lotus/commands/generate/migration'
+          Lotus::Commands::Generate::Migration.new(options, name).start
+        end
+      end
+
+      desc 'model NAME', 'generate an entity'
+      long_desc <<-EOS
+        `lotus generate model` will generate an entity along with repository
+        and corresponding tests. The name of the model can contain slashes to
+        indicate module names.
+
+        > $ lotus generate model car
+
+        > $ lotus generate model vehicles/car
+      EOS
+      method_option :test, desc: 'Defines the testing Framework to be used. Default is defined through your .lotusrc file.'
+      def model(name)
+        if options[:help]
+          invoke :help, ['model']
+        else
+          require 'lotus/commands/generate/model'
+          Lotus::Commands::Generate::Model.new(options, name).start
+        end
+      end
+
+      desc 'mailer NAME', 'generate a mailer'
+      long_desc <<-EOS
+      `lotus generate mailer` will generate an empty mailer, along with templates and specs.
+
+      > $ lotus generate mailer forgot_password
+      > $ lotus generate mailer forgot_password --to "'log@bookshelf.com'" --from "'support@bookshelf.com'" --subject "'New Password'"
+      EOS
+      method_option :to, desc: 'sender email', default: Lotus::Commands::Generate::Mailer::DEFAULT_TO
+      method_option :from, desc: 'sendee email', default: Lotus::Commands::Generate::Mailer::DEFAULT_FROM
+      method_option :subject, desc: 'email subject', default: Lotus::Commands::Generate::Mailer::DEFAULT_SUBJECT
+      def mailer(name)
+        if options[:help]
+          invoke :help, ['mailer']
+        else
+          Lotus::Commands::Generate::Mailer.new(options, name).start
+        end
+      end
+
+      desc 'app APPLICATION_NAME', 'generate an app'
+      long_desc <<-EOS
+        `lotus generate app` creates a new app inside the 'apps' directory.
+
+        It can only be called for lotus applications with container architecture.
+
+        > $ lotus generate app admin
+
+        > $ lotus 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 'lotus/commands/generate/app'
+          Lotus::Commands::Generate::App.new(options, application_name).start
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'lotus/assets'
+
+module Lotus
+  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?
+            Lotus::Container.new
+          else
+            Lotus::Application.preload!
+          end
+        end
+
+        def precompile
+          Lotus::Assets.deploy
+        end
+      end
+    end
+  end
+end

data/lib/lotus/commands/console.rb

@@ -1,5 +1,13 @@
 module Lotus
   module Commands
+    # REPL that supports different engines.
+    #
+    # It is run with:
+    #
+    #   `bundle exec lotus console`
+    #
+    # @since 0.1.0
+    # @api private
     class Console
       module Methods
         def reload!
@@ -14,13 +22,21 @@ module Lotus
         'irb'  => 'IRB'
       }.freeze
 
+      DEFAULT_ENGINE = 'irb'.freeze
+
+      # @since 0.1.0
       attr_reader :options
 
-      def initialize(environment)
-        @environment = environment
-        @options     = environment.to_options
+      # @param options [Hash] Environment's options
+      #
+      # @since 0.1.0
+      # @see Lotus::Environment#initialize
+      def initialize(options)
+        @environment = Lotus::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?
@@ -33,20 +49,22 @@ module Lotus
         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
-
-      def default_engine
-        ENGINES.to_a.last
+        (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
@@ -58,6 +76,8 @@ module Lotus
         )
       end
 
+      # @since 0.1.0
+      # @api private
       def load_application
         if @environment.container?
           Lotus::Container.new