hanami-cli 2.0.0.rc1 → 2.0.0

data/lib/hanami/cli/commands/app/db/utils/database.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "database_config"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module DB
+          module Utils
+            # @api private
+            class Database
+              # @api private
+              attr_reader :app
+
+              # @api private
+              attr_reader :config
+
+              # @api private
+              SCHEME_MAP = {
+                "sqlite" => -> {
+                  require_relative("sqlite")
+                  Sqlite
+                },
+                "postgres" => -> {
+                  require_relative("postgres")
+                  Postgres
+                },
+                "postgresql" => -> {
+                  require_relative("postgres")
+                  Postgres
+                },
+                "mysql" => -> {
+                  require_relative("mysql")
+                  Mysql
+                }
+              }.freeze
+
+              # @api private
+              def self.[](app)
+                database_url =
+                  if app.key?(:settings) && app[:settings].respond_to?(:database_url)
+                    app[:settings].database_url
+                  else
+                    ENV.fetch("DATABASE_URL")
+                  end
+
+                config = DatabaseConfig.new(database_url)
+
+                resolver = SCHEME_MAP.fetch(config.db_type) do
+                  raise "#{config.db_type} is not a supported db scheme"
+                end
+
+                klass = resolver.()
+
+                klass.new(app: app, config: config)
+              end
+
+              # @api private
+              def initialize(app:, config:)
+                @app = app
+                @config = config
+              end
+
+              # @api private
+              def create_command
+                raise Hanami::CLI::NotImplementedError
+              end
+
+              # @api private
+              def drop_command
+                raise Hanami::CLI::NotImplementedError
+              end
+
+              # @api private
+              def dump_command
+                raise Hanami::CLI::NotImplementedError
+              end
+
+              # @api private
+              def load_command
+                raise Hanami::CLI::NotImplementedError
+              end
+
+              # @api private
+              def root_path
+                app.root
+              end
+
+              # @api private
+              def rom_config
+                @rom_config ||=
+                  begin
+                    app.prepare(:persistence)
+                    app.container["persistence.config"]
+                  end
+              end
+
+              # @api private
+              def name
+                config.db_name
+              end
+
+              # @api private
+              def gateway
+                rom_config.gateways[:default]
+              end
+
+              # @api private
+              def connection
+                gateway.connection
+              end
+
+              # @api private
+              def run_migrations(**options)
+                require "rom/sql"
+                ROM::SQL.with_gateway(gateway) do
+                  migrator.run(options)
+                end
+              end
+
+              # @api private
+              def migrator
+                @migrator ||=
+                  begin
+                    require "rom/sql"
+                    ROM::SQL::Migration::Migrator.new(connection, path: File.join(root_path, "db/migrate"))
+                  end
+              end
+
+              # @api private
+              def applied_migrations
+                sequel_migrator.applied_migrations
+              end
+
+              private
+
+              def sequel_migrator
+                @sequel_migrator ||= begin
+                  require "sequel"
+                  Sequel.extension :migration
+                  Sequel::TimestampMigrator.new(migrator.connection, migrations_path, {})
+                end
+              end
+
+              def migrations_path
+                File.join(root_path, "db/migrate")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/app/db/utils/database_config.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module DB
+          # @api private
+          module Utils
+            # @api private
+            class DatabaseConfig
+              # @api private
+              attr_reader :uri
+
+              # @api private
+              def initialize(database_url)
+                @uri = URI(database_url)
+              end
+
+              # @api private
+              def hostname
+                uri.hostname
+              end
+              alias_method :host, :hostname
+
+              # @api private
+              def user
+                uri.user
+              end
+              alias_method :username, :user
+
+              # @api private
+              def password
+                uri.password
+              end
+              alias_method :pass, :password
+
+              # @api private
+              def port
+                uri.port
+              end
+
+              # @api private
+              def db_name
+                @db_name ||= uri.path.gsub(/\A\//, "")
+              end
+
+              # @api private
+              def db_type
+                uri.scheme
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/app/db/utils/mysql.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "database"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module DB
+          module Utils
+            # @api private
+            class Mysql < Database
+              # @api private
+              def create_command
+                raise Hanami::CLI::NotImplementedError
+              end
+
+              # @api private
+              def dump_command
+                raise Hanami::CLI::NotImplementedError
+              end
+
+              # @api private
+              def load_command
+                raise Hanami::CLI::NotImplementedError
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/app/db/utils/postgres.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "open3"
+require_relative "database"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module DB
+          module Utils
+            # @api private
+            class Postgres < Database
+              # @api private
+              def create_command
+                existing_stdout, status = Open3.capture2(cli_env_vars, "psql -t -c '\\l #{escaped_name}'")
+
+                return true if status.success? && existing_stdout.include?(escaped_name)
+
+                system(cli_env_vars, "createdb #{escaped_name}")
+              end
+
+              # @api private
+              def drop_command
+                system(cli_env_vars, "dropdb #{escaped_name}")
+              end
+
+              # @api private
+              def dump_command
+                system(cli_env_vars, "pg_dump --schema-only --no-owner #{escaped_name} > #{dump_file}")
+              end
+
+              # @api private
+              def load_command
+                raise "Not Implemented Yet"
+              end
+
+              # @api private
+              def escaped_name
+                Shellwords.escape(name)
+              end
+
+              # @api private
+              def cli_env_vars
+                @cli_env_vars ||= {}.tap do |vars|
+                  vars["PGHOST"] = config.host.to_s
+                  vars["PGPORT"] = config.port.to_s if config.port
+                  vars["PGUSER"] = config.user.to_s if config.user
+                  vars["PGPASSWORD"] = config.pass.to_s if config.pass
+                end
+              end
+
+              # @api private
+              def dump_file
+                "#{root_path}/db/structure.sql"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/app/db/utils/sqlite.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "database"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module DB
+          module Utils
+            # @api private
+            class Sqlite < Database
+              # @api private
+              def create_command
+                rom_config
+                true
+              end
+
+              # @api private
+              def drop_command
+                file_path.unlink
+                true
+              end
+
+              # @api private
+              def dump_command
+                raise Hanami::CLI::NotImplementedError
+              end
+
+              # @api private
+              def load_command
+                raise Hanami::CLI::NotImplementedError
+              end
+
+              # @api private
+              def file_path
+                @file_path ||= Pathname("#{root_path}#{config.uri.path}").realpath
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,11 +7,13 @@ module Hanami
     module Commands
       module App
         module DB
+          # @api private
           class Version < App::Command
             desc "Print schema version"
 
             option :target, desc: "Target migration number", aliases: ["-t"]
 
+            # @api private
             def call(target: nil, **) # rubocop:disable Lint/UnusedMethodArgument
               migration = database.applied_migrations.last
               version = migration ? File.basename(migration, ".*") : "not available"

data/lib/hanami/cli/commands/app/generate/action.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require "hanami/cli/commands/app/command"
-require "hanami/cli/generators/app/action"
 require "dry/inflector"
 require "dry/files"
 require "shellwords"
+require_relative "../../../errors"
 
 module Hanami
   module CLI
     module Commands
       module App
         module Generate
+          # @since 2.0.0
+          # @api private
           class Action < App::Command
             # TODO: ideally the default format should lookup
             #       slice configuration (Action's `default_response_format`)
@@ -44,6 +45,8 @@ module Hanami
             ]
             # rubocop:enable Layout/LineLength
 
