hanami-cli 2.1.0 → 2.2.0.beta1

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

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @since 2.2.0
+        # @api private
+        class Operation
+          # @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, key, slice)
+            RubyFileWriter.new(
+              fs: fs,
+              inflector: inflector,
+              app_namespace: app_namespace,
+              key: key,
+              slice: slice,
+              relative_parent_class: "Operation",
+              body: ["def call", "end"],
+            ).call
+
+            unless key.match?(KEY_SEPARATOR)
+              out.puts(
+                "  Note: We generated a top-level operation. " \
+                "To generate into a directory, add a namespace: `my_namespace.add_book`"
+              )
+            end
+          end
+
+          private
+
+          attr_reader :fs, :inflector, :out
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/app/part_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
@@ -12,23 +13,6 @@ module Hanami
         # @since 2.1.0
         # @api private
         class PartContext < SliceContext
-          # TODO: move these constants somewhere that will let us reuse them
-
-          # @since 2.1.0
-          # @api private
-          KEY_SEPARATOR = "."
-          private_constant :KEY_SEPARATOR
-
-          # @since 2.1.0
-          # @api private
-          INDENTATION = "  "
-          private_constant :INDENTATION
-
-          # @since 2.1.0
-          # @api private
-          OFFSET = INDENTATION * 2
-          private_constant :OFFSET
-
           # @since 2.1.0
           # @api private
           attr_reader :key
@@ -74,7 +58,7 @@ module Hanami
           # @api private
           def module_namespace_declaration
             namespaces.each_with_index.map { |token, i|
-              "#{OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
+              "#{NESTED_OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
             }.join($/)
           end
 
@@ -82,14 +66,14 @@ module Hanami
           # @api private
           def module_namespace_end
             namespaces.each_with_index.map { |_, i|
-              "#{OFFSET}#{INDENTATION * i}end"
+              "#{NESTED_OFFSET}#{INDENTATION * i}end"
             }.reverse.join($/)
           end
 
           # @since 2.1.0
           # @api private
           def module_namespace_offset
-            "#{OFFSET}#{INDENTATION * namespaces.count}"
+            "#{NESTED_OFFSET}#{INDENTATION * namespaces.count}"
           end
         end
       end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @since 2.2.0
+        # @api private
+        class Relation
+          # @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, key, slice)
+            schema_name = key.split(KEY_SEPARATOR).last
+
+            RubyFileWriter.new(
+              fs: fs,
+              inflector: inflector,
+              app_namespace: app_namespace,
+              key: key,
+              slice: slice,
+              extra_namespace: "Relations",
+              relative_parent_class: "DB::Relation",
+              body: ["schema :#{schema_name}, infer: true"],
+            ).call
+          end
+
+          private
+
+          attr_reader :fs, :inflector, :out
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @since 2.2.0
+        # @api private
+        class Repo
+          # @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, key, slice)
+            RubyFileWriter.new(
+              fs: fs,
+              inflector: inflector,
+              app_namespace: app_namespace,
+              key: key,
+              slice: slice,
+              extra_namespace: "Repos",
+              relative_parent_class: "DB::Repo",
+              body: [],
+            ).call
+          end
+
+          private
+
+          attr_reader :fs, :inflector, :out
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "erb"
+require "dry/files"
+require_relative "../constants"
+require_relative "../../errors"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @since 2.2.0
+        # @api private
+        class RubyFileWriter
+          # @since 2.2.0
+          # @api private
+          def initialize(
+            fs:,
+            inflector:,
+            app_namespace:,
+            key:,
+            slice:,
+            relative_parent_class:,
+            extra_namespace: nil,
+            body: []
+          )
+            @fs = fs
+            @inflector = inflector
+            @app_namespace = app_namespace
+            @key = key
+            @slice = slice
+            @extra_namespace = extra_namespace&.downcase
+            @relative_parent_class = relative_parent_class
+            @body = body
+            raise_missing_slice_error_if_missing(slice) if slice
+          end
+
+          # @since 2.2.0
+          # @api private
+          def call
+            fs.mkdir(directory)
+            fs.write(path, file_contents)
+          end
+
+          private
+
+          # @since 2.2.0
+          # @api private
+          attr_reader(
+            :fs,
+            :inflector,
+            :app_namespace,
+            :key,
+            :slice,
+            :extra_namespace,
+            :relative_parent_class,
+            :body,
+          )
+
+          # @since 2.2.0
+          # @api private
+          def file_contents
+            class_definition(
+              class_name: class_name,
+              container_namespace: container_namespace,
+              local_namespaces: local_namespaces,
+            )
+          end
+
+          # @since 2.2.0
+          # @api private
+          def class_name
+            key.split(KEY_SEPARATOR)[-1]
+          end
+
+          # @since 2.2.0
+          # @api private
+          def container_namespace
+            slice || app_namespace
+          end
+
+          # @since 2.2.0
+          # @api private
+          def local_namespaces
+            Array(extra_namespace) + key.split(KEY_SEPARATOR)[..-2]
+          end
+
+          # @since 2.2.0
+          # @api private
+          def directory
+            base = if slice
+                     fs.join("slices", slice)
+                   else
+                     fs.join("app")
+                   end
+
+            @directory ||= if local_namespaces.any?
+                             fs.join(base, local_namespaces)
+                           else
+                             fs.join(base)
+                           end
+          end
+
+          # @since 2.2.0
+          # @api private
+          def path
+            fs.join(directory, "#{class_name}.rb")
+          end
+
+          # @since 2.2.0
+          # @api private
+          def class_definition(class_name:, container_namespace:, local_namespaces:)
+            container_module = normalize(container_namespace)
+
+            modules = local_namespaces
+              .map { normalize(_1) }
+              .compact
+              .prepend(container_module)
+
+            parent_class = [container_module, relative_parent_class].join("::")
+
+            RubyFileGenerator.class(
+              normalize(class_name),
+              parent_class: parent_class,
+              modules: modules,
+              header: ["# frozen_string_literal: true"],
+              body: body
+            )
+          end
+
+          # @since 2.2.0
+          # @api private
+          def normalize(name)
+            inflector.camelize(name).gsub(/[^\p{Alnum}]/, "")
+          end
+
+          # @since 2.2.0
+          # @api private
+          def raise_missing_slice_error_if_missing(slice)
+            if slice
+              slice_directory = fs.join("slices", slice)
+              raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/app/slice/operation.erb

