hanami-cli 1.0.0.alpha1 → 2.0.0.alpha6

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../application"
+require_relative "structure/dump"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          class Seed < Application
+            FILE_PATH = "db/seeds.rb"
+
+            desc "Load seed data"
+
+            def call(**)
+              if has_file?
+                measure "seed data loaded from #{FILE_PATH}" do
+                  load full_file_path
+                end
+              else
+                out.puts "=> #{FILE_PATH} not found"
+              end
+            end
+
+            private
+
+            def full_file_path
+              File.join(application.root, FILE_PATH)
+            end
+
+            def has_file?
+              File.exist?(full_file_path)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../../application"
+require_relative "create"
+require_relative "migrate"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          class Setup < Application
+            desc "Setup database"
+
+            def call(**)
+              run_command Create
+              run_command Migrate
+            end
+          end
+        end
+      end
+    end
+  end
+end

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, **) # rubocop:disable Lint/UnusedMethodArgument
+              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/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/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/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/commands/monolith.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        require_relative "monolith/version"
+        # require_relative "monolith/install"
+        # require_relative "monolith/generate"
+        require_relative "monolith/install"
+        require_relative "monolith/generate"
+        require_relative "monolith/console"
+        require_relative "monolith/db/create"
+        require_relative "monolith/db/create_migration"
+        require_relative "monolith/db/drop"
+        require_relative "monolith/db/migrate"
+        require_relative "monolith/db/setup"
+        require_relative "monolith/db/reset"
+        require_relative "monolith/db/rollback"
+        require_relative "monolith/db/sample_data"
+        require_relative "monolith/db/seed"
+        require_relative "monolith/db/structure/dump"
+        require_relative "monolith/db/version"
+
+        def self.extended(base)
+          base.module_eval do
+            register "version", Version, aliases: ["v", "-v", "--version"]
+            # FIXME: temporary disabled for Hanami v2.0.0.alpha2
+            # register "install", Install
+
+            # FIXME: temporary disabled for Hanami v2.0.0.alpha2
+            # register "generate", aliases: ["g"] do |prefix|
+            #   prefix.register "slice", Generate::Slice
+            #   prefix.register "action", Generate::Action
+            # end
+
+            register "console", Commands::Monolith::Console
+
+            register "db create", Commands::Monolith::DB::Create
+            register "db create_migration", Commands::Monolith::DB::CreateMigration
+            register "db drop", Commands::Monolith::DB::Drop
+            register "db migrate", Commands::Monolith::DB::Migrate
+            register "db setup", Commands::Monolith::DB::Setup
+            register "db reset", Commands::Monolith::DB::Reset
+            register "db rollback", Commands::Monolith::DB::Rollback
+            register "db sample_data", Commands::Monolith::DB::SampleData
+            register "db seed", Commands::Monolith::DB::Seed
+            register "db structure dump", Commands::Monolith::DB::Structure::Dump
+            register "db version", Commands::Monolith::DB::Version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hanami
+  # TODO: move elsewhere
+  def self.architecture
+    return :monolith if File.exist?("config/application.rb")
+  end
+
+  module CLI
+    module Commands
+    end
+
+    def self.register_commands!(architecture = Hanami.architecture)
+      commands = case architecture
+                 when :monolith
+                   require_relative "commands/monolith"
+                   Commands::Monolith
+                 else
+                   require_relative "commands/gem"
+                   Commands::Gem
+                 end
+
+      extend(commands)
+    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/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))

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

@@ -0,0 +1,13 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "dry/transformer"
+
+module <%= classified_app_name %>
+  module Functions
+    extend Dry::Transformer::Registry
+
+    import Dry::Transformer::ArrayTransformations
+    import Dry::Transformer::HashTransformations
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "rake"
+
+gem "hanami-router", "<%= hanami_version %>"
+gem "hanami-controller", "<%= hanami_version %>"
+gem "hanami-validations", "<%= hanami_version %>"
+gem "hanami-view", git: "https://github.com/hanami/view.git", branch: "master"
+gem "dry-cli", "~> 0.6", require: false, git: "https://github.com/dry-rb/dry-cli.git", branch: "feature/file-utils-class"
+gem "hanami-cli", git: "https://github.com/hanami/cli.git", branch: "main"
+gem "hanami", require: false, git: "https://github.com/hanami/hanami.git", branch: "feature/hanami-2-cli"
+
+gem "puma"
+
+group :cli, :development, :test do
+  gem "hanami-rspec", git: "https://github.com/hanami/rspec.git", branch: "main"
+end

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

@@ -0,0 +1,18 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "dry/monads"
+require "dry/matcher/result_matcher"
+
+module <%= classified_app_name %>
+  class Operation
+    include Dry::Monads[:result, :try]
+
+    class << self
+      def inherited(klass)
+        klass.include Dry::Monads[:do]
+        klass.include Dry::Matcher::ResultMatcher.for(:call)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "hanami/application/rake_tasks"

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

@@ -0,0 +1 @@
+# <%= classified_app_name %>

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

@@ -0,0 +1,13 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "rom-repository"
+require_relative "entities"
+
+module <%= classified_app_name %>
+  class Repository < ROM::Repository::Root
+    include Deps[container: "persistence.rom"]
+
+    struct_namespace Entities
+  end
+end

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+Hanami.application.routes do
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "<%= underscored_app_name %>/types"
+
+Hanami.application.settings do
+end

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

@@ -0,0 +1,10 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "dry/types"
+
+module <%= classified_app_name %>
+  module Types
+    include Dry.Types
+  end
+end

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

@@ -0,0 +1,14 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "dry/validation"
+require "dry/schema/messages/i18n"
+
+module <%= classified_app_name %>
+  module Validation
+    class Contract < Dry::Validation::Contract
+      config.messages.backend = :i18n
+      config.messages.top_namespace = "validation"
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "hanami/view/context"
+
+module <%= classified_app_name %>
+  module View
+    class Context < Hanami::View::Context
+      def initialize(**args)
+        defaults = {content: {}}
+
+        super(**defaults.merge(args))
+      end
+    end
+  end
+end