+            # @since 2.0.0
+            # @api private
             def initialize(fs: Hanami::CLI::Files.new, inflector: Dry::Inflector.new,
                            generator: Generators::App::Action.new(fs: fs, inflector: inflector), **)
               @generator = generator
@@ -51,17 +54,21 @@ module Hanami
             end
 
             # rubocop:disable Metrics/ParameterLists
+
+            # @since 2.0.0
+            # @api private
             def call(name:, url: nil, http: nil, format: DEFAULT_FORMAT, skip_view: DEFAULT_SKIP_VIEW, slice: nil, **)
               slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
               name = inflector.underscore(Shellwords.shellescape(name))
               *controller, action = name.split(ACTION_SEPARATOR)
 
               if controller.empty?
-                raise ArgumentError.new("cannot parse controller and action name: `#{name}'\n\texample: users.show")
+                raise InvalidActionNameError.new(name)
               end
 
               generator.call(app.namespace, controller, action, url, http, format, skip_view, slice)
             end
+
             # rubocop:enable Metrics/ParameterLists
 
             private

data/lib/hanami/cli/commands/app/generate/slice.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
-require "hanami/cli/command"
-require "hanami/cli/generators/app/slice"
 require "dry/inflector"
 require "dry/files"
 require "shellwords"
-require "hanami/cli/files"
-require "hanami/cli/url"
+require_relative "../../../errors"
 
 module Hanami
   module CLI
     module Commands
       module App
         module Generate
