hanami 0.0.0 → 0.7.0

data/lib/hanami/application_name.rb

@@ -0,0 +1,101 @@
+module Hanami
+  # An application name.
+  #
+  # @since 0.2.1
+  class ApplicationName
+
+    # A list of words that are prohibited from forming the application name
+    #
+    # @since 0.2.1
+    RESERVED_WORDS = %w(hanami).freeze
+
+    # Initialize and check against reserved words
+    #
+    # An application name needs to be translated in quite a few ways:
+    # First, it must be checked against a list of reserved words and rejected
+    # if it is invalid. Secondly, assuming it is not invalid, it must be able
+    # to be output roughly as given, but with the following changes:
+    #
+    # 1. downcased,
+    # 2. with surrounding spaces removed,
+    # 3. with internal whitespace rendered as underscores
+    # 4. with underscores de-duplicated
+    #
+    # which is the default output. It must also be transformable into an
+    # environment variable.
+    #
+    # @return [Hanami::ApplicationName] a new instance of the application name
+    #
+    # @since 0.2.1
+    def initialize(name)
+      @name = sanitize(name)
+      ensure_validity!
+    end
+
+    # Returns the cleaned application name.
+    #
+    # @return [String] the santized name
+    #
+    # @example
+    #   ApplicationName.new("my-App ").to_s # => "my-app"
+    #
+    # @since 0.2.1
+    def to_s
+      @name
+    end
+
+    # Returns the application name uppercased with non-alphanumeric characters
+    # as underscores.
+    #
+    # @return [String] the upcased name
+    #
+    # @example
+    #   ApplicationName.new("my-app").to_env_s => "MY_APP"
+    #
+    # @since 0.2.1
+    def to_env_s
+      @name.upcase.gsub(/\W/, '_')
+    end
+
+    # Returns true if a potential application name matches one of the reserved
+    # words.
+    #
+    # @param name [String] the application name
+    # @return [TrueClass, FalseClass] the result of the check
+    #
+    # @example
+    #   Hanami::ApplicationName.invalid?("hanami") # => true
+    #
+    # @since 0.2.1
+    def self.invalid?(name)
+      RESERVED_WORDS.include?(name)
+    end
+
+    private
+
+    # Raises RuntimeError with explanation if the provided name is invalid.
+    #
+    # @api private
+    # @since 0.2.1
+    def ensure_validity!
+      if self.class.invalid?(@name)
+        raise RuntimeError,
+          "application name must not be any one of the following: " +
+          RESERVED_WORDS.join(", ")
+      end
+    end
+
+    # Cleans a string to be a functioning application name.
+    #
+    # @api private
+    # @since 0.2.1
+    def sanitize(name)
+      name
+        .downcase
+        .strip
+        .gsub(/\s/, '_')
+        .gsub(/_{2,}/, '_')
+        .gsub(/-/, '_')
+    end
+  end
+end

data/lib/hanami/cli.rb

