hanami-router 0.0.0 → 0.6.0

data/lib/hanami/routing/resource/nested.rb

@@ -0,0 +1,39 @@
+module Hanami
+  module Routing
+    class Resource
+      # Helper class to calculate nested path
+      #
+      # @api private
+      # @since 0.4.0
+      class Nested
+        # @api private
+        # @since 0.4.0
+        SEPARATOR = '/'.freeze
+
+        # @api private
+        # @since 0.4.0
+        def initialize(resource_name, resource)
+          @resource_name = resource_name.to_s.split(SEPARATOR)
+          @resource      = resource
+          @path          = []
+          _calculate(@resource_name.dup, @resource)
+        end
+
+        # @api private
+        # @since 0.4.0
+        def to_path
+          @path.reverse!.pop
+          @resource_name.zip(@path).flatten.join
+        end
+
+        private
+
+        def _calculate(param_wildcard, resource = nil)
+          return if resource.nil?
+          @path << resource.wildcard_param(param_wildcard.pop)
+          _calculate(param_wildcard, resource.parent)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/routing/resource/options.rb

@@ -0,0 +1,74 @@
+module Hanami
+  module Routing
+    class Resource
+      # Options for RESTFul resource(s)
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::Router#resource
+      # @see Hanami::Router#resources
+      class Options
+        # @api private
+        # @since 0.1.0
+        attr_reader :actions
+
+        # Initialize the options for:
+        #   * Hanami::Router#resource
+        #   * Hanami::Router#resources
+        #
+        # @param actions [Array<Symbol>] the name of the actions
+        # @param options [Hash]
+        # @option options [Hash] :only white list of the default actions
+        # @option options [Hash] :except black list of the default actions
+        # @option options [String] :controller namespace for an actions
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @see Hanami::Routing::Resource
+        # @see Hanami::Routing::Resources
+        #
+        # @example
+        #   require 'hanami/router'
+        #
+        #   Hanami::Router.new do
+        #     resources 'articles', only:   [:index]
+        #     resource  'profile',  except: [:new, :create, :destroy]
+        #   end
+        def initialize(actions, options = {})
+          only     = Array(options.delete(:only) || actions)
+          except   = Array(options.delete(:except))
+          @actions = ( actions & only ) - except
+
+          @options = options
+        end
+
+        # Return the option for the given key
+        #
+        # @param key [Symbol] the key that should be searched
+        #
+        # @return [Object,nil] returns the object associated to the given key
+        #   or nil, if missing.
+        #
+        # @api private
+        # @since 0.1.1
+        def [](key)
+          @options[key]
+        end
+
+        # Merge the current options with the given hash, without mutating self.
+        #
+        # @param hash [Hash] the hash to be merged
+        #
+        # @return [Hash] the result of the merging operation
+        #
+        # @api private
+        # @since 0.1.1
+        def merge(hash)
+          @options.merge(hash)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/routing/resources.rb

@@ -0,0 +1,48 @@
+require 'hanami/routing/resource'
+require 'hanami/routing/resources/action'
+
+module Hanami
+  module Routing
+    # Set of RESTful resources routes
+    # Implementation of Hanami::Router#resources
+    #
+    # @since 0.1.0
+    #
+    # @api private
+    #
+    # @see Hanami::Router#resources
+    class Resources < Resource
+      # Set of default routes
+      #
+      # @api private
+      # @since 0.1.0
+      self.actions = [:index, :new, :create, :show, :edit, :update, :destroy]
+
+      # Action class
+      #
+      # @api private
+      # @since 0.1.0
+      self.action = Resources::Action
+
+      # Member action class
+      #
+      # @api private
+      # @since 0.1.0
+      self.member = Resources::MemberAction
+
+      # Collection action class
+      #
+      # @api private
+      # @since 0.1.0
+      self.collection = Resources::CollectionAction
+
+      # Return wildcard param between separators
+      #
+      # @api private
+      # @since 0.4.0
+      def wildcard_param(route_param = nil)
+        "/:#{ Hanami::Utils::String.new(route_param).singularize }_id/"
+      end
+    end
+  end
+end

data/lib/hanami/routing/resources/action.rb

