hanami 2.0.0.alpha7 → 2.0.0.beta1

data/lib/hanami/extensions/view/context.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+require "hanami/view/context"
+require_relative "../../errors"
+require_relative "../../slice_configurable"
+require_relative "slice_configured_context"
+
+module Hanami
+  module Extensions
+    module View
+      # View context for views in Hanami apps.
+      #
+      # @api public
+      # @since 2.0.0
+      module Context
+        def self.included(context_class)
+          super
+
+          context_class.extend(Hanami::SliceConfigurable)
+          context_class.extend(ClassMethods)
+          context_class.prepend(InstanceMethods)
+        end
+
+        module ClassMethods
+          def configure_for_slice(slice)
+            extend SliceConfiguredContext.new(slice)
+          end
+        end
+
+        module InstanceMethods
+          # @see SliceConfiguredContext#define_new
+          def initialize(**kwargs)
+            defaults = {content: {}}
+
+            super(**kwargs, **defaults)
+          end
+
+          def inflector
+            _options.fetch(:inflector)
+          end
+
+          def routes
+            _options.fetch(:routes)
+          end
+
+          def settings
+            _options.fetch(:settings)
+          end
+
+          def assets
+            unless _options[:assets]
+              raise Hanami::ComponentLoadError, "hanami-assets gem is required to access assets"
+            end
+
+            _options[:assets]
+          end
+
+          def content_for(key, value = nil, &block)
+            content = _options[:content]
+            output = nil
+
+            if block
+              content[key] = yield
+            elsif value
+              content[key] = value
+            else
+              output = content[key]
+            end
+
+            output
+          end
+
+          def current_path
+            request.fullpath
+          end
+
+          def csrf_token
+            request.session[Hanami::Action::CSRFProtection::CSRF_TOKEN]
+          end
+
+          def request
+            _options.fetch(:request)
+          end
+
+          def session
+            request.session
+          end
+
+          def flash
+            response.flash
+          end
+
+          private
+
+          # TODO: create `Request#flash` so we no longer need the `response`
+          def response
+            _options.fetch(:response)
+          end
+        end
+      end
+    end
+  end
+end
+
+Hanami::View::Context.include(Hanami::Extensions::View::Context)

