hanami-cli 1.0.0.alpha1 → 2.0.0.alpha6

data/hanami-cli.gemspec

@@ -1,36 +1,41 @@
 # frozen_string_literal: true
 
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "hanami/cli/version"
+require_relative "lib/hanami/cli/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "hanami-cli"
   spec.version       = Hanami::CLI::VERSION
   spec.authors       = ["Luca Guidi"]
   spec.email         = ["me@lucaguidi.com"]
-  spec.licenses      = ["MIT"]
 
   spec.summary       = "Hanami CLI"
-  spec.description   = "Hanami framework to build command line interfaces with Ruby"
-  spec.homepage      = "http://hanamirb.org"
+  spec.description   = "Hanami command line"
+  spec.homepage      = "https://hanamirb.org"
+  spec.license       = "MIT"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/hanami/cli"
+  spec.metadata["changelog_uri"] = "https://github.com/hanami/cli/blob/master/CHANGELOG.md"
 
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
   spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.5.0"
-
-  spec.files = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
+  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.required_ruby_version = ">= 3.0"
 
-  spec.add_dependency "hanami-utils",    "~> 2.0.alpha"
-  spec.add_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_dependency "bundler", "~> 2.1"
+  spec.add_dependency "rake", "~> 13.0"
+  spec.add_dependency "dry-cli", "~> 0.6"
+  spec.add_dependency "dry-files", "~> 0.1"
+  spec.add_dependency "dry-inflector", "~> 0.2"
 
-  spec.add_development_dependency "bundler", ">= 1.6", "< 3"
-  spec.add_development_dependency "rake",  "~> 12.0"
-  spec.add_development_dependency "rspec", "~> 3.7"
+  spec.add_development_dependency "rspec", "~> 3.9"
+  spec.add_development_dependency "rubocop", "~> 1.0"
 end

data/lib/hanami/cli/bundler.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "bundler"
+require "open3"
+require "etc"
+require "dry/files"
+require_relative "./system_call"
+
+module Hanami
+  module CLI
+    class Bundler
+      BUNDLE_GEMFILE = "BUNDLE_GEMFILE"
+      private_constant :BUNDLE_GEMFILE
+
+      DEFAULT_GEMFILE_PATH = "Gemfile"
+      private_constant :DEFAULT_GEMFILE_PATH
+
+      def self.require(*groups)
+        return unless File.exist?(ENV[BUNDLE_GEMFILE] || DEFAULT_GEMFILE_PATH)
+
+        ::Bundler.require(*groups)
+      end
+
+      def initialize(fs: Dry::Files.new, system_call: SystemCall.new)
+        @fs = fs
+        @system_call = system_call
+      end
+
+      def install
+        parallelism_level = Etc.nprocessors
+        bundle "install --jobs=#{parallelism_level} --quiet --no-color"
+      end
+
+      def install!
+        install.tap do |result|
+          raise "Bundle install failed\n\n\n#{result.err.inspect}" unless result.successful?
+        end
+      end
+
+      def exec(cmd, env: nil, &blk)
+        bundle("exec #{cmd}", env: env, &blk)
+      end
+
+      def bundle(cmd, env: nil, &blk)
+        bundle_bin = which("bundle")
+        hanami_env = "HANAMI_ENV=#{env} " unless env.nil?
+
+        system_call.call("#{hanami_env}#{bundle_bin} #{cmd}",
+                         env: {BUNDLE_GEMFILE => fs.expand_path(DEFAULT_GEMFILE_PATH)}, &blk)
+      end
+
+      private
+
+      attr_reader :fs
+
+      attr_reader :system_call
+
+      # Adapted from https://stackoverflow.com/a/5471032/498386
+      def which(cmd)
+        exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+
+        ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = fs.join(path, "#{cmd}#{ext}")
+            return exe if fs.executable?(exe) && !fs.directory?(exe)
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/hanami/cli/command.rb

@@ -1,398 +1,26 @@
 # frozen_string_literal: true
 
-require "forwardable"
-require "concurrent/array"
-require "hanami/cli/option"
-require "hanami/utils/class_attribute"
+require "dry/cli"
+require "dry/files"
+require "dry/inflector"
 
 module Hanami