@@ -0,0 +1,150 @@
+require 'hanami/utils/string'
+require 'hanami/utils/path_prefix'
+require 'hanami/routing/resource'
+
+module Hanami
+  module Routing
+    class Resources < Resource
+      # Action for RESTful resources
+      #
+      # @since 0.1.0
+      #
+      # @api private
+      #
+      # @see Hanami::Router#resources
+      class Action < Resource::Action
+        # Ruby namespace where lookup for default subclasses.
+        #
+        # @api private
+        # @since 0.1.0
+        self.namespace = Resources
+
+        # Id route variable
+        #
+        # @since 0.2.0
+        # @api private
+        class_attribute :identifier
+        self.identifier = ':id'.freeze
+      end
+
+      # Pluralize concrete actions
+      #
+      # @api private
+      # @since 0.4.0
+      module PluralizedAction
+        private
+        # The name of the RESTful action.
+        #
+        # @api private
+        # @since 0.4.0
+        def as
+          Hanami::Utils::String.new(super).pluralize
+        end
+      end
+
+      # Collection action
+      # It implements #collection within a #resources block.
+      #
+      # @api private
+      # @since 0.1.0
+      # @see Hanami::Router#resources
+      class CollectionAction < Resource::CollectionAction
+        def as(action_name)
+          Hanami::Utils::String.new(super(action_name)).pluralize
+        end
+      end
+
+      # Member action
+      # It implements #member within a #resources block.
+      #
+      # @api private
+      # @since 0.1.0
+      # @see Hanami::Router#resources
+      class MemberAction < Resource::MemberAction
+        private
+        def path(action_name)
+          rest_path.join(Action.identifier, action_name)
+        end
+      end
+
+      # Implementation of common methods for concrete member actions
+      #
+      # @api private
+      # @since 0.1.0
+      module DefaultMemberAction
+        private
+        def path
+          rest_path.join(Action.identifier)
+        end
+      end
+
+      # Index action
+      #
+      # @api private
+      # @since 0.1.0
+      # @see Hanami::Router#resources
+      class Index < Action
+        include PluralizedAction
+        self.verb = :get
+      end
+
+      # New action
+      #
+      # @api private
+      # @since 0.1.0
+      # @see Hanami::Router#resources
+      class New < Resource::New
+      end
+
+      # Create action
+      #
+      # @api private
+      # @since 0.1.0
+      # @see Hanami::Router#resources
+      class Create < Resource::Create
+        include PluralizedAction
+      end
+
+      # Show action
+      #
+      # @api private
+      # @since 0.1.0
+      # @see Hanami::Router#resources
+      class Show < Resource::Show
+        include DefaultMemberAction
+      end
+
+      # Edit action
+      #
+      # @api private
+      # @since 0.1.0
+      # @see Hanami::Router#resources
+      class Edit < Resource::Edit
+        include DefaultMemberAction
+
+        private
+        def path
+          super.join(action_name)
+        end
+      end
+
+      # Update action
+      #
+      # @api private
+      # @since 0.1.0
+      # @see Hanami::Router#resources
+      class Update < Resource::Update
+        include DefaultMemberAction
+      end
+
+      # Destroy action
+      #
+      # @api private
+      # @since 0.1.0
+      # @see Hanami::Router#resources
+      class Destroy < Resource::Destroy
+        include DefaultMemberAction
+      end
+    end
+  end
+end

data/lib/hanami/routing/route.rb