@@ -0,0 +1,119 @@
+require 'thor'
+require 'hanami/commands/console'
+require 'hanami/commands/new/app'
+require 'hanami/commands/new/container'
+
+module Hanami
+  class Cli < Thor
+    # include Thor::Actions
+
+    desc 'version', 'prints Hanami version'
+    long_desc <<-EOS
+    `hanami version` prints the version of the bundled hanami gem.
+    EOS
+    def version
+      require 'hanami/version'
+      puts "v#{ Hanami::VERSION }"
+    end
+
+    desc 'server', 'starts a hanami server'
+    long_desc <<-EOS
+    `hanami server` starts a server for the current hanami project.
+
+    $ > hanami server
+
+    $ > hanami server -p 4500
+    EOS
+    method_option :port, aliases: '-p', desc: 'The port to run the server on, '
+    method_option :server, desc: 'choose a specific Rack::Handler, e.g. webrick, thin etc'
+    method_option :rackup, desc: 'a rackup configuration file path to load (config.ru)'
+    method_option :host, desc: 'the host address to bind to'
+    method_option :debug, desc: 'turn on debug output'
+    method_option :warn, desc: 'turn on warnings'
+    method_option :daemonize, desc: 'if true, the server will daemonize itself (fork, detach, etc)'
+    method_option :pid, desc: 'path to write a pid file after daemonize'
+    method_option :environment, desc: 'path to environment configuration (config/environment.rb)'
+    method_option :code_reloading, desc: 'code reloading', type: :boolean, default: true
+    method_option :help, desc: 'displays the usage message'
+    def server
+      if options[:help]
+        invoke :help, ['server']
+      else
+        require 'hanami/commands/server'
+        Hanami::Commands::Server.new(options).start
+      end
+    end
+
+    desc 'console', 'starts a hanami console'
+    long_desc <<-EOS
+    `hanami console` starts the interactive hanami console.
+
+    $ > hanami console --engine=pry
+    EOS
+    method_option :environment, desc: 'path to environment configuration (config/environment.rb)'
+    method_option :engine, desc: "choose a specific console engine: (#{Hanami::Commands::Console::ENGINES.keys.join('/')})"
+    method_option :help, desc: 'displays the usage method'
+    def console
+      if options[:help]
+        invoke :help, ['console']
+      else
+        Hanami::Commands::Console.new(options).start
+      end
+    end
+
+    desc 'new APPLICATION_NAME', 'generate a new hanami project'
+    long_desc <<-EOS
+      `hanami new` creates a new hanami project.
+      You can specify various options such as the database to be used as well as the path and architecture.
+
+      $ > hanami new fancy_app --application_name=admin
+
+      $ > hanami new fancy_app --arch=app
+
+      $ > hanami new fancy_app --hanami-head=true
+    EOS
+    method_option :database, aliases: ['-d', '--db'], desc: "application database (#{Hanami::Generators::DatabaseConfig::SUPPORTED_ENGINES.keys.join('/')})", default: Hanami::Generators::DatabaseConfig::DEFAULT_ENGINE
+    method_option :architecture, aliases: ['-a', '--arch'], desc: 'project architecture (container/app)', default: Hanami::Commands::New::Abstract::DEFAULT_ARCHITECTURE
+    method_option :application_name, desc: 'application name, only for container', default: Hanami::Commands::New::Container::DEFAULT_APPLICATION_NAME
+    method_option :application_base_url, desc: 'application base url', default: Hanami::Commands::New::Abstract::DEFAULT_APPLICATION_BASE_URL
+    method_option :test, desc: "project test framework (#{Hanami::Generators::TestFramework::VALID_FRAMEWORKS.join('/')})", default: Hanami::Hanamirc::DEFAULT_TEST_SUITE
+    method_option :hanami_head, desc: 'use Hanami HEAD (true/false)', type: :boolean, default: false
+    method_option :help, desc: 'displays the usage method'
+    def new(application_name)
+      if options[:help]
+        invoke :help, ['new']
+      elsif options[:architecture] == 'app'
+        Hanami::Commands::New::App.new(options, application_name).start
+      else
+        Hanami::Commands::New::Container.new(options, application_name).start
+      end
+    end
+
+    desc 'routes', 'prints the routes'
+    long_desc <<-EOS
+      `hanami routes` outputs all the registered routes to the console.
+    EOS
+    method_option :environment, desc: 'path to environment configuration (config/environment.rb)'
+    method_option :help, desc: 'displays the usage method'
+    def routes
+      if options[:help]
+        invoke :help, ['routes']
+      else
+        require 'hanami/commands/routes'
+        Hanami::Commands::Routes.new(options).start
+      end
+    end
+
+    require 'hanami/cli_sub_commands/db'
+    register Hanami::CliSubCommands::DB, 'db', 'db [SUBCOMMAND]', 'manage set of DB operations'
+
+    require 'hanami/cli_sub_commands/generate'
+    register Hanami::CliSubCommands::Generate, 'generate', 'generate [SUBCOMMAND]', 'generate hanami classes'
+
+    require 'hanami/cli_sub_commands/destroy'
+    register Hanami::CliSubCommands::Destroy, 'destroy', 'destroy [SUBCOMMAND]', 'destroy hanami classes'
+
+    require 'hanami/cli_sub_commands/assets'
+    register Hanami::CliSubCommands::Assets, 'assets', 'assets [SUBCOMMAND]', 'manage assets'
+  end
+end

data/lib/hanami/cli_sub_commands/assets.rb

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

data/lib/hanami/cli_sub_commands/db.rb