+          # @since 2.0.0
+          # @api private
           class Slice < Command
             argument :name, required: true, desc: "The slice name"
             option :url, required: false, type: :string, desc: "The slice URL prefix"
@@ -22,12 +21,16 @@ module Hanami
               "users --url=/u # Users slice (/u URL prefix)",
             ]
 
+            # @since 2.0.0
+            # @api private
             def initialize(fs: Hanami::CLI::Files.new, inflector: Dry::Inflector.new,
                            generator: Generators::App::Slice.new(fs: fs, inflector: inflector), **)
               @generator = generator
               super(fs: fs)
             end
 
+            # @since 2.0.0
+            # @api private
             def call(name:, url: nil, **)
               require "hanami/setup"
 
@@ -51,8 +54,8 @@ module Hanami
 
               result ||= DEFAULT_URL_PREFIX + name
               CLI::URL.call(result)
-            rescue ArgumentError
-              raise ArgumentError.new("invalid URL prefix: `#{url}'")
+            rescue InvalidURLError
+              raise InvalidURLPrefixError.new(url)
             end
 
             def valid_url?(url)

data/lib/hanami/cli/commands/app/generate.rb

@@ -4,6 +4,8 @@ module Hanami
   module CLI
     module Commands
       module App
+        # @since 2.0.0
+        # @api private
         module Generate
           require_relative "./generate/slice"
           require_relative "./generate/action"

data/lib/hanami/cli/commands/app/install.rb

@@ -1,11 +1,22 @@
 # frozen_string_literal: true
 
-require "hanami/cli/command"
-
 module Hanami
   module CLI
     module Commands
       module App
+        # The `install` command exists to provide third parties a hook for their own installation
+        # behaviour to be run as part of `hanami new`.
+        #
+        # Third parties should register their install commands like so:
+        #
+        # ```
+        # if Hanami::CLI.within_hanami_app?
+        #   Hanami::CLI.after "install", MyHanamiGem::CLI::Commands::Install
+        # end
+        # ````
+        #
+        # @since 2.0.0
+        # @api private
         class Install < Command
           desc "Install Hanami third-party plugins"
 

data/lib/hanami/cli/commands/app/middleware.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "hanami"
-require "hanami/cli/middleware_stack_inspector"
 
 module Hanami
   module CLI
@@ -23,10 +22,16 @@ module Hanami
         # $ bundle exec hanami middleware --with-arguments
         # /    Rack::Session::Cookie args: [{:secret=>"foo"}]
         # ```
+        #
+        # @since 2.0.0
+        # @api private
         class Middleware < Hanami::CLI::Command
           desc "Print app Rack middleware stack"
 
+          # @since 2.0.0
+          # @api private
           DEFAULT_WITH_ARGUMENTS = false
+          private_constant :DEFAULT_WITH_ARGUMENTS
 
           option :with_arguments, default: DEFAULT_WITH_ARGUMENTS, required: false,
                                   desc: "Include inspected arguments", type: :boolean
