hanami-cli 2.0.0.alpha7 → 2.0.0.beta1

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

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "hanami/operation"
+
+module <%= classified_app_name %>
+  class Operation < Hanami::Operation
+  end
+end

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

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

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

@@ -0,0 +1,7 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= classified_app_name %>
+  class Relation < Hanami::Relation
+  end
+end

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

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "hanami/repository"
+
+module <%= classified_app_name %>
+  class Repository < Hanami::Repository
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "hanami/routes"
+
+module <%= classified_app_name %>
+  class Routes < Hanami::Routes
+    define do
+      root { "Hello from Hanami" }
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "<%= underscored_app_name %>/types"
+require "hanami/settings"
+
+module <%= classified_app_name %>
+  class Settings < Hanami::Settings
+  end
+end

data/lib/hanami/cli/generators/gem/{application/monolith/functions.erb → app/transformations.erb}

@@ -4,7 +4,7 @@
 require "dry/transformer"
 
 module <%= classified_app_name %>
-  module Functions
+  module Transformations
     extend Dry::Transformer::Registry
 
     import Dry::Transformer::ArrayTransformations

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

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

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

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "hanami/view"
+
+module <%= classified_app_name %>
+  class View < Hanami::View
+  end
+end

data/lib/hanami/cli/generators/gem/{application/monolith → app}/view_context.erb

@@ -3,13 +3,8 @@
 require "hanami/view/context"
 
 module <%= classified_app_name %>
-  module View
+  module Views
     class Context < Hanami::View::Context
-      def initialize(**args)
-        defaults = {content: {}}
-
-        super(**defaults.merge(args))
-      end
     end
   end
 end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "hanami/view/part"
+
+module <%= classified_app_name %>
+  module Views
+    class Part < Hanami::View::Part
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "erb"
+require "shellwords"
+require "hanami/cli/generators/context"
+
+module Hanami
+  module CLI
+    module Generators
+      module Gem
+        class App
+          def initialize(fs:, inflector:, command_line:)
+            super()
+            @fs = fs
+            @inflector = inflector
+            @command_line = command_line
+          end
+
+          def call(app, context: Context.new(inflector, app), &blk)
+            generate_app(app, context)
+            blk.call
+          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/app.rb", t("app.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}/types.rb", t("types.erb", context))
+
+            fs.write("app/actions/.keep", t("keep.erb", context))
+            fs.write("app/action.rb", t("action.erb", context))
+          end
+
+          def template(path, context)
+            require "erb"
+
+            ERB.new(
+              File.read(File.join(__dir__, "app", path))
+            ).result(context.ctx)
+          end
+
+          alias_method :t, :template
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Generators
+      module Version
+        # @since 2.0.0
+        # @api private
+        def self.version
+          return Hanami::VERSION if defined?(Hanami::VERSION)
+
+          Hanami::CLI::VERSION
+        end
+
+        # @since 2.0.0
+        # @api private
+        def self.gem_requirement
+          result = if prerelease?
+                     prerelease_version
+                   else
+                     stable_version
+                   end
+
+          "~> #{result}"
+        end
+
+        # @since 2.0.0
+        # @api private
+        def self.prerelease?
+          version =~ /alpha|beta|rc/
+        end
+
+        # @since 2.0.0
+        # @api private
+        #
+        # @example
+        #   Hanami::VERSION # => 2.0.0
+        #   Hanami::CLI::Generators::Version.stable_version # => "2.0"
+        def self.stable_version
+          version.scan(/\A\d{1,2}\.\d{1,2}/).first
+        end
+
+        # @since 2.0.0
+        # @api private
+        #
+        # @example
+        #   Hanami::VERSION # => 2.0.0.alpha8.1
+        #   Hanami::CLI::Generators::Version.stable_version # => "2.0.0.alpha"
+        def self.prerelease_version
+          version.sub(/[[[:digit:]].]*\Z/, "")
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/rake_tasks.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "rake"
+require "hanami/cli/bundler"
+
+module Hanami
+  module CLI
+    # Install Rake tasks in an app
+    #
+    # @since 2.0.0
+    class RakeTasks
+      include Rake::DSL
+
+      # @since 2.0.0
+      # @api private
+      @tasks = []
+
+      # @since 2.0.0
+      # @api private
+      @_mutex = Mutex.new
+
+      # @since 2.0.0
+      # @api private
+      def self.register_tasks(&blk)
+        @_mutex.synchronize do
+          @tasks << blk
+          @tasks.uniq!
+        end
+      end
+
+      # @since 2.0.0
+      # @api private
+      def self.tasks
+        @_mutex.synchronize do
+          @tasks
+        end
+      end
+
+      # @since 0.6.0
+      # @api private
+      def self.install_tasks
+        new.call(tasks)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def call(tasks)
+        tasks.each(&:call)
+      end
+    end
+  end
+end
+
+Hanami::CLI::Bundler.require(:cli)