data/lib/hanami/extensions/view/slice_configured_context.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+
+module Hanami
+  module Extensions
+    module View
+      # Provides slice-specific configuration and behavior for any view context class
+      # defined within a slice's module namespace.
+      #
+      # @api private
+      # @since 2.0.0
+      class SliceConfiguredContext < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(_context_class)
+          define_new
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        # Defines a {.new} method on the context class that resolves key components from
+        # the app container and provides them to {#initialize} as injected
+        # dependencies.
+        #
+        # This includes the following app components:
+        #
+        #   - the configured inflector as `inflector`
+        #   - "settings" from the app container as `settings`
+        #   - "routes" from the app container as `routes`
+        #   - "assets" from the app container as `assets`
+        def define_new
+          inflector = slice.inflector
+          resolve_settings = method(:resolve_settings)
+          resolve_routes = method(:resolve_routes)
+          resolve_assets = method(:resolve_assets)
+
+          define_method :new do |**kwargs|
+            kwargs[:inflector] ||= inflector
+            kwargs[:settings] ||= resolve_settings.()
+            kwargs[:routes] ||= resolve_routes.()
+            kwargs[:assets] ||= resolve_assets.()
+
+            super(**kwargs)
+          end
+        end
+
+        def resolve_settings
+          slice.app[:settings] if slice.app.key?(:settings)
+        end
+
+        def resolve_routes
+          slice.app["routes"] if slice.app.key?("routes")
+        end
+
+        def resolve_assets
+          slice.app[:assets] if slice.app.key?(:assets)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/extensions/view/slice_configured_view.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+
+module Hanami
+  module Extensions
+    module View
+      # Provides slice-specific configuration and behavior for any view class defined
+      # within a slice's module namespace.
+      #
+      # @api private
+      # @since 2.0.0
+      class SliceConfiguredView < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(view_class)
+          configure_view(view_class)
+          define_inherited
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize
+        def configure_view(view_class)
+          view_class.settings.each do |setting|
+            if slice.config.views.respond_to?(:"#{setting}")
+              view_class.config.public_send(
+                :"#{setting}=",
+                slice.config.views.public_send(:"#{setting}")
+              )
+            end
+          end
+
+          view_class.config.inflector = inflector
+          view_class.config.paths = prepare_paths(slice, view_class.config.paths)
+          view_class.config.template = template_name(view_class)
+
+          if (part_namespace = namespace_from_path(slice.config.views.parts_path))
+            view_class.config.part_namespace = part_namespace
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def define_inherited
+          template_name = method(:template_name)
+
+          define_method(:inherited) do |subclass|
+            super(subclass)
+            subclass.config.template = template_name.(subclass)
+          end
+        end
+
+        def prepare_paths(slice, configured_paths)
+          configured_paths.map { |path|
+            if path.dir.relative?
+              if slice.app.equal?(slice)
+                # App-level templates are in app/
+                slice.root.join(APP_DIR, path.dir)
+              else
+                # Other slice templates are in the root slice dir
+                slice.root.join(path.dir)
+              end
+            else
+              path
+            end
+          }
+        end
+
+        def namespace_from_path(path)
+          path = "#{slice.slice_name.path}/#{path}"
+
+          begin
+            require path
+          rescue LoadError => exception
+            raise exception unless exception.path == path
+          end
+
+          begin
+            inflector.constantize(inflector.camelize(path))
+          rescue NameError => exception
+          end
+        end
+
+        def template_name(view_class)
+          slice
+            .inflector
+            .underscore(view_class.name)
+            .sub(/^#{slice.slice_name.path}\//, "")
+            .sub(/^#{view_class.config.template_inference_base}\//, "")
+        end
+
+        def inflector
+          slice.inflector
+        end
+      end
+    end
+  end
+end

data/lib/hanami/extensions/view.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+require_relative "../slice_configurable"
+require_relative "view/slice_configured_view"
+
+module Hanami
+  module Extensions
+    # Extended behavior for actions intended for use within an Hanami app.
+    #
+    # @see Hanami::View
+    #
+    # @api public
+    # @since 2.0.0
+    module View
+      def self.included(view_class)
+        super
+
+        view_class.extend(Hanami::SliceConfigurable)
+        view_class.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # @api private
+        def configure_for_slice(slice)
+          extend SliceConfiguredView.new(slice)
+        end
+      end
+    end
+  end
+end
+
+Hanami::View.include(Hanami::Extensions::View)

data/lib/hanami/extensions.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+if Hanami.bundled?("hanami-controller")
+  require_relative "./extensions/action"
+end
+
+if Hanami.bundled?("hanami-view")
+  require_relative "./extensions/view"
+  require_relative "./extensions/view/context"
+end

data/lib/hanami/providers/inflector.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "dry/system/provider/source"
+
+module Hanami
+  module Providers
+    class Inflector < Dry::System::Provider::Source
+      def start
+        register :inflector, Hanami.app.inflector
+      end
+    end
+  end
+end

data/lib/hanami/providers/logger.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "dry/system/provider/source"
+
+module Hanami
+  module Providers
+    class Logger < Dry::System::Provider::Source
+      def start
+        register :logger, Hanami.app.configuration.logger_instance
+      end
+    end
+  end
+end

data/lib/hanami/providers/rack.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "dry/system/provider/source"
+
+module Hanami
+  module Providers
+    class Rack < Dry::System::Provider::Source
+      def prepare
+        require "dry/monitor"
+        require "hanami/web/rack_logger"
+      end
+
+      def start
+        target.start :logger
+
+        notifications = target[:notifications]
+
+        monitor_middleware = Dry::Monitor::Rack::Middleware.new(notifications)
+
+        rack_logger = Hanami::Web::RackLogger.new(target[:logger])
+        rack_logger.attach(monitor_middleware)
+
+        register "monitor", monitor_middleware
+      end
+    end
+  end
+end

data/lib/hanami/providers/routes.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "dry/system/provider/source"
+
+module Hanami
+  module Providers
+    class Routes < Dry::System::Provider::Source
+      def self.for_slice(slice)
+        Class.new(self) do |klass|
+          klass.instance_variable_set(:@slice, slice)
+        end
+      end
+
+      def self.slice
+        @slice || Hanami.app
+      end
+
+      def prepare
+        require "hanami/slice/routes_helper"
+      end
+
+      def start
+        # Register a lazy instance of RoutesHelper to ensure we don't load prematurely
+        # load the router during the process of booting. This ensures the router's
+        # resolver can run strict action key checks once when it runs on a fully booted
+        # slice.
+        register :routes do
+          Hanami::Slice::RoutesHelper.new(self.class.slice.router)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/providers/settings.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "dry/system/provider/source"
+
+module Hanami
+  module Providers
+    class Settings < Dry::System::Provider::Source
+      def self.for_slice(slice)
+        Class.new(self) do |klass|
+          klass.instance_variable_set(:@slice, slice)
+        end
+      end
+
+      def self.slice
+        @slice || Hanami.app
+      end
+
+      def start
+        register :settings, self.class.slice.settings
+      end
+    end
+  end
+end

data/lib/hanami/rake_tasks.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "hanami/cli/rake_tasks"
+require "hanami/cli/command_line"
+
+Hanami::CLI::RakeTasks.register_tasks do
+  @_hanami_command_line = Hanami::CLI::CommandLine.new
+
+  desc "Load the app environment"
+  task :environment do
+    require "hanami/prepare"
+  end
+
+  # Ruby ecosystem compatibility
+  #
+  # Most of the SaaS automatic tasks are designed after Ruby on Rails.
+  # They expect the following Rake tasks to be present:
+  #
+  #   * db:migrate
+  #   * assets:precompile
+  #
+  # See https://github.com/heroku/heroku-buildpack-ruby/issues/442
+  #
+  # ===
+  #
+  # These Rake tasks aren't listed when someone runs `rake -T`, because we
+  # want to encourage developers to use `hanami` commands.
+  #
+  # In order to migrate the database or precompile assets a developer should
+  # use:
+  #
+  #   * hanami db migrate
+  #   * hanami assets precompile
+  #
+  # This is the preferred way to run Hanami command line tasks.
+  # Please use them when you're in control of your deployment environment.
+  #
+  # If you're not in control and your deployment requires these "standard"
+  # Rake tasks, they are here to solve this only specific problem.
+  namespace :db do
+    task :migrate do
+      # TODO(@jodosha): Enable when we'll integrate with ROM
+      # run_hanami_command("db migrate")
+    end
+  end
+
+  namespace :assets do
+    task :precompile do
+      # TODO(@jodosha): Enable when we'll integrate with hanami-assets
+      # run_hanami_command("assets precompile")
+    end
+  end
+
+  private
+
+  def run_hanami_command(command)
+    @_hanami_command_line.call(command)
+  end
+end
+
+Hanami::CLI::RakeTasks.install_tasks

data/lib/hanami/routes.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Hanami
+  # App routes
+  #
+  # Users are expected to inherit from this class to define their app
+  # routes.
+  #
+  # @example
+  #   # config/routes.rb
+  #   # frozen_string_literal: true
+  #
+  #   require "hanami/routes"
+  #
+  #   module MyApp
+  #     class Routes < Hanami::Routes
+  #       define do
+  #         root to: "home.show"
+  #       end
+  #     end
+  #   end
+  #
+  #   See {Hanami::Slice::Router} for the syntax allowed within the
+  #   `define` block.
+  #
+  # @see Hanami::Slice::Router
+  # @since 2.0.0
+  class Routes
+    # Defines app routes
+    #
+    # @yield DSL syntax to define app routes executed in the context
+    # of {Hanami::Slice::Router}
+    #
+    # @return [Proc]
+    def self.define(&block)
+      @_routes = block
+    end
+
+    # @api private
+    def self.routes
+      @_routes || raise(<<~MSG)
+        Routes need to be defined before being able to fetch them. E.g.,
+          define do
+            slice :main, at: "/" do
+              root to: "home.show"
+            end
+          end
+      MSG
+    end
+  end
+end

data/lib/hanami/server.rb

@@ -10,7 +10,7 @@ module Hanami
   #
   #   `bundle exec hanami server`
   #
-  # It runs the application, by using the server specified in your `Gemfile`
+  # It runs the app, by using the server specified in your `Gemfile`
   # (eg. Puma or Unicorn).
   #
   # @since 0.8.0

data/lib/hanami/settings/dotenv_store.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+
+module Hanami
+  class Settings
+    # Default app settings store.
+    #
+    # Uses [dotenv](https://github.com/bkeepers/dotenv) (if available) to load
+    # .env files and then loads settings from ENV. For a given `HANAMI_ENV`
+    # environment, the following `.env` files are looked up in the following order:
+    #
+    # - .env.{environment}.local
+    # - .env.local (except if the environment is `test`)
+    # - .env.{environment}
+    # - .env
+    #
+    # @since 2.0.0
+    # @api private
+    class DotenvStore
+      Undefined = Dry::Core::Constants::Undefined
+
+      attr_reader :store,
+                  :hanami_env
+
+      def initialize(store: ENV, hanami_env: Hanami.env)
+        @store = store
+        @hanami_env = hanami_env
+      end
+
+      def fetch(name, default_value = Undefined, &block)
+        name = name.to_s.upcase
+        args = (default_value == Undefined) ? [name] : [name, default_value]
+
+        store.fetch(*args, &block)
+      end
+
+      def with_dotenv_loaded
+        require "dotenv"
+        Dotenv.load(*dotenv_files) if defined?(Dotenv)
+        self
+      rescue LoadError
+        self
+      end
+
+      private
+
+      def dotenv_files
+        [
+          ".env.#{hanami_env}.local",
+          (".env.local" unless hanami_env == :test),
+          ".env.#{hanami_env}",
+          ".env"
+        ].compact
+      end
+    end
+  end
+end