piko-lite-box 0.0.1

data/hanami-3.0.1/lib/hanami/slice/router.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require "hanami/router"
+require_relative "routing/resolver"
+require_relative "routing/middleware/stack"
+
+module Hanami
+  class Slice
+    # `Hanami::Router` subclass with enhancements for use within Hanami apps.
+    #
+    # This is loaded from Hanami apps and slices and made available as their
+    # {Hanami::Slice::ClassMethods#router router}.
+    #
+    # @api private
+    class Router < ::Hanami::Router
+      # @api private
+      attr_reader :inflector
+
+      # @api private
+      attr_reader :middleware_stack
+
+      # @api private
+      attr_reader :path_prefix
+
+      # @api private
+      def initialize(
+        routes:,
+        inflector:,
+        middleware_stack: Routing::Middleware::Stack.new,
+        prefix: ::Hanami::Router::DEFAULT_PREFIX,
+        **kwargs,
+        &blk
+      )
+        @path_prefix = Hanami::Router::Prefix.new(prefix)
+        @inflector = inflector
+        @middleware_stack = middleware_stack
+        @resource_scope = []
+        instance_eval(&blk)
+        super(**kwargs, &routes)
+      end
+
+      # @api private
+      def freeze
+        return self if frozen?
+
+        remove_instance_variable(:@middleware_stack)
+        super
+      end
+
+      # @api private
+      def to_rack_app
+        middleware_stack.to_rack_app(self)
+      end
+
+      # @api private
+      def use(*args, **kwargs, &blk)
+        middleware_stack.use(*args, **kwargs.merge(path_prefix: path_prefix.to_s), &blk)
+      end
+
+      # Yields a block for routes to resolve their action components from the given slice.
+      #
+      # An optional URL prefix may be supplied with `at:`.
+      #
+      # @example
+      #   # config/routes.rb
+      #
+      #   module MyApp
+      #     class Routes < Hanami::Routes
+      #       slice :admin, at: "/admin" do
+      #         # Will route to the "actions.posts.index" component in Admin::Slice
+      #         get "posts", to: "posts.index"
+      #       end
+      #     end
+      #   end
+      #
+      # @param slice_name [Symbol] the slice's name
+      # @param at [String, nil] optional URL prefix for the routes
+      #
+      # @api public
+      # @since 2.0.0
+      def slice(slice_name, at:, as: nil, &blk)
+        blk ||= @resolver.find_slice(slice_name).routes
+
+        prev_resolver = @resolver
+        @resolver = @resolver.to_slice(slice_name)
+
+        scope(at, as:, &blk)
+      ensure
+        @resolver = prev_resolver
+      end
+
+      # Generates RESTful routes for a plural resource.
+      #
+      # @param name [Symbol] the resource name (plural)
+      # @param options [Hash] options for customizing the routes
+      # @option options [Array<Symbol>] :only Limit to specific actions
+      # @option options [Array<Symbol>] :except Exclude specific actions
+      # @option options [String] :to the action key namespace, e.g. "namespace.action"
+      # @option options [String] :path the URL path
+      # @option options [String, Symbol] :as the route name prefix
+      #
+      # @example
+      #   resources :users
+      #   # Generates:
+      #   # GET    /users          users.index
+      #   # GET    /users/new      users.new
+      #   # POST   /users          users.create
+      #   # GET    /users/:id      users.show
+      #   # GET    /users/:id/edit users.edit
+      #   # PATCH  /users/:id      users.update
+      #   # DELETE /users/:id      users.destroy
+      #
+      # @api public
+      # @since 2.3.0
+      def resources(name, **options, &block)
+        build_resource(name, :plural, options, &block)
+      end
+
+      # Generates RESTful routes for a singular resource.
+      #
+      # @param name [Symbol] the resource name (singular)
+      # @param options [Hash] options for customizing the routes
+      # @option options [Array<Symbol>] :only limit to specific actions
+      # @option options [Array<Symbol>] :except exclude specific actions
+      # @option options [String] :to the action key namespace, e.g. "namespace.action"
+      # @option options [String] :path the URL path
+      # @option options [String, Symbol] :as the route name prefix
+      #
+      # @example
+      #   resource :profile
+      #   # Generates (singular, no index):
+      #   # GET    /profile/new    profile.new
+      #   # POST   /profile        profile.create
+      #   # GET    /profile        profile.show
+      #   # GET    /profile/edit   profile.edit
+      #   # PATCH  /profile        profile.update
+      #   # DELETE /profile        profile.destroy
+      #
+      # @api public
+      # @since 2.3.0
+      def resource(name, **options, &block)
+        build_resource(name, :singular, options, &block)
+      end
+
+      private
+
+      def build_resource(name, type, options, &block)
+        resource_builder = ResourceBuilder.new(
+          name: name,
+          type: type,
+          resource_scope: @resource_scope,
+          options: options,
+          inflector: inflector
+        )
+
+        resource_builder.add_routes(self)
+        resource_builder.scope(self, &block) if block
+      end
+
+      # Builds RESTful routes for a resource
+      #
+      # @api private
+      class ResourceBuilder
+        ROUTE_OPTIONS = {
+          index: {method: :get},
+          new: {method: :get, path_suffix: "/new", name_prefix: "new"},
+          create: {method: :post},
+          show: {method: :get, path_suffix: "/:id"},
+          edit: {method: :get, path_suffix: "/:id/edit", name_prefix: "edit"},
+          update: {method: :patch, path_suffix: "/:id"},
+          destroy: {method: :delete, path_suffix: "/:id"}
+        }.freeze
+
+        PLURAL_ACTIONS = %i[index new create show edit update destroy].freeze
+        SINGULAR_ACTIONS = (PLURAL_ACTIONS - %i[index]).freeze
+
+        def initialize(name:, type:, resource_scope:, options:, inflector:)
+          @name = name
+          @type = type
+          @resource_scope = resource_scope
+          @options = options
+          @inflector = inflector
+
+          @path = options[:path] || name.to_s
+        end
+
+        def scope(router, &block)
+          @resource_scope.push(@name)
+          router.scope(scope_path, as: scope_name, &block)
+        ensure
+          @resource_scope.pop
+        end
+
+        def add_routes(router)
+          actions.each do |action|
+            add_route(router, action, ROUTE_OPTIONS.fetch(action))
+          end
+        end
+
+        private
+
+        def plural?
+          @type == :plural
+        end
+
+        def singular?
+          !plural?
+        end
+
+        def scope_path
+          if plural?
+            "#{@path}/:#{@inflector.singularize(@path.to_s)}_id"
+          else
+            @path
+          end
+        end
+
+        def scope_name
+          @inflector.singularize(@name)
+        end
+
+        def actions
+          default_actions = plural? ? PLURAL_ACTIONS : SINGULAR_ACTIONS
+          if @options[:only]
+            Array(@options[:only]) & default_actions
+          elsif @options[:except]
+            default_actions - Array(@options[:except])
+          else
+            default_actions
+          end
+        end
+
+        def add_route(router, action, route_options)
+          path = "/#{@path}#{route_suffix(route_options[:path_suffix])}"
+          to = "#{key_path_base}#{CONTAINER_KEY_DELIMITER}#{action}"
+          as = route_name(action, route_options[:name_prefix])
+
+          router.public_send(route_options[:method], path, to:, as:)
+        end
+
+        def route_suffix(suffix)
+          return suffix.sub(LEADING_ID_REGEX, "") if suffix && singular?
+
+          suffix
+        end
+        LEADING_ID_REGEX = %r{\A/:id}
+
+        def key_path_base
+          @key_path_base ||= @options[:to] || begin
+            if @resource_scope.any?
+              prefix = @resource_scope.join(CONTAINER_KEY_DELIMITER)
+              "#{prefix}#{CONTAINER_KEY_DELIMITER}#{@name}"
+            else
+              @name.to_s
+            end
+          end
+        end
+
+        def route_name(action, prefix)
+          name = route_name_base
+          name = @inflector.pluralize(name) if plural? && PLURALIZED_NAME_ACTIONS.include?(action)
+
+          [prefix, name]
+        end
+        PLURALIZED_NAME_ACTIONS = %i[index create].freeze
+
+        def route_name_base
+          @route_name_base ||=
+            if @options[:as]
+              @options[:as].to_s
+            elsif plural?
+              @inflector.singularize(@name.to_s)
+            else
+              @name.to_s
+            end
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/slice/routes_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Slice
+    # Hanami app routes helpers
+    #
+    # An instance of this class will be registered with slice (at the "routes" key). You
+    # can use it to access the route helpers for your app.
+    #
+    # @example
+    #   MyApp::App["routes"].path(:root) # => "/"
+    #
+    # @see Hanami::Router::UrlHelpers
+    # @since 2.0.0
+    class RoutesHelper
+      # @since 2.0.0
+      # @api private
+      def initialize(router)
+        @router = router
+      end
+
+      # @see Hanami::Router::UrlHelpers#path
+      def path(...)
+        router.path(...)
+      end
+
+      # @see Hanami::Router::UrlHelpers#url
+      def url(...)
+        router.url(...)
+      end
+
+      private
+
+      attr_reader :router
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/slice/routing/middleware/stack.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "hanami/router"
+require "hanami/middleware"
+require "hanami/middleware/app"
+require "hanami/errors"
+
+module Hanami
+  class Slice
+    module Routing
+      # @since 2.0.0
+      # @api private
+      module Middleware
+        # Wraps a rack app with a middleware stack
+        #
+        # We use this class to add middlewares to the rack application generated from
+        # {Hanami::Slice::Router}.
+        #
+        # ```
+        # stack = Hanami::Slice::Routing::Middleware::Stack.new
+        # stack.use(Rack::ContentType, "text/html")
+        # stack.to_rack_app(a_rack_app)
+        # ```
+        #
+        # Middlewares can be mounted on specific paths:
+        #
+        # ```
+        # stack.with("/api") do
+        #   stack.use(Rack::ContentType, "application/json")
+        # end
+        # ```
+        #
+        # @see Hanami::Config#middleware
+        #
+        # @since 2.0.0
+        # @api private
+        class Stack
+          include Enumerable
+
+          # @since 2.0.0
+          # @api private
+          attr_reader :stack
+
+          # Returns an array of Ruby namespaces from which to load middleware classes specified by
+          # symbol names given to {#use}.
+          #
+          # Defaults to `[Hanami::Middleware]`.
+          #
+          # @return [Array<Object>]
+          #
+          # @api public
+          # @since 2.0.0
+          attr_reader :namespaces
+
+          # @since 2.0.0
+          # @api private
+          def initialize
+            @stack = Hash.new { |hash, key| hash[key] = [] }
+            @namespaces = [Hanami::Middleware]
+          end
+
+          # @since 2.0.0
+          # @api private
+          def initialize_copy(source)
+            super
+            @stack = stack.dup
+            @namespaces = namespaces.dup
+          end
+
+          # Adds a middleware to the stack.
+          #
+          # @example
+          #   # Using a symbol name; adds Hanami::Middleware::BodyParser.new([:json])
+          #   middleware.use :body_parser, :json
+          #
+          #   # Using a class name
+          #   middleware.use MyMiddleware
+          #
+          #   # Adding a middleware before or after others
+          #   middleware.use MyMiddleware, before: SomeMiddleware
+          #   middleware.use MyMiddleware, after: OtherMiddleware
+          #
+          # @param spec [Symbol, Class] the middleware name or class name
+          # @param args [Array, nil] Arguments to pass to the middleware's `.new` method
+          # @param before [Class, nil] an optional (already added) middleware class to add the
+          #   middleware before
+          # @param after [Class, nil] an optional (already added) middleware class to add the
+          #   middleware after
+          #
+          # @return [self]
+          #
+          # @api public
+          # @since 2.0.0
+          def use(spec, *args, path_prefix: ::Hanami::Router::DEFAULT_PREFIX, before: nil, after: nil, **kwargs, &blk)
+            middleware = resolve_middleware_class(spec)
+            item = [middleware, args, kwargs, blk]
+
+            if before
+              @stack[path_prefix].insert((idx = index_of(before, path_prefix)).zero? ? 0 : idx - 1, item)
+            elsif after
+              @stack[path_prefix].insert(index_of(after, path_prefix) + 1, item)
+            else
+              @stack[path_prefix].push(item)
+            end
+
+            self
+          end
+
+          # @since 2.0.0
+          # @api private
+          def update(other)
+            other.stack.each do |path_prefix, items|
+              stack[path_prefix].concat(items)
+            end
+            self
+          end
+
+          # @since 2.0.0
+          # @api private
+          def to_rack_app(app)
+            unless Hanami.bundled?("rack")
+              raise "Add \"rack\" to your `Gemfile` to run Hanami as a rack app"
+            end
+
+            mapping = to_hash
+            return app if mapping.empty?
+
+            Hanami::Middleware::App.new(app, mapping)
+          end
+
+          # @since 2.0.0
+          # @api private
+          def to_hash
+            @stack.each_with_object({}) do |(path, _), result|
+              result[path] = stack_for(path)
+            end
+          end
+
+          # @since 2.0.0
+          # @api private
+          def empty?
+            @stack.empty?
+          end
+
+          # @since 2.0.0
+          # @api private
+          def each(&blk)
+            @stack.each(&blk)
+          end
+
+          # @since 2.0.0
+          # @api private
+          def mapped(builder, prefix, &blk)
+            if prefix == ::Hanami::Router::DEFAULT_PREFIX
+              builder.instance_eval(&blk)
+            else
+              builder.map(prefix, &blk)
+            end
+          end
+
+          private
+
+          # @since 2.0.0
+          def index_of(middleware, path_prefix)
+            @stack[path_prefix].index { |(m, *)| m.equal?(middleware) }
+          end
+
+          # @since 2.0.0
+          # @api private
+          def stack_for(current_path)
+            @stack.each_with_object([]) do |(path, stack), result|
+              next unless current_path.start_with?(path)
+
+              result.push(stack)
+            end.flatten(1)
+          end
+
+          # @since 2.0.0
+          def resolve_middleware_class(spec)
+            case spec
+            when Symbol then load_middleware_class(spec)
+            when Class, Module then spec
+            else
+              if spec.respond_to?(:call)
+                spec
+              else
+                raise UnsupportedMiddlewareSpecError, spec
+              end
+            end
+          end
+
+          # @since 2.0.0
+          def load_middleware_class(spec)
+            begin
+              require "hanami/middleware/#{spec}"
+            rescue LoadError # rubocop:disable Lint/SuppressedException
+            end
+
+            # FIXME: Classify must use App inflector
+            class_name = Hanami::Utils::String.classify(spec.to_s)
+            namespace = namespaces.detect { |ns| ns.const_defined?(class_name) }
+
+            if namespace
+              namespace.const_get(class_name)
+            else
+              raise(
+                UnsupportedMiddlewareSpecError,
+                "Failed to find corresponding middleware class for `#{spec}` in #{namespaces.join(', ')}"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/slice/routing/resolver.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Slice
+    # @api private
+    module Routing
+      # Hanami app router endpoint resolver
+      #
+      # This resolves endpoints objects from a slice container using the strings passed to `to:` as
+      # their container keys.
+      #
+      # @api private
+      # @since 2.0.0
+      class Resolver
+        SLICE_ACTIONS_KEY_NAMESPACE = "actions"
+
+        # @api private
+        # @since 2.0.0
+        def initialize(slice:)
+          @slice = slice
+        end
+
+        # @api private
+        # @since 2.0.0
+        def find_slice(slice_name)
+          slice.slices[slice_name]
+        end
+
+        # @api private
+        # @since 2.0.0
+        def to_slice(slice_name)
+          self.class.new(slice: find_slice(slice_name))
+        end
+
+        # @api private
+        # @since 2.0.0
+        def call(_path, endpoint)
+          endpoint =
+            case endpoint
+            when String
+              resolve_slice_action(endpoint)
+            when Class
+              endpoint.respond_to?(:call) ? endpoint : endpoint.new
+            else
+              endpoint
+            end
+
+          unless endpoint.respond_to?(:call)
+            raise Routes::NotCallableEndpointError.new(endpoint)
+          end
+
+          endpoint
+        end
+
+        private
+
+        # @api private
+        # @since 2.0.0
+        attr_reader :slice
+
+        # @api private
+        # @since 2.0.0
+        def resolve_slice_action(key)
+          action_key = "#{SLICE_ACTIONS_KEY_NAMESPACE}.#{key}"
+
+          ensure_action_in_slice(action_key)
+
+          # Lazily resolve action from the slice to reduce router initialization time, and
+          # circumvent endless loops from the action requiring access to router-related
+          # concerns (which may not be fully loaded at the time of reading the routes)
+          -> (*args) {
+            action = slice.resolve(action_key) do
+              raise Routes::MissingActionError.new(action_key, slice)
+            end
+
+            action.call(*args)
+          }
+        end
+
+        def ensure_action_in_slice(key)
+          return unless slice.booted?
+
+          raise Routes::MissingActionError.new(key, slice) unless slice.key?(key)
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/slice/view_name_inferrer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Hanami
+  class Slice
+    # Infers a view name for automatically rendering within actions.
+    #
+    # @api private
+    # @since 2.0.0
+    class ViewNameInferrer
+      ALTERNATIVE_NAMES = {
+        "create" => "new",
+        "update" => "edit"
+      }.freeze
+
+      class << self
+        # Returns an array of container keys for views matching the given action.
+        #
+        # Also provides alternative view keys for common RESTful actions.
+        #
+        # @example
+        #   ViewNameInferrer.call(action_name: "Main::Actions::Posts::Create", slice: Main::Slice)
+        #   # => ["views.posts.create", "views.posts.new"]
+        #
+        # @param action_class_name [String] action class name
+        # @param slice [Hanami::Slice, Hanami::Application] Hanami slice containing the action
+        #
+        # @return [Array<string>] array of paired view container keys
+        def call(action_class_name:, slice:)
+          action_key_base = slice.config.actions.name_inference_base
+          view_key_base = slice.config.actions.view_name_inference_base
+
+          action_name_key = action_name_key(action_class_name, slice, action_key_base)
+
+          view_key = [view_key_base, action_name_key].compact.join(CONTAINER_KEY_DELIMITER)
+
+          [view_key, alternative_view_key(view_key)].compact
+        end
+
+        private
+
+        def action_name_key(action_name, slice, key_base)
+          slice
+            .inflector
+            .underscore(action_name)
+            .sub(%r{^#{slice.slice_name.path}#{PATH_DELIMITER}}, "")
+            .sub(%r{^#{key_base}#{PATH_DELIMITER}}, "")
+            .gsub("/", CONTAINER_KEY_DELIMITER)
+        end
+
+        def alternative_view_key(view_key)
+          parts = view_key.split(CONTAINER_KEY_DELIMITER)
+
+          alternative_name = ALTERNATIVE_NAMES[parts.last]
+          return unless alternative_name
+
+          [parts[0..-2], alternative_name].join(CONTAINER_KEY_DELIMITER)
+        end
+      end
+    end
+  end
+end