data/lib/hanami/cli/repl/core.rb

@@ -8,14 +8,14 @@ module Hanami
       # @api private
       class Core
         # @api private
-        attr_reader :application
+        attr_reader :app
 
         # @api private
         attr_reader :opts
 
         # @api private
-        def initialize(application, opts)
-          @application = application
+        def initialize(app, opts)
+          @app = app
           @opts = opts
         end
 
@@ -26,7 +26,7 @@ module Hanami
 
         # @api private
         def context
-          @context ||= Hanami::Console::Context.new(application)
+          @context ||= Hanami::Console::Context.new(app)
         end
 
         # @api private
@@ -36,18 +36,18 @@ module Hanami
 
         # @api private
         def name
-          (application.container.config.name || inflector.underscore(application.name))
+          (app.container.config.name || inflector.underscore(app.name))
             .to_s.split("/")[0]
         end
 
         # @api private
         def env
-          application.container.env
+          app.container.env
         end
 
         # @api private
         def inflector
-          application.inflector
+          app.inflector
         end
       end
     end

data/lib/hanami/cli/server.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    # @api private
+    class Server
+      attr_reader :rack_server
+
+      RACK_FALLBACK_OPTIONS = {
+        host: :Host,
+        port: :Port
+      }.freeze
+
+      OVERRIDING_OPTIONS = {
+        config: :config,
+        debug: :debug,
+        warn: :warn
+      }.freeze
+
+      def initialize(rack_server: Rack::Server)
+        @rack_server = rack_server
+      end
+
+      def call(**options)
+        rack_server.start(Hash[
+          extract_rack_fallback_options(options) + extract_overriding_options(options)
+        ])
+      end
+
+      private
+
+      def extract_rack_fallback_options(options)
+        RACK_FALLBACK_OPTIONS.filter_map do |(name, rack_name)|
+          options[name] && [rack_name, options[name]]
+        end
+      end
+
+      def extract_overriding_options(options)
+        OVERRIDING_OPTIONS.map do |(name, rack_name)|
+          [rack_name, options[name]]
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/version.rb

@@ -2,6 +2,6 @@
 
 module Hanami
   module CLI
-    VERSION = "2.0.0.alpha7"
+    VERSION = "2.0.0.beta1"
   end
 end

data/lib/hanami/console/context.rb

@@ -4,48 +4,48 @@ require_relative "plugins/slice_readers"
 
 module Hanami
   module Console
-    # Hanami application console context
+    # Hanami app console context
     #
     # @api private
     # @since 2.0.0
     class Context < Module
       # @api private
-      attr_reader :application
+      attr_reader :app
 
       # @api private
-      def initialize(application)
+      def initialize(app)
         super()
-        @application = application
+        @app = app
 
         define_context_methods
-        include Plugins::SliceReaders.new(application)
+        include Plugins::SliceReaders.new(app)
       end
 
       private
 
       def define_context_methods
-        app = application
+        hanami_app = app
 
         define_method(:inspect) do
-          "#<#{self.class} application=#{app} env=#{app.config.env}>"
+          "#<#{self.class} app=#{hanami_app} env=#{hanami_app.config.env}>"
         end
 
         define_method(:app) do
-          app
+          hanami_app
         end
 
-        define_method(:application) do
-          app
+        define_method(:app) do
+          hanami_app
         end
 
         define_method(:method_missing) do |name, *args, &block|
-          return app.public_send(name, *args, &block) if app.respond_to?(name)
+          return hanami_app.public_send(name, *args, &block) if hanami_app.respond_to?(name)
 
           super(name, *args, &block)
         end
 
         define_method(:respond_to_missing?) do |name, include_private|
-          super(name, include_private) || app.respond_to?(name, include_private)
+          super(name, include_private) || hanami_app.respond_to?(name, include_private)
         end
       end
     end

data/lib/hanami/console/plugins/slice_readers.rb

@@ -9,11 +9,11 @@ module Hanami
       # @since 2.0.0
       class SliceReaders < Module
         # @api private
-        def initialize(application)
+        def initialize(app)
           super()
 
-          application.slices.each do |slice|
-            define_method(slice.slice_name) do
+          app.slices.each do |slice|
+            define_method(slice.slice_name.to_sym) do
               slice
             end
           end

data/project.yml

@@ -0,0 +1,2 @@
+name: hanami-cli
+custom_ci: false