-  class CLI
-    # Base class for commands
-    #
-    # @since 0.1.0
-    class Command
-      # @since 0.1.0
-      # @api private
-      def self.inherited(base)
-        super
-        base.extend ClassMethods
+  module CLI
+    class Command < Dry::CLI::Command
+      def initialize(out: $stdout, fs: Dry::Files.new, inflector: Dry::Inflector.new)
+        super()
+        @out = out
+        @fs = fs
+        @inflector = inflector
       end
 
-      # @since 0.1.0
-      # @api private
-      module ClassMethods
-        # @since 0.1.0
-        # @api private
-        #
-        # rubocop:disable Metrics/MethodLength
-        def self.extended(base)
-          super
-          return unless extend?(base)
+      private
 
-          base.class_eval do
-            include Utils::ClassAttribute
+      attr_reader :out
 
-            class_attribute :description
-            self.description = nil
+      attr_reader :fs
 
-            class_attribute :examples
-            self.examples = Concurrent::Array.new
-
-            class_attribute :arguments
-            self.arguments = Concurrent::Array.new
-
-            class_attribute :options
-            self.options = Concurrent::Array.new
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-
-        # Only add class attributes if a command is inheriting directly from `Hanami::CLI::Command`.
-        # In this way, its subclasses can inherit arguments/options from the parent class.
-        #
-        # @return [TrueClass,FalseClass] the result of the check
-        #
-        # @since 1.0.0
-        # @api private
-        #
-        # @example
-        #   # For this class `extend?` will return `true`
-        #   class Server < Hanami::CLI::Command
-        #     option :engine
-        #
-        #     def call(**options)
-        #       # start the server
-        #     end
-        #   end
-        #
-        #   # For this class `extend?` will return `false`
-        #   class ServerReloader < Server
-        #     option :reload, type: :boolean, default: true
-        #
-        #     def call(**options)
-        #       reload = options.fetch(:reload)
-        #       super unless reload
-        #
-        #       # activate reloading
-        #     end
-        #   end
-        def self.extend?(base)
-          base.superclass == Hanami::CLI::Command
-        end
-      end
-
-      # Set the description of the command
-      #
-      # @param description [String] the description
-      #
-      # @since 0.1.0
-      #
-      # @example
-      #   require "hanami/cli"
-      #
-      #   class Echo < Hanami::CLI::Command
-      #     desc "Prints given input"
-      #
-      #     def call(*)
-      #       # ...
-      #     end
-      #   end
-      def self.desc(description)
-        self.description = description
-      end
-
-      # Describe the usage of the command
-      #
-      # @param examples [Array<String>] one or more examples
-      #
-      # @since 0.1.0
-      #
-      # @example
-      #   require "hanami/cli"
-      #
-      #   class Server < Hanami::CLI::Command
-      #     example [
-      #       "                    # Basic usage (it uses the bundled server engine)",
-      #       "--server=webrick    # Force `webrick` server engine",
-      #       "--host=0.0.0.0      # Bind to a host",
-      #       "--port=2306         # Bind to a port",
-      #       "--no-code-reloading # Disable code reloading"
-      #     ]
-      #
-      #     def call(*)
-      #       # ...
-      #     end
-      #   end
-      #
-      #   # $ foo server --help
-      #   #   # ...
-      #   #
-      #   #   Examples:
-      #   #     foo server                     # Basic usage (it uses the bundled server engine)
-      #   #     foo server --server=webrick    # Force `webrick` server engine
-      #   #     foo server --host=0.0.0.0      # Bind to a host
-      #   #     foo server --port=2306         # Bind to a port
-      #   #     foo server --no-code-reloading # Disable code reloading
-      def self.example(*examples)
-        self.examples += examples.flatten
-      end
-
-      # Specify an argument
-      #
-      # @param name [Symbol] the argument name
-      # @param options [Hash] a set of options
-      #
-      # @since 0.1.0
-      #
-      # @example Optional argument
-      #   require "hanami/cli"
-      #
-      #   class Hello < Hanami::CLI::Command
-      #     argument :name
-      #
-      #     def call(name: nil, **)
-      #       if name.nil?
-      #         puts "Hello, stranger"
-      #       else
-      #         puts "Hello, #{name}"
-      #       end
-      #     end
-      #   end
-      #
-      #   # $ foo hello
-      #   #   Hello, stranger
-      #
-      #   # $ foo hello Luca
-      #   #   Hello, Luca
-      #
-      # @example Required argument
-      #   require "hanami/cli"
-      #
-      #   class Hello < Hanami::CLI::Command
-      #     argument :name, required: true
-      #
-      #     def call(name:, **)
-      #       puts "Hello, #{name}"
-      #     end
-      #   end
-      #
-      #   # $ foo hello Luca
-      #   #   Hello, Luca
-      #
-      #   # $ foo hello
-      #   #   ERROR: "foo hello" was called with no arguments
-      #   #   Usage: "foo hello NAME"
-      #
-      # @example Multiple arguments
-      #   require "hanami/cli"
-      #
-      #   module Generate
-      #     class Action < Hanami::CLI::Command
-      #       argument :app,    required: true
-      #       argument :action, required: true
-      #
-      #       def call(app:, action:, **)
-      #         puts "Generating action: #{action} for app: #{app}"
-      #       end
-      #     end
-      #   end
-      #
-      #   # $ foo generate action web home
-      #   #   Generating action: home for app: web
-      #
-      #   # $ foo generate action
-      #   #   ERROR: "foo generate action" was called with no arguments
-      #   #   Usage: "foo generate action APP ACTION"
-      #
-      # @example Description
-      #   require "hanami/cli"
-      #
-      #   class Hello < Hanami::CLI::Command
-      #     argument :name, desc: "The name of the person to greet"
-      #
-      #     def call(name: nil, **)
-      #       # ...
-      #     end
-      #   end
-      #
-      #   # $ foo hello --help
-      #   #   Command:
-      #   #     foo hello
-      #   #
-      #   #   Usage:
-      #   #     foo hello [NAME]
-      #   #
-      #   #   Arguments:
-      #   #     NAME                # The name of the person to greet
-      #   #
-      #   #   Options:
-      #   #     --help, -h          # Print this help
-      def self.argument(name, options = {})
-        arguments << Argument.new(name, options)
-      end
-
-      # Command line option (aka optional argument)
-      #
-      # @param name [Symbol] the param name
-      # @param options [Hash] a set of options
-      #
-      # @since 0.1.0
-      #
-      # @example Basic usage
-      #   require "hanami/cli"
-      #
-      #   class Console < Hanami::CLI::Command
-      #     param :engine
-      #
-      #     def call(engine: nil, **)
-      #       puts "starting console (engine: #{engine || :irb})"
-      #     end
-      #   end
-      #
-      #   # $ foo console
-      #   # starting console (engine: irb)
-      #
-      #   # $ foo console --engine=pry
-      #   # starting console (engine: pry)
-      #
-      # @example List values
-      #   require "hanami/cli"
-      #
-      #   class Console < Hanami::CLI::Command
-      #     param :engine, values: %w(irb pry ripl)
-      #
-      #     def call(engine: nil, **)
-      #       puts "starting console (engine: #{engine || :irb})"
-      #     end
-      #   end
-      #
-      #   # $ foo console
-      #   # starting console (engine: irb)
-      #
-      #   # $ foo console --engine=pry
-      #   # starting console (engine: pry)
-      #
-      #   # $ foo console --engine=foo
-      #   # Error: Invalid param provided
-      #
-      # @example Description
-      #   require "hanami/cli"
-      #
-      #   class Console < Hanami::CLI::Command
-      #     param :engine, desc: "Force a console engine"
-      #
-      #     def call(engine: nil, **)
-      #       # ...
-      #     end
-      #   end
-      #
-      #   # $ foo console --help
-      #   # # ...
-      #   #
-      #   # Options:
-      #   #   --engine=VALUE                  # Force a console engine: (irb/pry/ripl)
-      #   #   --help, -h                      # Print this help
-      #
-      # @example Boolean
-      #   require "hanami/cli"
-      #
-      #   class Server < Hanami::CLI::Command
-      #     param :code_reloading, type: :boolean, default: true
-      #
-      #     def call(code_reloading:, **)
-      #       puts "staring server (code reloading: #{code_reloading})"
-      #     end
-      #   end
-      #
-      #   # $ foo server
-      #   # starting server (code reloading: true)
-      #
-      #   # $ foo server --no-code-reloading
-      #   # starting server (code reloading: false)
-      #
-      #   # $ foo server --help
-      #   # # ...
-      #   #
-      #   # Options:
-      #   #   --[no]-code-reloading
-      #
-      # @example Aliases
-      #   require "hanami/cli"
-      #
-      #   class Server < Hanami::CLI::Command
-      #     param :port, aliases: ["-p"]
-      #
-      #     def call(options)
-      #       puts "staring server (port: #{options.fetch(:port, 2300)})"
-      #     end
-      #   end
-      #
-      #   # $ foo server
-      #   # starting server (port: 2300)
-      #
-      #   # $ foo server --port=2306
-      #   # starting server (port: 2306)
-      #
-      #   # $ foo server -p 2306
-      #   # starting server (port: 2306)
-      #
-      #   # $ foo server --help
-      #   # # ...
-      #   #
-      #   # Options:
-      #   #   --port=VALUE, -p VALUE
-      def self.option(name, options = {})
-        self.options << Option.new(name, options)
-      end
-
-      # @since 0.1.0
-      # @api private
-      def self.params
-        (arguments + options).uniq
-      end
-
-      # @since 0.1.0
-      # @api private
-      def self.default_params
-        params.each_with_object({}) do |param, result|
-          result[param.name] = param.default unless param.default.nil?
-        end
-      end
-
-      # @since 0.1.0
-      # @api private
-      def self.required_arguments
-        arguments.select(&:required?)
-      end
-
-      # @since 0.1.0
-      # @api private
-      def self.optional_arguments
-        arguments.reject(&:required?)
-      end
-
-      extend Forwardable
-
-      delegate %i[
-        description
-        examples
-        arguments
-        options
-        params
-        default_params
-        required_arguments
-        optional_arguments
-      ] => "self.class"
-
-      # @since 0.1.0
-      # @api private
-      attr_reader :command_name
-
-      # @since 0.1.0
-      # @api private
-      def initialize(command_name:, **)
-        @command_name = command_name
-      end
+      attr_reader :inflector
     end
   end
 end

