hanami-cli 1.0.0.alpha1 → 2.0.0.alpha2

data/lib/hanami/cli/commands/monolith/db/structure/dump.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../../../application"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          module Structure
+            class Dump < Application
+              desc "Dumps database structure to db/structure.sql file"
+
+              def call(*)
+                measure("#{database.name} structure dumped to db/structure.sql") do
+                  database.dump_command
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/monolith/db/version.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../../application"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          class Version < Application
+            desc "Print schema version"
+
+            option :target, desc: "Target migration number", aliases: ["-t"]
+
+            def call(target: nil, **)
+              migration = database.applied_migrations.last
+              version = migration ? File.basename(migration, ".*") : "not available"
+
+              out.puts "=> current schema version is #{version}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/monolith/generate.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module Generate
+          require_relative "./generate/slice"
+          require_relative "./generate/action"
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/monolith/generate/action.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "hanami/cli/command"
+require "hanami/cli/generators/monolith/action"
+require "dry/inflector"
+require "dry/files"
+require "shellwords"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module Generate
+          class Action < Command
+            # TODO: ideally the default format should lookup
+            #       slice configuration (Action's `default_response_format`)
+            DEFAULT_FORMAT = "html"
+            private_constant :DEFAULT_FORMAT
+
+            DEFAULT_SKIP_VIEW = false
+            private_constant :DEFAULT_SKIP_VIEW
+
+            argument :slice, required: true, desc: "Slice name"
+            argument :name, required: true, desc: "Action name"
+            option :url, required: false, type: :string, desc: "Action URL"
+            option :http, required: false, type: :string, desc: "Action HTTP method"
+            option :format, required: false, type: :string, default: DEFAULT_FORMAT, desc: "Template format"
+            option :skip_view, required: false, type: :boolean, default: DEFAULT_SKIP_VIEW,
+                               desc: "Skip view and template generation"
+
+            def initialize(fs: Dry::Files.new, inflector: Dry::Inflector.new,
+                           generator: Generators::Monolith::Action.new(fs: fs, inflector: inflector), **)
+              @generator = generator
+              super(fs: fs)
+            end
+
+            # rubocop:disable Metrics/ParameterLists
+            def call(slice:, name:, url: nil, http: nil, format: DEFAULT_FORMAT, skip_view: DEFAULT_SKIP_VIEW, **)
+              slice = inflector.underscore(Shellwords.shellescape(slice))
+              name = inflector.underscore(Shellwords.shellescape(name))
+              *controller, action = name.split(ACTION_SEPARATOR)
+
+              if controller.empty?
+                raise ArgumentError.new("cannot parse controller and action name: `#{name}'\n\texample: users.show")
+              end
+
+              generator.call(slice, controller, action, url, http, format, skip_view)
+            end
+            # rubocop:enable Metrics/ParameterLists
+
+            private
+
+            ACTION_SEPARATOR = "."
+            private_constant :ACTION_SEPARATOR
+
+            attr_reader :generator
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "hanami/cli/command"
+require "hanami/cli/generators/monolith/slice"
+require "dry/inflector"
+require "dry/files"
+require "shellwords"
+require "hanami/cli/url"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module Generate
+          class Slice < Command
+            argument :name, required: true, desc: "The slice name"
+            option :url_prefix, required: false, type: :string, desc: "The slice URL prefix"
+
+            def initialize(fs: Dry::Files.new, inflector: Dry::Inflector.new,
+                           generator: Generators::Monolith::Slice.new(fs: fs, inflector: inflector), **)
+              @generator = generator
+              super(fs: fs)
+            end
+
+            def call(name:, url_prefix: nil, **)
+              require "hanami/setup"
+
+              app = inflector.underscore(Hanami.application.namespace)
+              name = inflector.underscore(Shellwords.shellescape(name))
+              url_prefix = sanitize_url_prefix(name, url_prefix)
+
+              generator.call(app, name, url_prefix)
+            end
+
+            private
+
+            DEFAULT_URL_PREFIX = "/"
+            private_constant :DEFAULT_URL_PREFIX
+
+            attr_reader :generator
+
+            def sanitize_url_prefix(name, url_prefix)
+              result = url_prefix
+              result = inflector.underscore(Shellwords.shellescape(result)) unless result.nil?
+
+              result ||= DEFAULT_URL_PREFIX + name
+              CLI::URL.call(result)
+            rescue ArgumentError
+              raise ArgumentError.new("invalid URL prefix: `#{url_prefix}'")
+            end
+
+            def valid_url?(url)
+              return false if url.nil?
+
+              url.start_with?(DEFAULT_URL_PREFIX)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "hanami/cli/command"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        class Install < Command
+          def call(*)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/monolith/version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "hanami/cli/command"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        class Version < Command
+          def call(*)
+            require "hanami/version"
+            out.puts "v#{Hanami::VERSION}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    class Error < StandardError
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "hanami/version"
+
+module Hanami
+  module CLI
+    module Generators
+      class Context
+        def initialize(inflector, app)
+          @inflector = inflector
+          @app = app
+        end
+
+        def ctx
+          binding
+        end
+
+        def hanami_version
+          Hanami::Version.gem_requirement
+        end
+
+        def classified_app_name
+          inflector.classify(app)
+        end
+
+        def underscored_app_name
+          inflector.underscore(app)
+        end
+
+        private
+
+        attr_reader :inflector
+
+        attr_reader :app
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Generators
+      module Gem
+        module Application
+          class << self
+            def call(architecture, fs, inflector, command_line)
+              require_relative "./application/#{architecture}"
+
+              generator_name = inflector.classify(architecture).to_sym
+              const_get(generator_name).new(fs: fs, inflector: inflector, command_line: command_line)
+            end
+            alias_method :[], :call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/gem/application/monolith.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "erb"
+require "shellwords"
+require "hanami/cli/generators/context"
+
+module Hanami
+  module CLI
+    module Generators
+      module Gem
+        module Application
+          class Monolith
+            def initialize(fs:, inflector:, command_line:)
+              super()
+              @fs = fs
+              @inflector = inflector
+              @command_line = command_line
+            end
+
+            def call(app, slice, slice_url_prefix, context: Context.new(inflector, app), &blk)
+              generate_app(app, context)
+              blk.call
+              generate_slice!(slice, slice_url_prefix)
+            end
+
+            private
+
+            attr_reader :fs
+
+            attr_reader :inflector
+
+            attr_reader :command_line
+
+            def generate_app(app, context) # rubocop:disable Metrics/AbcSize
+              fs.write(".env", t("env.erb", context))
+
+              fs.write("README.md", t("readme.erb", context))
+              fs.write("Gemfile", t("gemfile.erb", context))
+              fs.write("Rakefile", t("rakefile.erb", context))
+              fs.write("config.ru", t("config_ru.erb", context))
+
+              fs.write("config/application.rb", t("application.erb", context))
+              fs.write("config/settings.rb", t("settings.erb", context))
+              fs.write("config/routes.rb", t("routes.erb", context))
+
+              fs.write("lib/tasks/.keep", t("keep.erb", context))
+
+              fs.write("lib/#{app}/entities/.keep", t("keep.erb", context))
+              fs.write("lib/#{app}/persistence/relations/.keep", t("keep.erb", context))
+              fs.write("lib/#{app}/validation/contract.rb", t("validation_contract.erb", context))
+              fs.write("lib/#{app}/view/context.rb", t("view_context.erb", context))
+              fs.write("lib/#{app}/action.rb", t("action.erb", context))
+              fs.write("lib/#{app}/entities.rb", t("entities.erb", context))
+              fs.write("lib/#{app}/functions.rb", t("functions.erb", context))
+              fs.write("lib/#{app}/operation.rb", t("operation.erb", context))
+              fs.write("lib/#{app}/repository.rb", t("repository.erb", context))
+              fs.write("lib/#{app}/types.rb", t("types.erb", context))
+            end
+
+            def generate_slice!(slice_name, slice_url_prefix)
+              slice_name = Shellwords.shellescape(slice_name)
+              slice_url_prefix = Shellwords.shellescape(slice_url_prefix)
+
+              command_line.call("hanami generate slice #{slice_name} --url-prefix=#{slice_url_prefix}").tap do |result|
+                raise "hanami generate slice #{slice_name} failed\n\n\n#{result.err.inspect}" unless result.successful?
+              end
+            end
+
+            def template(path, context)
+              require "erb"
+
+              ERB.new(
+                File.read(__dir__ + "/monolith/#{path}")
+              ).result(context.ctx)
+            end
+
+            alias_method :t, :template
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/gem/application/monolith/action.erb

@@ -0,0 +1,21 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "json" # required for Hanami::Action::Flash to work
+require "hanami/action"
+require "hanami/action/cookies"
+require "hanami/action/csrf_protection"
+require "hanami/action/session"
+
+module <%= classified_app_name %>
+  class Action < Hanami::Action
+    def self.inherited(klass)
+      super
+
+      # These will need to be sorted by the framework eventually
+      klass.include Hanami::Action::Cookies
+      klass.include Hanami::Action::Session
+      klass.include Hanami::Action::CSRFProtection
+    end
+  end
+end

data/lib/hanami/cli/generators/gem/application/monolith/application.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "hanami"
+
+module <%= classified_app_name %>
+  class Application < Hanami::Application
+  end
+end

data/lib/hanami/cli/generators/gem/application/monolith/config_ru.erb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "hanami/boot"
+
+run Hanami.app

data/lib/hanami/cli/generators/gem/application/monolith/entities.erb

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= classified_app_name %>
+  module Entities
+  end
+end
+
+Dir[File.join(__dir__, "entities", "*.rb")].each(&method(:require))