hanami-cli 2.1.1 → 2.2.0.beta1

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "dry/files"
+require "shellwords"
+require_relative "../../../naming"
+require_relative "../../../errors"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module Generate
+          # @since 2.2.0
+          # @api private
+          class Repo < Command
+            argument :name, required: true, desc: "Repo name"
+
+            example [
+              %(books               (MyApp::Repos::BooksRepo)),
+              %(books/drafts_repo   (MyApp::Repos::Books::DraftsRepo)),
+              %(books --slice=admin (Admin::Repos::BooksRepo)),
+            ]
+
+            # @since 2.2.0
+            # @api private
+            def generator_class
+              Generators::App::Repo
+            end
+
+            # @since 2.2.0
+            # @api private
+            def call(name:, slice: nil, **opts)
+              normalized_name = if name.end_with?("_repo")
+                                  name
+                                else
+                                  "#{inflector.singularize(name)}_repo"
+                                end
+              super(name: normalized_name, slice: slice, **opts)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -12,10 +12,23 @@ module Hanami
         module Generate
           # @since 2.0.0
           # @api private
-          class Slice < Command
+          class Slice < App::Command
             argument :name, required: true, desc: "The slice name"
             option :url, required: false, type: :string, desc: "The slice URL prefix"
 
+            # @since 2.2.0
+            # @api private
+            SKIP_DB_DEFAULT = false
+            private_constant :SKIP_DB_DEFAULT
+
+            # @since 2.2.0
+            # @api private
+            option :skip_db,
+              type: :boolean,
+              required: false,
+              default: SKIP_DB_DEFAULT,
+              desc: "Skip database"
+
             example [
               "admin          # Admin slice (/admin URL prefix)",
               "users --url=/u # Users slice (/u URL prefix)",
@@ -34,14 +47,18 @@ module Hanami
 
             # @since 2.0.0
             # @api private
-            def call(name:, url: nil, **)
+            def call(
+              name:,
+              url: nil,
+              skip_db: SKIP_DB_DEFAULT
+            )
               require "hanami/setup"
 
               app = inflector.underscore(Hanami.app.namespace)
               name = inflector.underscore(Shellwords.shellescape(name))
               url = sanitize_url_prefix(name, url)
 
-              generator.call(app, name, url)
+              generator.call(app, name, url, skip_db: skip_db)
             end
 
             private

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module Generate
+          # @since 2.2.0
+          # @api private
+          class Struct < Command
+            argument :name, required: true, desc: "Struct name"
+
+            example [
+              %(book                (MyApp::Structs::Book)),
+              %(book/published_book (MyApp::Structs::Book::PublishedBook)),
+              %(book --slice=admin  (Admin::Structs::Book)),
+            ]
+
+            def generator_class
+              Generators::App::Struct
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -31,7 +31,7 @@ module Hanami
 
           # @since 2.1.0
           # @api private
-          option :head, type: :boolean, desc: "Install head deps", default: DEFAULT_HEAD
+          option :head, type: :flag, desc: "Install head deps", default: DEFAULT_HEAD
 
           # @since 2.0.0
           # @api private

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

@@ -34,7 +34,7 @@ module Hanami
           private_constant :DEFAULT_WITH_ARGUMENTS
 
           option :with_arguments, default: DEFAULT_WITH_ARGUMENTS, required: false,
-                                  desc: "Include inspected arguments", type: :boolean
+                                  desc: "Include inspected arguments", type: :flag
 
           example [
             "middleware                  # Print app Rack middleware stack",

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

@@ -41,8 +41,8 @@ module Hanami
           option :port, default: Hanami::Port::DEFAULT, required: false,
                         desc: "The port to run the server on (falls back to the rack handler)"
           option :config, default: DEFAULT_CONFIG_PATH, required: false, desc: "Rack configuration file"
-          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
+          option :debug, default: false, required: false, desc: "Turn on/off debug output", type: :flag
+          option :warn, default: false, required: false, desc: "Turn on/off warnings", type: :flag
 
           # @since 2.0.0
           # @api private

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

@@ -27,11 +27,30 @@ module Hanami
               end
             end
 
+            if Hanami.bundled?("hanami-db")
+              register "db" do |db|
+                db.register "create", DB::Create
+                db.register "drop", DB::Drop
+                db.register "migrate", DB::Migrate
+                db.register "structure dump", DB::Structure::Dump
+                db.register "structure load", DB::Structure::Load
+                db.register "seed", DB::Seed
+                db.register "prepare", DB::Prepare
+                db.register "version", DB::Version
+              end
+            end
+
             register "generate", aliases: ["g"] do |prefix|
-              prefix.register "slice", Generate::Slice
               prefix.register "action", Generate::Action
-              prefix.register "view", Generate::View
+              prefix.register "component", Generate::Component
+              prefix.register "migration", Generate::Migration
+              prefix.register "operation", Generate::Operation
               prefix.register "part", Generate::Part
+              prefix.register "relation", Generate::Relation
+              prefix.register "repo", Generate::Repo
+              prefix.register "slice", Generate::Slice
+              prefix.register "struct", Generate::Struct
+              prefix.register "view", Generate::View
             end
           end
         end

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

@@ -25,6 +25,27 @@ module Hanami
           SKIP_ASSETS_DEFAULT = false
           private_constant :SKIP_ASSETS_DEFAULT
 
+          # @since 2.2.0
+          # @api private
+          SKIP_DB_DEFAULT = false
+          private_constant :SKIP_DB_DEFAULT
+
+          # @since 2.2.0
+          # @api private
+          DATABASE_SQLITE = "sqlite"
+
+          # @since 2.2.0
+          # @api private
+          DATABASE_POSTGRES = "postgres"
+
+          # @since 2.2.0
+          # @api private
+          DATABASE_MYSQL = "mysql"
+
+          # @since 2.2.0
+          # @api private
+          SUPPORTED_DATABASES = [DATABASE_SQLITE, DATABASE_POSTGRES, DATABASE_MYSQL].freeze
+
           desc "Generate a new Hanami app"
 
           # @since 2.0.0
@@ -33,28 +54,42 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          option :skip_install, type: :boolean, required: false,
+          option :skip_install, type: :flag, required: false,
                                 default: SKIP_INSTALL_DEFAULT,
                                 desc: "Skip app installation (Bundler, third-party Hanami plugins)"
 
           # @since 2.1.0
           # @api private
-          option :head, type: :boolean, required: false,
+          option :head, type: :flag, required: false,
                         default: HEAD_DEFAULT,
                         desc: "Use Hanami HEAD version (from GitHub `main` branches)"
 
           # @since 2.1.0
           # @api private
-          option :skip_assets, type: :boolean, required: false,
+          option :skip_assets, type: :flag, required: false,
                                default: SKIP_ASSETS_DEFAULT,
-                               desc: "Skip assets"
+                               desc: "Skip including hanami-assets"
+
+          # @since 2.2.0
+          # @api private
+          option :skip_db, type: :flag, required: false,
+                           default: SKIP_DB_DEFAULT,
+                           desc: "Skip including hanami-db"
+
+          # @since 2.2.0
+          # @api private
+          option :database, type: :string, required: false,
+                            default: DATABASE_SQLITE,
+                            desc: "Database adapter (supported: sqlite, mysql, postgres)"
 
           # rubocop:disable Layout/LineLength
           example [
-            "bookshelf                # Generate a new Hanami app in `bookshelf/' directory, using `Bookshelf' namespace",
-            "bookshelf --head         # Generate a new Hanami app, using Hanami HEAD version from GitHub `main' branches",
-            "bookshelf --skip-install # Generate a new Hanami app, but it skips Hanami installation",
-            "bookshelf --skip-assets  # Generate a new Hanami app without assets"
+            "bookshelf                                    # Generate a new Hanami app in `bookshelf/' directory, using `Bookshelf' namespace",
+            "bookshelf --head                             # Generate a new Hanami app, using Hanami HEAD version from GitHub `main' branches",
+            "bookshelf --skip-install                     # Generate a new Hanami app, but it skips Hanami installation",
+            "bookshelf --skip-assets                      # Generate a new Hanami app without hanmai-assets",
+            "bookshelf --skip-db                          # Generate a new Hanami app without hanami-db",
+            "bookshelf --database={sqlite|postgres|mysql} # Generate a new Hanami app with a specified database (default: sqlite)",
           ]
           # rubocop:enable Layout/LineLength
 
@@ -75,20 +110,36 @@ module Hanami
             @system_call = system_call
           end
 
-          # rubocop:enable Metrics/ParameterLists
-
-          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
 
           # @since 2.0.0
           # @api private
-          def call(app:, head: HEAD_DEFAULT, skip_install: SKIP_INSTALL_DEFAULT, skip_assets: SKIP_ASSETS_DEFAULT, **)
+          def call(
+            app:,
+            head: HEAD_DEFAULT,
+            skip_install: SKIP_INSTALL_DEFAULT,
+            skip_assets: SKIP_ASSETS_DEFAULT,
+            skip_db: SKIP_DB_DEFAULT,
+            database: nil
+          )
+            # rubocop:enable Metrics/ParameterLists
             app = inflector.underscore(app)
 
             raise PathAlreadyExistsError.new(app) if fs.exist?(app)
+            raise ConflictingOptionsError.new("--skip-db", "--database") if skip_db && database
+
+            normalized_database ||= normalize_database(database)
 
             fs.mkdir(app)
             fs.chdir(app) do
-              context = Generators::Context.new(inflector, app, head: head, skip_assets: skip_assets)
+              context = Generators::Context.new(
+                inflector,
+                app,
+                head: head,
+                skip_assets: skip_assets,
+                skip_db: skip_db,
+                database: normalized_database
+              )
               generator.call(app, context: context) do
                 if skip_install
                   out.puts "Skipping installation, please enter `#{app}' directory and run `bundle exec hanami install'"
@@ -112,7 +163,7 @@ module Hanami
               end
             end
           end
-          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
 
           private
 
@@ -120,6 +171,19 @@ module Hanami
           attr_reader :generator
           attr_reader :system_call
 
+          def normalize_database(database)
+            case database
+            when nil, "sqlite", "sqlite3"
+              DATABASE_SQLITE
+            when "mysql", "mysql2"
+              DATABASE_MYSQL
+            when "postgres", "postgresql", "pg"
+              DATABASE_POSTGRES
+            else
+              raise DatabaseNotSupportedError.new(database, SUPPORTED_DATABASES)
+            end
+          end
+
           def run_install_command!(head:)
             head_flag = head ? " --head" : ""
             bundler.exec("hanami install#{head_flag}").tap do |result|

data/lib/hanami/cli/errors.rb

@@ -91,5 +91,33 @@ module Hanami
         super("`#{scheme}' is not a supported db scheme")
       end
     end
+
+    # @since 2.2.0
+    # @api public
+    class DatabaseNotSupportedError < Error
+      def initialize(invalid_database, supported_databases)
+        super("`#{invalid_database}' is not a supported database. Supported databases are: #{supported_databases.join(', ')}")
+      end
+    end
+
+    # @since 2.2.0
+    # @api public
+    class ConflictingOptionsError < Error
+      def initialize(option1, option2)
+        super("`#{option1}' and `#{option2}' cannot be used together")
+      end
+    end
+
+    # @since 2.2.0
+    # @api public
+    class InvalidMigrationNameError < Error
+      def initialize(name)
+        super(<<~TEXT)
+          Invalid migration name: #{name}
+
+          Name must contain only letters, numbers, and underscores.
+        TEXT
+      end
+    end
   end
 end

data/lib/hanami/cli/generators/app/action_context.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "slice_context"
 require "dry/files/path"
+require_relative "slice_context"
+require_relative "../constants"
 
 module Hanami
   module CLI
@@ -52,7 +53,7 @@ module Hanami
           # @api private
           def module_controller_declaration
             controller.each_with_index.map do |token, i|
-              "#{OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
+              "#{NESTED_OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
             end.join($/)
           end
 
@@ -60,14 +61,14 @@ module Hanami
           # @api private
           def module_controller_end
             controller.each_with_index.map do |_, i|
-              "#{OFFSET}#{INDENTATION * i}end"
+              "#{NESTED_OFFSET}#{INDENTATION * i}end"
             end.reverse.join($/)
           end
 
           # @since 2.0.0
           # @api private
           def module_controller_offset
-            "#{OFFSET}#{INDENTATION * controller.count}"
+            "#{NESTED_OFFSET}#{INDENTATION * controller.count}"
           end
 
           # @since 2.0.0
@@ -79,15 +80,6 @@ module Hanami
 
           private
 
-          NAMESPACE_SEPARATOR = "::"
-          private_constant :NAMESPACE_SEPARATOR
-
-          INDENTATION = "  "
-          private_constant :INDENTATION
-
-          OFFSET = INDENTATION * 2
-          private_constant :OFFSET
-
           attr_reader :controller
 
           attr_reader :action

data/lib/hanami/cli/generators/app/component/component.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module <%= camelized_app_name %>
+<%= module_namespace_declaration %>
+<%= module_namespace_offset %>class <%= camelized_name %>
+<%= module_namespace_offset %>end
+<%= module_namespace_end %>
+end

data/lib/hanami/cli/generators/app/component/slice_component.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+<%= module_namespace_declaration %>
+<%= module_namespace_offset %>class <%= camelized_name %>
+<%= module_namespace_offset %>end
+<%= module_namespace_end %>
+end

data/lib/hanami/cli/generators/app/component.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "erb"
+require "dry/files"
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @api private
+        # @since 2.2.0
+        class Component
+          # @api private
+          # @since 2.2.0
+          def initialize(fs:, inflector:)
+            @fs = fs
+            @inflector = inflector
+          end
+
+          # @api private
+          # @since 2.2.0
+          def call(app, key, slice)
+            context = ComponentContext.new(inflector, app, slice, key)
+
+            if slice
+              generate_for_slice(context, slice)
+            else
+              generate_for_app(context)
+            end
+          end
+
+          private
+
+          attr_reader :fs
+
+          attr_reader :inflector
+
+          def generate_for_slice(context, slice)
+            slice_directory = fs.join("slices", slice)
+            raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
+
+            fs.mkdir(directory = fs.join(slice_directory, context.namespaces))
+            fs.write(fs.join(directory, "#{context.underscored_name}.rb"), t("slice_component.erb", context))
+          end
+
+          def generate_for_app(context)
+            fs.mkdir(directory = fs.join("app", context.namespaces))
+            fs.write(fs.join(directory, "#{context.underscored_name}.rb"), t("component.erb", context))
+          end
+
+          def template(path, context)
+            ERB.new(
+              File.read(__dir__ + "/component/#{path}")
+            ).result(context.ctx)
+          end
+
+          alias_method :t, :template
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/app/component_context.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        class ComponentContext < SliceContext
+          # @api private
+          # @since 2.2.0
+          attr_reader :key
+
+          # @api private
+          # @since 2.2.0
+          def initialize(inflector, app, slice, key)
+            @key = key
+            super(inflector, app, slice, nil)
+          end
+
+          # @api private
+          # @since 2.2.0
+          def namespaces
+            @namespaces ||= key.split(MATCHER_PATTERN)[..-2].map { inflector.underscore(_1) }
+          end
+
+          # @api private
+          # @since 2.2.0
+          def name
+            @name ||= key.split(MATCHER_PATTERN)[-1]
+          end
+
+          # @api private
+          # @since 2.2.0
+          def camelized_namespace
+            namespaces.map { inflector.camelize(_1) }.join(NAMESPACE_SEPARATOR)
+          end
+
+          # @api private
+          # @since 2.2.0
+          def camelized_name
+            inflector.camelize(name)
+          end
+
+          # @api private
+          # @since 2.2.0
+          def underscored_namespace
+            namespaces.map { inflector.underscore(_1) }
+          end
+
+          # @api private
+          # @since 2.2.0
+          def underscored_name
+            inflector.underscore(name)
+          end
+
+          # @api private
+          # @since 2.2.0
+          def module_namespace_declaration
+            namespaces.each_with_index.map { |token, i|
+              "#{OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
+            }.join($/)
+          end
+
+          # @api private
+          # @since 2.2.0
+          def module_namespace_end
+            namespaces.each_with_index.map { |_, i|
+              "#{OFFSET}#{INDENTATION * i}end"
+            }.reverse.join($/)
+          end
+
+          # @api private
+          # @since 2.2.0
+          def module_namespace_offset
+            "#{OFFSET}#{INDENTATION * namespaces.count}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/app/migration.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @since 2.2.0
+        # @api private
+        class Migration
+          # @since 2.2.0
+          # @api private
+          def initialize(fs:, inflector:, out: $stdout)
+            @fs = fs
+            @inflector = inflector
+            @out = out
+          end
+
+          # @since 2.2.0
+          # @api private
+          def call(_app_namespace, name, slice, **_opts)
+            normalized_name = inflector.underscore(name)
+            ensure_valid_name(normalized_name)
+
+            base = if slice
+                     fs.join("slices", slice, "config", "db", "migrate")
+                   else
+                     fs.join("config", "db", "migrate")
+                   end
+
+            path = fs.join(base, file_name(normalized_name))
+
+            fs.write(path, FILE_CONTENTS)
+          end
+
+          private
+
+          attr_reader :fs, :inflector, :out
+
+          VALID_NAME_REGEX = /^[_a-z0-9]+$/
+          private_constant :VALID_NAME_REGEX
+
+          def ensure_valid_name(name)
+            unless VALID_NAME_REGEX.match?(name.downcase)
+              raise InvalidMigrationNameError.new(name)
+            end
+          end
+
+          def file_name(name)
+            "#{Time.now.strftime(VERSION_FORMAT)}_#{name}.rb"
+          end
+
+          VERSION_FORMAT = "%Y%m%d%H%M%S"
+          private_constant :VERSION_FORMAT
+
+          FILE_CONTENTS = <<~RUBY
+            # frozen_string_literal: true
+
+            ROM::SQL.migration do
+              # Add your migration here.
+              #
+              # See https://sequel.jeremyevans.net/rdoc/files/doc/migration_rdoc.html for details.
+            end
+          RUBY
+          private_constant :FILE_CONTENTS
+        end
+      end
+    end
+  end
+end