@@ -0,0 +1,7 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  class Operation < <%= camelized_app_name %>::Operation
+  end
+end

data/lib/hanami/cli/generators/app/slice/relation.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module DB
+    class Relation < <%= camelized_app_name %>::DB::Relation
+    end
+  end
+end

data/lib/hanami/cli/generators/app/slice/{slice.erb → repo.erb}

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module <%= camelized_slice_name %>
-  class Slice < Hanami::Slice
+  module DB
+    class Repo < <%= camelized_app_name %>::DB::Repo
+    end
   end
 end

data/lib/hanami/cli/generators/app/slice/struct.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module DB
+    class Struct < <%= camelized_app_name %>::DB::Struct
+    end
+  end
+end

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

@@ -19,18 +19,20 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def call(app, slice, url, context: SliceContext.new(inflector, app, slice, url)) # rubocop:disable Metrics/AbcSize
+          def call(app, slice, url, context: nil, **opts)
+            context ||= SliceContext.new(inflector, app, slice, url, **opts)
+
             fs.inject_line_at_class_bottom(
               fs.join("config", "routes.rb"), "class Routes", t("routes.erb", context).chomp
             )
 
             fs.mkdir(directory = "slices/#{slice}")
 
-            # fs.write("#{directory}/config/slice.rb", t("slice.erb", context))
             fs.write(fs.join(directory, "action.rb"), t("action.erb", context))
             fs.write(fs.join(directory, "view.rb"), t("view.erb", context))
             fs.write(fs.join(directory, "views", "helpers.rb"), t("helpers.erb", context))
             fs.write(fs.join(directory, "templates", "layouts", "app.html.erb"), t("app_layout.erb", context))
+            fs.write(fs.join(directory, "operation.rb"), t("operation.erb", context))
 
             if context.bundled_assets?
               fs.write(fs.join(directory, "assets", "js", "app.js"), t("app_js.erb", context))
@@ -38,15 +40,21 @@ module Hanami
               fs.write(fs.join(directory, "assets", "images", "favicon.ico"), file("favicon.ico"))
             end
 
