hanami 2.0.0.alpha1 → 2.0.0.alpha2

data/lib/hanami/application/settings/definition.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "hanami/utils/basic_object"
+
+module Hanami
+  class Application
+    module Settings
+      # Application settings definition DSL
+      #
+      # @since 2.0.0
+      # @api private
+      class Definition < Hanami::Utils::BasicObject
+        attr_reader :settings
+
+        def initialize(&block)
+          @settings = []
+          instance_eval(&block) if block
+        end
+
+        def setting(name, *args)
+          @settings << [name, args]
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application/settings/loader.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Application
+    module Settings
+      # Default application settings loader. Uses dotenv (if available) to load
+      # .env files and then loads settings from ENV.
+      #
+      # @since 2.0.0
+      # @api private
+      class Loader
+        InvalidSettingsError = Class.new(StandardError) do
+          def initialize(errors)
+            @errors = errors
+          end
+
+          def to_s
+            <<~STR.strip
+              Could not initialize settings. The following settings were invalid:
+
+              #{@errors.map { |setting, message| "#{setting}: #{message}" }.join("\n")}
+            STR
+          end
+        end
+
+        UnsupportedSettingArgumentError = Class.new(StandardError) do
+          def initialize(setting_name, arguments)
+            @setting_name = setting_name
+            @arguments = arguments
+          end
+
+          def to_s
+            <<~STR.strip
+              Unsupported arguments #{@arguments.inspect} for setting +#{@setting_name}+
+            STR
+          end
+        end
+
+        def initialize(*)
+        end
+
+        def call(defined_settings)
+          load_dotenv
+
+          settings, errors = load_settings(defined_settings)
+
+          raise InvalidSettingsError, errors if errors.any?
+
+          settings
+        end
+
+        private
+
+        def load_dotenv
+          require "dotenv"
+          Dotenv.load(*dotenv_files) if defined?(Dotenv)
+        rescue LoadError # rubocop:disable Lint/SuppressedException
+        end
+
+        def dotenv_files
+          [
+            ".env.#{Hanami.env}.local",
+            (".env.local" unless Hanami.env?(:test)),
+            ".env.#{Hanami.env}",
+            ".env"
+          ].compact
+        end
+
+        def load_settings(defined_settings) # rubocop:disable Metrics/MethodLength
+          defined_settings.each_with_object([{}, {}]) { |(name, args), (settings, errors)|
+            begin
+              settings[name] = resolve_setting(name, args)
+            rescue => exception # rubocop:disable Style/RescueStandardError
+              if exception.is_a?(UnsupportedSettingArgumentError) # rubocop: disable Style/GuardClause
+                raise exception
+              else
+                errors[name] = exception
+              end
+            end
+          }
+        end
+
+        def resolve_setting(name, args)
+          value = ENV.fetch(name.to_s.upcase) { Undefined }
+
+          if args.none?
+            value
+          elsif args[0]&.respond_to?(:call)
+            args[0].call(value)
+          else
+            raise UnsupportedSettingArgumentError.new(name, args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application/settings/struct.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Application
+    module Settings
+      # Application settings struct
+      #
+      # When the application loads settings, a struct subclass is created for
+      # the settings defined specifically for the application, then initialized
+      # with those settings and their values
+      #
+      # @since 2.0.0
+      # @api public
+      class Struct
+        class << self
+          def [](names)
+            Class.new(self) do
+              @setting_names = names
+
+              define_singleton_method(:setting_names) do
+                @setting_names
+              end
+
+              define_readers
+            end
+          end
+
+          def reserved?(name)
+            instance_methods.include?(name)
+          end
+
+          private
+
+          def define_readers
+            setting_names.each do |name|
+              next if reserved?(name)
+
+              define_method(name) do
+                @settings[name]
+              end
+            end
+          end
+        end
+
+        def initialize(settings)
+          @settings = settings.freeze
+        end
+
+        def [](name)
+          raise ArgumentError, "Unknown setting +#{name}+" unless self.class.setting_names.include?(name)
+
+          if self.class.reserved?(name)
+            @settings[name]
+          else
+            public_send(name)
+          end
+        end
+
+        def to_h
+          @settings.to_h
+        end
+      end
+    end
+  end
+end

data/lib/hanami/boot.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "hanami"
+require_relative "setup"
 
 Hanami.boot

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require_relative "commands"
+
+module Hanami
+  class CLI
+    module Application
+      # Hanami application CLI
+      class CLI < Hanami::CLI
+        attr_reader :application
+
+        def initialize(application: nil, commands: Commands)
+          super(commands)
+          @application = application
+        end
+
+        private
+
+        # TODO: we should make a prepare_command method upstream
+        def parse(result, out)
+          command, arguments = super
+
+          if command.respond_to?(:with_application)
+            # Set HANAMI_ENV before the application inits to ensure all aspects
+            # of the boot process respect the provided env
+            ENV["HANAMI_ENV"] = arguments[:env] if arguments[:env]
+
+            require "hanami/init"
+            application = Hanami.application
+
+            [command.with_application(application), arguments]
+          else
+            [command, arguments]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../base_command"
+
+module Hanami
+  class CLI
+    module Application
+      # Hanami application CLI command (intended to run inside application directory)
+      class Command < BaseCommand
+        def self.inherited(klass)
+          super
+
+          klass.option :env, aliases: ["-e"], default: nil, desc: "Application environment"
+        end
+
+        attr_reader :application
+
+        def initialize(application: nil, **opts)
+          super(**opts)
+          @application = application
+        end
+
+        def with_application(application)
+          self.class.new(
+            command_name: @command_name,
+            application: application,
+            out: out,
+            inflector: application.inflector,
+            files: files,
+          )
+        end
+
+        private
+
+        def run_command(klass, *args)
+          klass.new(
+            command_name: klass.name,
+            application: application,
+            out: out,
+            inflector: application.inflector,
+            files: files,
+          ).call(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "hanami/cli/registry"
+
+module Hanami
+  class CLI
+    module Application
+      # Hanami application CLI commands registry
+      module Commands
+        extend Hanami::CLI::Registry
+
+        require_relative "commands/console"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require "hanami/cli/application/command"
+require "hanami/console/context"
+
+module Hanami
+  class CLI
+    module Application
+      module Commands # rubocop:disable Style/Documentation
+        # Hanami application `console` CLI command
+        class Console < Command
+          REPL =
+            begin
+              require "pry"
+              Pry
+            rescue LoadError
+              require "irb"
+              IRB
+            end
+
+          desc "Open interactive console"
+
+          def call(**)
+            measure "#{prompt_prefix} booted in" do
+              out.puts "=> starting #{prompt_prefix} console"
+              application.init
+            end
+
+            start_repl
+          end
+
+          private
+
+          def start_repl
+            context = Hanami::Console::Context.new(application)
+
+            case REPL.name.to_sym
+            when :Pry
+              start_pry(context)
+            when :IRB
+              start_irb(context)
+            end
+          end
+
+          def start_pry(context)
+            # https://github.com/pry/pry/pull/1877
+            if Gem.loaded_specs["pry"].version >= Gem::Version.new("0.13.0")
+              Pry.prompt = Pry::Prompt.new(:hanami, "Hanami Console prompt.", prompt_procs)
+              Pry.start(context)
+            else
+              Pry.start(context, prompt_procs)
+            end
+          end
+
+          def start_irb(context)
+            IRB.start(context, prompt_procs)
+          end
+
+          def prompt_procs
+            [proc { default_prompt }, proc { indented_prompt }]
+          end
+
+          def default_prompt
+            "#{prompt_prefix}> "
+          end
+
+          def indented_prompt
+            "#{prompt_prefix}* "
+          end
+
+          def prompt_prefix
+            "#{inflector.underscore(application.application_name)}[#{application.config.env}]"
+          end
+        end
+
+        register "console", Console
+      end
+    end
+  end
+end

data/lib/hanami/cli/base_command.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "hanami/cli/command"
+require "hanami/utils/files"
+
+module Hanami
+  class CLI
+    # Base class for Hanami application CLI commands
+    class BaseCommand < Hanami::CLI::Command
+      attr_reader :out
+      attr_reader :inflector
+      attr_reader :files
+
+      def initialize(
+        command_name:,
+        out: $stdout,
+        inflector: Dry::Inflector.new,
+        files: Hanami::Utils::Files
+      )
+        super(command_name: command_name)
+
+        @out = out
+        @inflector = inflector
+        @files = files
+      end
+
+      private
+
+      def run_command(klass, *args)
+        klass.new(
+          command_name: klass.name,
+          application: application,
+          out: out,
+          files: files,
+        ).call(*args)
+      end
+
+      def measure(desc)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        yield
+        stop = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        out.puts "=> #{desc} in #{(stop - start).round(1)}s"
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "hanami/cli"
+require "dry/cli"
+require "ostruct"
 
 module Hanami
   # Hanami CLI
@@ -55,7 +56,7 @@ module Hanami
     # @since 1.1.0
     # @api private
     module Commands
-      extend Hanami::CLI::Registry
+      extend Dry::CLI::Registry
 
       require "hanami/cli/commands/command"
       require "hanami/cli/commands/server"