@@ -0,0 +1,124 @@
+module Hanami
+  class CliSubCommands
+    # A set of subcommands related to DB
+    #
+    # It is run with:
+    #
+    #   `bundle exec hanami db`
+    #
+    # @since 0.6.0
+    # @api private
+    class DB < Thor
+      namespace :db
+
+      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 'hanami/commands/db/console'
+          Hanami::Commands::DB::Console.new(options, name).start
+        end
+      end
+
+      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 'hanami/commands/db/create'
+          Hanami::Commands::DB::Create.new(options).start
+        end
+      end
+
+      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 'hanami/commands/db/drop'
+          Hanami::Commands::DB::Drop.new(options).start
+        end
+      end
+
+      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 'hanami/commands/db/migrate'
+          Hanami::Commands::DB::Migrate.new(options, version).start
+        end
+      end
+
+      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 'hanami/commands/db/apply'
+          Hanami::Commands::DB::Apply.new(options).start
+        end
+      end
+
+      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 'hanami/commands/db/prepare'
+          Hanami::Commands::DB::Prepare.new(options).start
+        end
+      end
+
+      # @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 'hanami/commands/db/version'
+          Hanami::Commands::DB::Version.new(options).start
+        end
+      end
+
+      private
+
+      # @since 0.6.0
+      # @api private
+      def environment
+        Hanami::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"
+          exit 1
+        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"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli_sub_commands/destroy.rb

@@ -0,0 +1,102 @@
+require 'hanami/routing/route'
+require 'hanami/commands/generate/action'
+
+module Hanami
+  class CliSubCommands
+    class Destroy < Thor
+      include Thor::Actions
+      namespace :destroy
+
+      desc 'action APPLICATION_NAME CONTROLLER_NAME#ACTION_NAME', 'destroy a hanami action'
+      long_desc <<-EOS
+        `hanami 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'.
+
+        > $ hanami destroy action app cars#index
+
+        > $ hanami destroy action other-app cars#index
+
+        > $ hanami 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 (#{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 :template, desc: 'Extension used when the template was generated. Default is defined through your .hanamirc file.'
+
+      def actions(application_name, controller_and_action_name)
+        if options[:help]
+          invoke :help, ['action']
+        else
+          Hanami::Commands::Generate::Action.new(options, application_name, controller_and_action_name).destroy.start
+        end
+      end
+
+      desc 'migration NAME', 'destroy a migration'
+      long_desc <<-EOS
+      `hanami destroy migration` will destroy a migration file.
+
+      > $ hanami destroy migration create_books
+      EOS
+
+      def migration(name)
+        if options[:help]
+          invoke :help, ['migration']
+        else
+          require 'hanami/commands/generate/migration'
+          Hanami::Commands::Generate::Migration.new(options, name).destroy.start
+        end
+      end
+
+      desc 'model NAME', 'destroy an entity'
+      long_desc <<-EOS
+        `hanami destroy model` will destroy an entity along with repository
+        and corresponding tests
+
+        > $ hanami generate model car
+      EOS
+
+      def model(name)
+        if options[:help]
+          invoke :help, ['model']
+        else
+          require 'hanami/commands/generate/model'
+          Hanami::Commands::Generate::Model.new(options, name).destroy.start
+        end
+      end
+
+      desc 'application NAME', 'destroy an application'
+      long_desc <<-EOS
+      `hanami destroy application` will destroy an application, along with templates and specs.
+
+      > $ hanami destroy application api
+      EOS
+      def application(name)
+        if options[:help]
+          invoke :help, ['app']
+        else
+          require 'hanami/commands/generate/app'
+          Hanami::Commands::Generate::App.new(options, name).destroy.start
+        end
+      end
+
+      desc 'mailer NAME', 'destroy a mailer'
+      long_desc <<-EOS
+      `hanami destroy mailer` will destroy a mailer, along with templates and specs.
+
+      > $ hanami destroy mailer forgot_password
+      EOS
+
+      def mailer(name)
+        if options[:help]
+          invoke :help, ['mailer']
+        else
+          require 'hanami/commands/generate/mailer'
+
+          options[:behavior] = :revoke
+          Hanami::Commands::Generate::Mailer.new(options, name).destroy.start
+        end
+      end
+    end
+  end
+end