hanami-cli 1.0.0.alpha1 → 2.0.0.alpha2

data/lib/hanami/cli/command_line.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "./bundler"
+
+module Hanami
+  module CLI
+    class CommandLine
+      def initialize(bundler: CLI::Bundler.new)
+        @bundler = bundler
+      end
+
+      def call(command)
+        @bundler.exec(command)
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hanami
+  # TODO: move elsewhere
+  def self.architecture
+    return :monolith if File.exist?("config/application.rb")
+  end
+
+  module CLI
+    module Commands
+    end
+
+    def self.register_commands!(architecture = Hanami.architecture)
+      commands = case architecture
+                 when :monolith
+                   require_relative "commands/monolith"
+                   Commands::Monolith
+                 else
+                   require_relative "commands/gem"
+                   Commands::Gem
+                 end
+
+      extend(commands)
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "dry/files"
+
+require_relative "db/utils/database"
+
+module Hanami
+  module CLI
+    module Commands
+      class Application < Hanami::CLI::Command
+        module Environment
+          def call(**opts)
+            env = opts[:env]
+            ENV["HANAMI_ENV"] = env.to_s
+            super(**opts)
+          end
+        end
+
+        def self.inherited(klass)
+          super
+          klass.option(:env, required: false, default: "development", desc: "Application's environment")
+          klass.prepend(Environment)
+        end
+
+        def application
+          @application ||=
+            begin
+              require "hanami/init"
+              Hanami.application
+            end
+        end
+
+        def run_command(klass, *args)
+          klass.new(
+            out: out,
+            inflector: application.inflector,
+            fs: Dry::Files
+          ).call(*args)
+        end
+
+        def measure(desc)
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result = yield
+          stop = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          if result
+            out.puts "=> #{desc} in #{(stop - start).round(4)}s"
+          else
+            out.puts "!!! => #{desc.inspect} FAILED"
+          end
+        end
+
+        def database
+          @database ||= Commands::DB::Utils::Database[application]
+        end
+
+        def database_config
+          database.config
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "database_config"
+
+module Hanami
+  module CLI
+    module Commands
+      module DB
+        module Utils
+          class Database
+            attr_reader :application, :config
+
+            SCHEME_MAP = {
+              "sqlite" => -> {
+                require_relative("sqlite")
+                Sqlite
+              },
+              "postgres" => -> {
+                require_relative("postgres")
+                Postgres
+              },
+              "mysql" => -> {
+                require_relative("mysql")
+                Mysql
+              }
+            }.freeze
+
+            def self.[](application)
+              config = DatabaseConfig.new(application.settings.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(application: application, config: config)
+            end
+
+            def initialize(application:, config:)
+              @application = application
+              @config = config
+            end
+
+            def create_command
+              raise NotImplementedError
+            end
+
+            def drop_command
+              raise NotImplementedError
+            end
+
+            def dump_command
+              raise NotImplementedError
+            end
+
+            def load_command
+              raise NotImplementedError
+            end
+
+            def root_path
+              application.root
+            end
+
+            def rom_config
+              @rom_config ||=
+                begin
+                  application.init_bootable(:persistence)
+                  application.container["persistence.config"]
+                end
+            end
+
+            def name
+              config.db_name
+            end
+
+            def applied_migrations
+              sequel_migrator.applied_migrations
+            end
+
+            def gateway
+              rom_config.gateways[:default]
+            end
+
+            def connection
+              gateway.connection
+            end
+
+            def run_migrations(**options)
+              require "rom/sql"
+              ROM::SQL.with_gateway(gateway) do
+                migrator.run(options)
+              end
+            end
+
+            def migrator
+              @migrator ||=
+                begin
+                  require "rom/sql"
+                  ROM::SQL::Migration::Migrator.new(connection, path: File.join(root_path, "db/migrate"))
+                end
+            end
+
+            def applied_migrations
+              sequel_migrator.applied_migrations
+            end
+
+            private
+
+            def sequel_migrator
+              Sequel::TimestampMigrator.new(migrator.connection, migrations_path, {})
+            end
+
+            def migrations_path
+              File.join(root_path, "db/migrate")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "database"
+
+module Hanami
+  module CLI
+    module Commands
+      module DB
+        module Utils
+          class Mysql < Database
+            def create_command
+              raise "Not Implemented Yet"
+            end
+
+            def dump_command
+              raise "Not Implemented Yet"
+            end
+
+            def load_command
+              raise "Not Implemented Yet"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative "database"
+
+module Hanami
+  module CLI
+    module Commands
+      module DB
+        module Utils
+          class Postgres < Database
+            def create_command
+              system(cli_env_vars, "createdb #{escaped_name}")
+            end
+
+            def drop_command
+              system(cli_env_vars, "dropdb #{escaped_name}")
+            end
+
+            def dump_command
+              system(cli_env_vars, "pg_dump --schema-only --no-owner #{escaped_name} > #{dump_file}")
+            end
+
+            def load_command
+              raise "Not Implemented Yet"
+            end
+
+            def escaped_name
+              Shellwords.escape(name)
+            end
+
+            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
+
+            def dump_file
+              "#{root_path}/db/structure.sql"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Commands
+      module Gem
+        require_relative "gem/version"
+        # FIXME: temporary disabled for Hanami v2.0.0.alpha2
+        # require_relative "gem/new"
+
+        def self.extended(base)
+          base.module_eval do
+            register "version", Version, aliases: ["v", "-v", "--version"]
+            # FIXME: temporary disabled for Hanami v2.0.0.alpha2
+            # register "new", New
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/gem/new.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "hanami/cli/command"
+require "hanami/cli/bundler"
+require "hanami/cli/command_line"
+require "hanami/cli/generators/gem/application"
+require "dry/files"
+
+module Hanami
+  module CLI
+    module Commands
+      module Gem
+        class New < Command
+          ARCHITECTURES = %w[monolith micro].freeze
+          private_constant :ARCHITECTURES
+
+          DEFAULT_ARCHITECTURE = ARCHITECTURES.first
+          private_constant :DEFAULT_ARCHITECTURE
+
+          DEFAULT_SLICE_NAME = "main"
+          private_constant :DEFAULT_SLICE_NAME
+
+          DEFAULT_SLICE_URL_PREFIX = "/"
+          private_constant :DEFAULT_SLICE_URL_PREFIX
+
+          argument :app, required: true, desc: "The application name"
+
+          option :architecture, alias: "arch", default: DEFAULT_ARCHITECTURE,
+                                values: ARCHITECTURES, desc: "The architecture"
+
+          option :slice, default: DEFAULT_SLICE_NAME, desc: %(The initial slice name, only for "monolith" architecture)
+          option :slice_url_prefix, default: DEFAULT_SLICE_URL_PREFIX,
+                                    desc: %(The initial slice URL prefix, only for "monolith" architecture)
+
+          def initialize(fs: Dry::Files.new, bundler: CLI::Bundler.new(fs: fs),
+                         command_line: CLI::CommandLine.new(bundler: bundler), **other)
+            @bundler = bundler
+            @command_line = command_line
+            super(fs: fs, **other)
+          end
+
+          def call(app:, architecture: DEFAULT_ARCHITECTURE, slice: DEFAULT_SLICE_NAME,
+                   slice_url_prefix: DEFAULT_SLICE_URL_PREFIX, **)
+            app = inflector.underscore(app)
+
+            fs.mkdir(app)
+            fs.chdir(app) do
+              generator(architecture).call(app, slice, slice_url_prefix) do
+                bundler.install!
+                run_install_commmand!
+              end
+            end
+          end
+
+          private
+
+          attr_reader :bundler
+          attr_reader :command_line
+
+          def generator(architecture)
+            unless ARCHITECTURES.include?(architecture)
+              raise ArgumentError.new("unknown architecture `#{architecture}'")
+            end
+
+            Generators::Gem::Application[architecture, fs, inflector, command_line]
+          end
+
+          def run_install_commmand!
+            command_line.call("hanami install").tap do |result|
+              raise "hanami install failed\n\n\n#{result.err.inspect}" unless result.successful?
+            end
+          end
+        end
+      end
+    end
+  end
+end