hanami-cli 2.1.1 → 2.2.0.beta2

data/lib/hanami/cli/files.rb

@@ -18,7 +18,11 @@ module Hanami
       # @api private
       def write(path, *content)
         already_exists = exist?(path)
+
         super
+
+        delete_keepfiles(path) unless already_exists
+
         if already_exists
           updated(path)
         else
@@ -46,6 +50,24 @@ module Hanami
 
       attr_reader :out
 
+      # Removes .keep files in any directories leading up to the given path.
+      #
+      # Does not attempt to remove `.keep` files in the following scenarios:
+      #   - When the given path is a `.keep` file itself.
+      #   - When the given path is absolute, since ascending up this path may lead to removal of
+      #     files outside the Hanami project directory.
+      def delete_keepfiles(path)
+        path = Pathname(path)
+
+        return if path.absolute?
+        return if path.relative_path_from(path.dirname).to_s == ".keep"
+
+        path.dirname.ascend do |part|
+          keepfile = (part + ".keep").to_path
+          delete(keepfile) if exist?(keepfile)
+        end
+      end
+
       def updated(path)
         out.puts "Updated #{path}"
       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,66 @@
+# 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(key:, base_path:, gateway: nil, **_opts)
+            name = inflector.underscore(key)
+            ensure_valid_name(name)
+
+            base_path = nil if base_path == "app" # Migrations are in the root dir, not app/
+            migrate_dir = gateway ? "#{gateway}_migrate" : "migrate"
+
+            path = fs.join(*[base_path, "config", "db", migrate_dir, file_name(name)].compact)
+
+            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,49 @@
+# 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(key:, namespace:, base_path:)
+            RubyFileWriter.new(
+              fs: fs,
+              inflector: inflector,
+            ).call(
+              namespace: namespace,
+              base_path: base_path,
+              key: key,
+              relative_parent_class: "Operation",
+              body: ["def call", "end"],
+            )
+
+            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,45 @@
+# 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(key:, namespace:, base_path:)
+            schema_name = key.split(KEY_SEPARATOR).last
+
+            RubyFileWriter.new(
+              fs: fs,
+              inflector: inflector,
+            ).call(
+              namespace: namespace,
+              key: key,
+              base_path: base_path,
+              extra_namespace: "Relations",
+              relative_parent_class: "DB::Relation",
+              body: ["schema :#{schema_name}, infer: true"],
+            )
+          end
+
+          private
+
+          attr_reader :fs, :inflector, :out
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# 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(key:, namespace:, base_path:)
+            RubyFileWriter.new(
+              fs: fs,
+              inflector: inflector,
+            ).call(
+              key: key,
+              namespace: namespace,
+              base_path: base_path,
+              extra_namespace: "Repos",
+              relative_parent_class: "DB::Repo",
+              body: [],
+            )
+          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,151 @@
+# 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:)
+            @fs = fs
+            @inflector = inflector
+          end
+
+          # @since 2.2.0
+          # @api private
+          def call(key:, namespace:, base_path:, relative_parent_class:, extra_namespace: nil, body: [])
+            ClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              key: key,
+              namespace: namespace,
+              base_path: base_path,
+              relative_parent_class: relative_parent_class,
+              extra_namespace: extra_namespace,
+              body: body,
+            ).write
+          end
+
+          private
+
+          # @since 2.2.0
+          # @api private
+          attr_reader :fs, :inflector
+        end
+
+        class ClassFile
+          def initialize(
+            fs:,
+            inflector:,
+            key:,
+            namespace:,
+            base_path:,
+            relative_parent_class:,
+            extra_namespace: nil,
+            body: []
+          )
+            @fs = fs
+            @inflector = inflector
+            @key = key
+            @namespace = namespace
+            @base_path = base_path
+            @extra_namespace = extra_namespace&.downcase
+            @relative_parent_class = relative_parent_class
+            @body = body
+          end
+
+          def write
+            fs.write(path, file_contents)
+          end
+
+          private
+
+          # @since 2.2.0
+          # @api private
+          attr_reader(
+            :fs,
+            :inflector,
+            :key,
+            :namespace,
+            :base_path,
+            :extra_namespace,
+            :relative_parent_class,
+            :body,
+          )
+
+          # @since 2.2.0
+          # @api private
+          def file_contents
+            class_definition(
+              class_name: class_name,
+              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 local_namespaces
+            Array(extra_namespace) + key.split(KEY_SEPARATOR)[..-2]
+          end
+
+          # @since 2.2.0
+          # @api private
+          def directory
+            @directory ||= if local_namespaces.any?
+                             fs.join(base_path, local_namespaces)
+                           else
+                             base_path
+                           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:, local_namespaces:)
+            container_module = normalize(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
+        end
+      end
+    end
+  end
+end

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

@@ -2,8 +2,6 @@
 # frozen_string_literal: true
 
 module <%= camelized_slice_name %>
-  module Entities
+  class Operation < <%= camelized_app_name %>::Operation
   end
 end
-
-Dir[File.join(__dir__, "entities", "*.rb")].each(&method(:require))

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