hanami-cli 2.1.1 → 2.2.0.beta2

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,40 @@
+# 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(key:, namespace:, base_path:)
+            RubyFileWriter.new(
+              fs: fs,
+              inflector: inflector,
+            ).call(
+              key: key,
+              namespace: namespace,
+              base_path: base_path,
+              extra_namespace: "Structs",
+              relative_parent_class: "DB::Struct",
+            )
+          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

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

@@ -80,6 +80,44 @@ module Hanami
           !options.fetch(:skip_assets, false)
         end
 
+        # @since 2.2.0
+        # @api private
+        def generate_db?
+          !options.fetch(:skip_db, false)
+        end
+
+        # @since 2.2.0
+        # @api private
+        def generate_sqlite?
+          generate_db? && database_option == Commands::Gem::New::DATABASE_SQLITE
+        end
+
+        # @since 2.2.0
+        # @api private
+        def generate_postgres?
+          generate_db? && database_option == Commands::Gem::New::DATABASE_POSTGRES
+        end
+
+        # @since 2.2.0
+        # @api private
+        def generate_mysql?
+          generate_db? && database_option == Commands::Gem::New::DATABASE_MYSQL
+        end
+
+        # @since 2.2.0
+        # @api private
+        def database_url
+          if generate_sqlite?
+            "sqlite://db/#{app}.sqlite"
+          elsif generate_postgres?
+            "postgres://localhost/#{app}"
+          elsif generate_mysql?
+            "mysql2://localhost/#{app}"
+          else
+            raise "Unknown database option: #{database_option}"
+          end
+        end
+
         # @since 2.1.0
         # @api private
         def bundled_views?
@@ -92,6 +130,12 @@ module Hanami
           Hanami.bundled?("hanami-assets")
         end
 
+        # @since 2.2.0
+        # @api private
+        def bundled_dry_monads?
+          Hanami.bundled?("dry-monads")
+        end
+
         # @since 2.1.0
         # @api private
         #
@@ -102,6 +146,10 @@ module Hanami
 
         private
 
+        def database_option
+          options.fetch(:database, Commands::Gem::New::DATABASE_SQLITE)
+        end
+
         # @since 2.0.0
         # @api private
         attr_reader :inflector

data/lib/hanami/cli/generators/gem/app/action.erb

@@ -2,8 +2,11 @@
 # frozen_string_literal: true
 
 require "hanami/action"
+require "dry/monads"
 
 module <%= camelized_app_name %>
   class Action < Hanami::Action
+    # Provide `Success` and `Failure` for pattern matching on operation results
+    include Dry::Monads[:result]
   end
 end

data/lib/hanami/cli/generators/gem/app/env.erb

@@ -0,0 +1,4 @@
+# This is checked into source control, so put sensitive values into `.env.local`
+<%- if generate_db? -%>
+DATABASE_URL=<%= database_url %>
+<%- end -%>

data/lib/hanami/cli/generators/gem/app/gemfile.erb

@@ -7,13 +7,24 @@ source "https://rubygems.org"
 <%= hanami_gem("assets") %>
 <%- end -%>
 <%= hanami_gem("controller") %>
+<%- if generate_db? -%>
+<%= hanami_gem("db") %>
+<%- end -%>
 <%= hanami_gem("router") %>
 <%= hanami_gem("validations") %>
 <%= hanami_gem("view") %>
 
 gem "dry-types", "~> 1.0", ">= 1.6.1"
+gem "dry-operation", github: "dry-rb/dry-operation"
 gem "puma"
 gem "rake"
+<%- if generate_sqlite? -%>
+gem "sqlite3"
+<%- elsif generate_postgres? -%>
+gem "pg"
+<%- elsif generate_mysql? -%>
+gem "mysql2"
+<%- end -%>
 
 group :development do
   <%= hanami_gem("webconsole") %>

data/lib/hanami/cli/generators/gem/app/gitignore.erb