@@ -0,0 +1,62 @@
+require 'http_router/route'
+
+module Hanami
+  module Routing
+    # Entry of the routing system
+    #
+    # @api private
+    #
+    # @since 0.1.0
+    #
+    # @see http://rdoc.info/gems/http_router/HttpRouter/Route
+    #
+    # @example
+    #   require 'hanami/router'
+    #
+    #   router = Hanami::Router.new
+    #   router.get('/', to: endpoint) # => #<Hanami::Routing::Route:0x007f83083ba028 ...>
+    class Route < HttpRouter::Route
+      # Asks the given resolver to return an endpoint that will be associated
+      #   with the other options.
+      #
+      # @param resolver [Hanami::Routing::EndpointResolver, #resolve] this may change
+      #   according to the :resolve option passed to Hanami::Router#initialize.
+      #
+      # @param options [Hash] options to customize the route
+      # @option options [Symbol] :as the name we want to use for the route
+      #
+      # @since 0.1.0
+      #
+      # @api private
+      #
+      # @see Hanami::Router#initialize
+      #
+      # @example
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new
+      #   router.get('/', to: endpoint, as: :home_page).name # => :home_page
+      #
+      #   router.path(:home_page) # => '/'
+      def generate(resolver, options = {}, &endpoint)
+        self.to   = resolver.resolve(options, &endpoint)
+        self.name = options[:as].to_sym if options[:as]
+        self
+      end
+
+      # Introspect the given route to understand if there is a wrapped
+      # Hanami::Router
+      #
+      # @since 0.2.0
+      # @api private
+      def nested_router
+        dest.routes if dest.respond_to?(:routes)
+      end
+
+      private
+      def to=(dest = nil, &blk)
+        self.to dest, &blk
+      end
+    end
+  end
+end

data/lib/hanami/routing/routes_inspector.rb