data/lib/hanami/cli/command_line.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "./bundler"
+
+module Hanami
+  module CLI
+    class CommandLine
+      def initialize(bundler: CLI::Bundler.new)
+        @bundler = bundler
+      end
+
+      def call(command)
+        @bundler.exec(command)
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/application.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "dry/files"
+
+require_relative "db/utils/database"
+
+module Hanami
+  module CLI
+    module Commands
+      class Application < Hanami::CLI::Command
+        module Environment
+          def call(**opts)
+            env = opts[:env]
+            ENV["HANAMI_ENV"] = env.to_s
+            super(**opts)
+          end
+        end
+
+        def self.inherited(klass)
+          super
+          klass.option(:env, required: false, default: "development", desc: "Application's environment")
+          klass.prepend(Environment)
+        end
+
+        def application
+          @application ||=
+            begin
+              require "hanami/prepare"
+              Hanami.application
+            end
+        end
+
+        def run_command(klass, *args)
+          klass.new(
+            out: out,
+            inflector: application.inflector,
+            fs: Dry::Files
+          ).call(*args)
+        end
+
+        def measure(desc)
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result = yield
+          stop = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          if result
+            out.puts "=> #{desc} in #{(stop - start).round(4)}s"
+          else
+            out.puts "!!! => #{desc.inspect} FAILED"
+          end
+        end
+
+        def database
+          @database ||= Commands::DB::Utils::Database[application]
+        end
+
+        def database_config
+          database.config
+        end
+      end
+    end
+  end
+end