@@ -36,6 +41,7 @@ module Hanami
             "middleware --with-arguments # Print app Rack middleware stack, including initialize arguments",
           ]
 
+          # @since 2.0.0
           # @api private
           def call(with_arguments: DEFAULT_WITH_ARGUMENTS)
             require "hanami/prepare"

data/lib/hanami/cli/commands/app/routes.rb

@@ -20,10 +20,17 @@ module Hanami
         # ```
         # $ bundle exec hanami routes --format=custom_routes_formatter
         # ```
+        #
+        # @since 2.0.0
+        # @api private
         class Routes < Hanami::CLI::Command
+          # @since 2.0.0
+          # @api private
           DEFAULT_FORMAT = "human_friendly"
           private_constant :DEFAULT_FORMAT
 
+          # @since 2.0.0
+          # @api private
           VALID_FORMATS = [
             DEFAULT_FORMAT,
             "csv"
@@ -42,6 +49,7 @@ module Hanami
             "routes --format=csv # Print app routes, using CSV format",
           ]
 
+          # @since 2.0.0
           # @api private
           def call(format: DEFAULT_FORMAT, **)
             require "hanami/router/inspector"

data/lib/hanami/cli/commands/app/server.rb

@@ -24,10 +24,17 @@ module Hanami
         # - All others are always given by the Hanami command.
         #
         # Run `bundle exec hanami server -h` to see all the supported options.
+        #
+        # @since 2.0.0
+        # @api private
         class Server < Command
+          # @since 2.0.0
+          # @api private
           DEFAULT_PORT = 2300
           private_constant :DEFAULT_PORT
 
+          # @since 2.0.0
+          # @api private
           DEFAULT_CONFIG_PATH = "config.ru"
           private_constant :DEFAULT_CONFIG_PATH
 
@@ -41,11 +48,14 @@ module Hanami
           option :debug, default: false, required: false, desc: "Turn on/off debug output", type: :boolean
           option :warn, default: false, required: false, desc: "Turn on/off warnings", type: :boolean
 
+          # @since 2.0.0
+          # @api private
           def initialize(server: Hanami::CLI::Server.new)
             super()
             @server = server
           end
 
+          # @since 2.0.0
           # @api private
           def call(port: DEFAULT_PORT, **kwargs)
             server.call(port: port, **kwargs)

data/lib/hanami/cli/commands/app/version.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
-require "hanami/cli/command"
-
 module Hanami
   module CLI
     module Commands
       module App
+        # @since 2.0.0
+        # @api private
         class Version < Command
           desc "Print Hanami app version"
 
+          # @since 2.0.0
+          # @api private
           def call(*)
             require "hanami/version"
             out.puts "v#{Hanami::VERSION}"

data/lib/hanami/cli/commands/app.rb

@@ -3,26 +3,13 @@
 module Hanami
   module CLI
     module Commands
+      # Commands made available when the `hanami` CLI is executed within an Hanami app.
+      #
+      # @api private
+      # @since 2.0.0
       module App
-        require_relative "app/version"
-        require_relative "app/install"
-        require_relative "app/console"
-        require_relative "app/server"
-        require_relative "app/routes"
-        require_relative "app/generate"
-        require_relative "app/middleware"
-        # require_relative "app/db/create"
-        # require_relative "app/db/create_migration"
-        # require_relative "app/db/drop"
-        # require_relative "app/db/migrate"
-        # require_relative "app/db/setup"
-        # require_relative "app/db/reset"
-        # require_relative "app/db/rollback"
-        # require_relative "app/db/sample_data"
-        # require_relative "app/db/seed"
-        # require_relative "app/db/structure/dump"
-        # require_relative "app/db/version"
-
+        # @since 2.0.0
+        # @api private
         def self.extended(base)
           base.module_eval do
             register "version", Commands::App::Version, aliases: ["v", "-v", "--version"]