@@ -0,0 +1,215 @@
+require 'hanami/utils/path_prefix'
+
+module Hanami
+  module Routing
+    # Routes inspector
+    #
+    # @since 0.2.0
+    class RoutesInspector
+      # Default route formatter
+      #
+      # @since 0.2.0
+      # @api private
+      FORMATTER = "%<name>20s %<methods>-10s %<path>-30s %<endpoint>-30s\n".freeze
+
+      # Default HTTP methods separator
+      #
+      # @since 0.2.0
+      # @api private
+      HTTP_METHODS_SEPARATOR = ', '.freeze
+
+      # Default inspector header hash values
+      #
+      # @since 0.5.0
+      # @api private
+      INSPECTOR_HEADER_HASH =  Hash[
+        name:     'Name',
+        methods:  'Method',
+        path:     'Path',
+        endpoint: 'Action'
+      ].freeze
+
+      # Default inspector header name values
+      #
+      # @since 0.5.0
+      # @api private
+      INSPECTOR_HEADER_NAME = 'Name'.freeze
+
+      # Empty line string
+      #
+      # @since 0.5.0
+      # @api private
+      EMPTY_LINE = "\n".freeze
+
+      # Instantiate a new inspector
+      #
+      # @return [Hanami::Routing::RoutesInspector] the new instance
+      #
+      # @since 0.2.0
+      # @api private
+      def initialize(routes)
+        @routes = routes
+      end
+
+      # Return a formatted string that describes all the routes
+      #
+      # @param formatter [String] the optional formatter for a route
+      # @param base_path [String] the base path of a nested route
+      #
+      # @return [String] routes pretty print
+      #
+      # @since 0.2.0
+      #
+      # @see Hanami::Routing::RoutesInspector::FORMATTER
+      #
+      # @example Default formatter
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new do
+      #     get    '/',       to: 'home#index'
+      #     get    '/login',  to: 'sessions#new',     as: :login
+      #     post   '/login',  to: 'sessions#create'
+      #     delete '/logout', to: 'sessions#destroy', as: :logout
+      #   end
+      #
+      #   puts router.inspector.to_s
+      #     # =>   Name Method     Path                     Action
+      #
+      #                 GET, HEAD  /                        Home::Index
+      #           login GET, HEAD  /login                   Sessions::New
+      #                 POST       /login                   Sessions::Create
+      #          logout GET, HEAD  /logout                  Sessions::Destroy
+      #
+      # @example Custom formatter
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new do
+      #     get    '/',       to: 'home#index'
+      #     get    '/login',  to: 'sessions#new',     as: :login
+      #     post   '/login',  to: 'sessions#create'
+      #     delete '/logout', to: 'sessions#destroy', as: :logout
+      #   end
+      #
+      #   formatter = "| %{methods} | %{name} | %{path} | %{endpoint} |\n"
+      #
+      #   puts router.inspector.to_s(formatter)
+      #     # => | Method    | Name   | Path    | Action            |
+      #
+      #          | GET, HEAD |        | /       | Home::Index       |
+      #          | GET, HEAD | login  | /login  | Sessions::New     |
+      #          | POST      |        | /login  | Sessions::Create  |
+      #          | GET, HEAD | logout | /logout | Sessions::Destroy |
+      #
+      # @example Nested routes
+      #   require 'hanami/router'
+      #
+      #   class AdminHanamiApp
+      #     def call(env)
+      #     end
+      #     def routes
+      #       Hanami::Router.new {
+      #         get '/home', to: 'home#index'
+      #       }
+      #     end
+      #   end
+      #
+      #   router = Hanami::Router.new {
+      #     get '/fakeroute', to: 'fake#index'
+      #     mount AdminHanamiApp, at: '/admin'
+      #     mount Hanami::Router.new {
+      #       get '/posts', to: 'posts#index'
+      #       mount Hanami::Router.new {
+      #         get '/comments', to: 'comments#index'
+      #       }, at: '/second_mount'
+      #     }, at: '/api'
+      #   }
+      #
+      #   formatter = "| %{methods} | %{name} | %{path} | %{endpoint} |\n"
+      #
+      #   puts router.inspector.to_s(formatter)
+      #     # => | Method    | Name | Path                       | Action          |
+      #
+      #          | GET, HEAD |      | /fakeroute                 | Fake::Index     |
+      #          | GET, HEAD |      | /admin/home                | Home::Index     |
+      #          | GET, HEAD |      | /api/posts                 | Posts::Index    |
+      #          | GET, HEAD |      | /api/second_mount/comments | Comments::Index |
+      def to_s(formatter = FORMATTER, base_path = nil)
+        base_path = Utils::PathPrefix.new(base_path)
+
+        inspect_routes(formatter, base_path)
+          .insert(0, formatter % INSPECTOR_HEADER_HASH + EMPTY_LINE)
+      end
+
+      # Returns a string representation of routes
+      #
+      # @param formatter [String] the template for the output
+      # @param base_path [Hanami::Utils::PathPrefix] the base path
+      #
+      # @return [String] serialized routes from router
+      #
+      # @since 0.5.1
+      # @api private
+      #
+      # @see Hanami::Routing::RoutesInspector#FORMATTER
+      # @see Hanami::Routing::RoutesInspector#to_s
+      def inspect_routes(formatter, base_path)
+        result = ''
+
+        # TODO refactoring: replace conditional with polymorphism
+        # We're exposing too much knowledge from Routing::Route:
+        # #path_for_generation and #base_path
+        @routes.each do |route|
+          result << if router = route.nested_router
+            inspect_router(formatter, router, route, base_path)
+          else
+            inspect_route(formatter, route, base_path)
+          end
+        end
+
+        result
+      end
+
+      private
+
+      # Returns a string representation of the given route
+      #
+      # @param formatter [String] the template for the output
+      # @param route [Hanami::Routing::Route] a route
+      # @param base_path [Hanami::Utils::PathPrefix] the base path
+      #
+      # @return [String] serialized route
+      #
+      # @since 0.2.0
+      # @api private
+      #
+      # @see Hanami::Routing::RoutesInspector#FORMATTER
+      # @see Hanami::Routing::RoutesInspector#to_s
+      def inspect_route(formatter, route, base_path)
+        formatter % Hash[
+          name:     route.name,
+          methods:  route.request_methods.to_a.join(HTTP_METHODS_SEPARATOR),
+          path:     base_path.join(route.path_for_generation),
+          endpoint: route.dest.inspect
+        ]
+      end
+
+      # Returns a string representation of the given router
+      #
+      # @param formatter [String] the template for the output
+      # @param router [Hanami::Router] a router
+      # @param route [Hanami::Routing::Route] a route
+      # @param base_path [Hanami::Utils::PathPrefix] the base path
+      #
+      # @return [String] serialized routes from router
+      #
+      # @since 0.2.0
+      # @api private
+      #
+      # @see Hanami::Routing::RoutesInspector#FORMATTER
+      # @see Hanami::Routing::RoutesInspector#to_s
+      def inspect_router(formatter, router, route, base_path)
+        router.inspector.inspect_routes(formatter, base_path.join(route.path_for_generation))
+      end
+    end
+  end
+end