@@ -1,6 +1,9 @@
-.env
+.env*.local
 log/*
 <%- if generate_assets? -%>
 public/
 node_modules/
 <%- end -%>
+<%- if generate_sqlite? -%>
+db/*.sqlite
+<%- end -%>

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

@@ -0,0 +1,13 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "dry/operation"
+
+module <%= camelized_app_name %>
+  class Operation < Dry::Operation
+    <%- if generate_db? -%>
+    # Provide `transaction do ... end` method for database transactions
+    include Dry::Operation::Extensions::ROM
+    <%- end -%>
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "hanami/db/relation"
+
+module <%= camelized_app_name %>
+  module DB
+    class Relation < Hanami::DB::Relation
+    end
+  end
+end

data/lib/hanami/cli/generators/gem/app/repo.erb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "hanami/db/repo"
+
+module <%= camelized_app_name %>
+  module DB
+    class Repo < Hanami::DB::Repo
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "hanami/db/struct"
+
+module <%= camelized_app_name %>
+  module DB
+    class Struct < Hanami::DB::Struct
+    end
+  end
+end

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

@@ -68,6 +68,25 @@ module Hanami
               fs.write("app/assets/images/favicon.ico", file("favicon.ico"))
             end
 
+            if context.generate_db?
+              fs.write("app/db/relation.rb", t("relation.erb", context))
+              fs.write("app/relations/.keep", t("keep.erb", context))
+
+              fs.write("app/db/repo.rb", t("repo.erb", context))
+              fs.write("app/repos/.keep", t("keep.erb", context))
+
+              fs.write("app/db/struct.rb", t("struct.erb", context))
+              fs.write("app/structs/.keep", t("keep.erb", context))
+
+              fs.write("config/db/migrate/.keep" , t("keep.erb", context))
+
+              if context.generate_sqlite?
+                fs.write("db/.keep" , t("keep.erb", context))
+              end
+            end
+
+            fs.write("app/operation.rb", t("operation.erb", context))
+
             fs.write("public/404.html", file("404.html"))
             fs.write("public/500.html", file("500.html"))
           end

data/lib/hanami/cli/ruby_file_generator.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module Hanami
+  module CLI
+    class RubyFileGenerator
+      # @api private
+      # @since 2.2.0
+      class GeneratedUnparseableCodeError < Error
+        def initialize(source_code)
+          super(
+            <<~ERROR_MESSAGE
+              Sorry, the code we generated is not valid Ruby.
+
+              Here's what we got:
+
+              #{source_code}
+
+              Please fix the errors and try again.
+            ERROR_MESSAGE
+          )
+        end
+      end
+
+      INDENT = "  "
+
+      def self.class(class_name, **args)
+        new(class_name: class_name, **args).to_s
+      end
+
+      def self.module(*names, **args)
+        module_names = if names.first.is_a?(Array)
+                         names.first
+                       else
+                         names
+                       end
+
+        new(modules: module_names, class_name: nil, parent_class: nil, **args).to_s
+      end
+
+      def initialize(
+        class_name: nil,
+        parent_class: nil,
+        modules: [],
+        header: [],
+        body: []
+      )
+        @class_name = class_name
+        @parent_class = parent_class
+        @modules = modules
+        @header = header.any? ? (header + [""]) : []
+        @body = body
+      end
+
+      def to_s
+        definition = lines(modules).map { |line| "#{line}\n" }.join
+        source_code = [header, definition].flatten.join("\n")
+        ensure_parseable!(source_code)
+        source_code
+      end
+
+      private
+
+      attr_reader(
+        :class_name,
+        :parent_class,
+        :modules,
+        :header,
+        :body
+      )
+
+      def lines(remaining_modules)
+        this_module, *rest_modules = remaining_modules
+        if this_module
+          with_module_lines(this_module, lines(rest_modules))
+        elsif class_name
+          class_lines
+        else
+          body
+        end
+      end
+
+      def with_module_lines(module_name, contents_lines)
+        [
+          "module #{module_name}",
+          *contents_lines.map { |line| indent(line) },
+          "end"
+        ]
+      end
+
+      def class_lines
+        [
+          class_definition,
+          *body.map { |line| indent(line) },
+          "end"
+        ].compact
+      end
+
+      def class_definition
+        if parent_class
+          "class #{class_name} < #{parent_class}"
+        else
+          "class #{class_name}"
+        end
+      end
+
+      def indent(line)
+        if line.strip.empty?
+          ""
+        else
+          INDENT + line
+        end
+      end
+
+      def ensure_parseable!(source_code)
+        unless Ripper.sexp(source_code)
+          raise GeneratedUnparseableCodeError.new(source_code)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/version.rb

@@ -6,6 +6,6 @@ module Hanami
     #
     # @api public
     # @since 2.0.0
-    VERSION = "2.1.1"
+    VERSION = "2.2.0.beta2"
   end
 end