-            # fs.write(fs.join(directory, "/entities.rb"), t("entities.erb", context))
-            # fs.write(fs.join(directory, "/repository.rb"), t("repository.erb", context))
+            if context.generate_db?
+              fs.write(fs.join(directory, "db", "relation.rb"), t("relation.erb", context))
+              fs.write(fs.join(directory, "relations", ".keep"), t("keep.erb", context))
+
+              fs.write(fs.join(directory, "db", "repo.rb"), t("repo.erb", context))
+              fs.write(fs.join(directory, "repos", ".keep"), t("keep.erb", context))
+
+              fs.write(fs.join(directory, "db", "struct.rb"), t("struct.erb", context))
+              fs.write(fs.join(directory, "structs", ".keep"), t("keep.erb", context))
+            end
 
             fs.write(fs.join(directory, "actions/.keep"), t("keep.erb", context))
             fs.write(fs.join(directory, "views/.keep"), t("keep.erb", context))
             fs.write(fs.join(directory, "templates/.keep"), t("keep.erb", context))
             fs.write(fs.join(directory, "templates/layouts/.keep"), t("keep.erb", context))
-            # fs.write(fs.join(directory, entities/.keep"), t("keep.erb", context))
-            # fs.write(fs.join(directory, repositories/.keep"), t("keep.erb", context))
           end
 
           private

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../context"
+require_relative "../constants"
 
 module Hanami
   module CLI
@@ -11,10 +12,10 @@ module Hanami
         class SliceContext < Generators::Context
           # @since 2.0.0
           # @api private
-          def initialize(inflector, app, slice, url)
+          def initialize(inflector, app, slice, url, **options)
             @slice = slice
             @url = url
-            super(inflector, app)
+            super(inflector, app, **options)
           end
 
           # @since 2.0.0
@@ -47,6 +48,12 @@ module Hanami
             %(<%= javascript_tag "app" %>)
           end
 
+          # @since 2.2.0
+          # @api private
+          def generate_db?
+            !options.fetch(:skip_db, false)
+          end
+
           private
 
           attr_reader :slice

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @since 2.2.0
+        # @api private
+        class Struct
+          # @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, key, slice)
+            RubyFileWriter.new(
+              fs: fs,
+              inflector: inflector,
+              app_namespace: app_namespace,
+              key: key,
+              slice: slice,
+              extra_namespace: "Structs",
+              relative_parent_class: "DB::Struct",
+            ).call
+          end
+
+          private
+
+          attr_reader :fs, :inflector, :out
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require_relative "slice_context"
 require "dry/files/path"
+require_relative "../constants"
 
 module Hanami
   module CLI
@@ -12,19 +13,6 @@ module Hanami
         # @since 2.1.0
         # @api private
         class ViewContext < SliceContext
-          # TODO: move these constants somewhere that will let us reuse them
-          KEY_SEPARATOR = "."
-          private_constant :KEY_SEPARATOR
-
-          NAMESPACE_SEPARATOR = "::"
-          private_constant :NAMESPACE_SEPARATOR
-
-          INDENTATION = "  "
-          private_constant :INDENTATION
-
-          OFFSET = INDENTATION * 2
-          private_constant :OFFSET
-
           # @since 2.1.0
           # @api private
           attr_reader :key
@@ -76,7 +64,7 @@ module Hanami
           # @api private
           def module_namespace_declaration
             namespaces.each_with_index.map { |token, i|
-              "#{OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
+              "#{NESTED_OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
             }.join($/)
           end
 
@@ -84,14 +72,14 @@ module Hanami
           # @api private
           def module_namespace_end
             namespaces.each_with_index.map { |_, i|
-              "#{OFFSET}#{INDENTATION * i}end"
+              "#{NESTED_OFFSET}#{INDENTATION * i}end"
             }.reverse.join($/)
           end
 
           # @since 2.1.0
           # @api private
           def module_namespace_offset
-            "#{OFFSET}#{INDENTATION * namespaces.count}"
+            "#{NESTED_OFFSET}#{INDENTATION * namespaces.count}"
           end
         end
       end

data/lib/hanami/cli/generators/constants.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    # @since 2.2.0
+    # @api private
+    module Generators
+      # @since 2.2.0
+      # @api private
+      INDENTATION = "  "
+      private_constant :INDENTATION
+
+      # @since 2.2.0
+      # @api private
+      OFFSET = INDENTATION
+      private_constant :OFFSET
+
+      # @since 2.2.0
+      # @api private
+      NESTED_OFFSET = INDENTATION * 2
+      private_constant :OFFSET
+
+      # @since 2.2.0
+      # @api private
+      KEY_SEPARATOR = %r{[.\/]}
+      private_constant :KEY_SEPARATOR
+
+      # @since 2.2.0
+      # @api private
+      MATCHER_PATTERN = /::|\./
+      private_constant :MATCHER_PATTERN
+
+      # @since 2.2.0
+      # @api private
+      NAMESPACE_SEPARATOR = "::"
+      private_constant :NAMESPACE_SEPARATOR
+    end
+  end
+end