lotus-router 0.1.1 → 0.2.0

data/lib/lotus/router/version.rb

@@ -1,5 +1,5 @@
 module Lotus
   class Router
-    VERSION = '0.1.1'
+    VERSION = '0.2.0'.freeze
   end
 end

data/lib/lotus/routing/endpoint.rb

@@ -30,6 +30,20 @@ module Lotus
     #     get '/rack-app', to: RackApp.new
     #   end
     class Endpoint < SimpleDelegator
+      # @since 0.2.0
+      def inspect
+        case __getobj__
+        when Proc
+          source, line     = __getobj__.source_location
+          lambda_inspector = " (lambda)"  if  __getobj__.lambda?
+
+          "#<Proc@#{ ::File.expand_path(source) }:#{ line }#{ lambda_inspector }>"
+        when Class
+          __getobj__
+        else
+          "#<#{ __getobj__.class }>"
+        end
+      end
     end
 
     # Routing endpoint
@@ -52,7 +66,7 @@ module Lotus
     #
     #   Lotus::Router.new do
     #     get '/class',               to: RackMiddleware
-    #     get '/lotus-action-class',  to: DashboardController::Index
+    #     get '/lotus-action-class',  to: Dashboard::Index
     #     get '/lotus-action-string', to: 'dashboard#index'
     #
     #     resource  'identity'
@@ -103,9 +117,31 @@ module Lotus
         obj.call(env)
       end
 
+      # @since 0.2.0
+      def inspect
+        # TODO review this implementation once the namespace feature will be
+        # cleaned up.
+        result = klass rescue nil
+
+        if result.nil?
+          result = @name
+          result = "#{ @namespace }::#{ result }" if @namespace != Object
+        end
+
+        result
+      end
+
       private
+      # @since 0.1.0
+      # @api private
       def obj
-        Utils::Class.load!(@name, @namespace).new
+        klass.new
+      end
+
+      # @since 0.2.0
+      # @api private
+      def klass
+        Utils::Class.load!(@name, @namespace)
       rescue NameError => e
         raise EndpointNotFound.new(e.message)
       end

data/lib/lotus/routing/endpoint_resolver.rb

@@ -10,29 +10,9 @@ module Lotus
     #
     # @api private
     class EndpointResolver
-      # Default suffix appended to the controller#action string.
-      # A different suffix can be passed to #initialize with the `:suffix` option.
-      #
-      # @see #initialize
-      # @see #resolve
-      #
-      # @since 0.1.0
-      #
-      # @example
-      #   require 'lotus/router'
-      #
-      #   router = Lotus::Router.new do
-      #     get '/', to: 'articles#show'
-      #   end
-      #
-      #   # That string is transformed into "Articles(::Controller::|Controller::)Show"
-      #   # because the resolver is able to lookup (in the given order) for:
-      #   #
-      #   #  * Articles::Controller::Show
-      #   #  * ArticlesController::Show
-      #   #
-      #   # When it finds a class, it stops the lookup and returns the result.
-      SUFFIX = '(::Controller::|Controller::)'.freeze
+      # @since 0.2.0
+      # @api private
+      NAMING_PATTERN = '%{controller}::%{action}'.freeze
 
       # Default separator for controller and action.
       # A different separator can be passed to #initialize with the `:separator` option.
@@ -62,27 +42,19 @@ module Lotus
       # @option options [Class,Module] :namespace the Ruby namespace where to
       #   lookup for controllers and actions. (defaults to `Object`)
       #
-      # @option options [String] :suffix the suffix appended to the controller
-      #   name during the lookup. (defaults to `SUFFIX`)
-      #
       # @option options [String] :pattern the string to interpolate in order
-      #   to return an action name. Please note that this option override
-      #   :suffix. This string SHOULD contain `'%{controller}'` and `'%{action}'`,
-      #   all the other keys will be ignored. See the examples below.
+      #   to return an action name. This string SHOULD contain
+      #   <tt>'%{controller}'</tt> and <tt>'%{action}'</tt>, all the other keys
+      #   will be ignored.
+      #   See the examples below.
       #
       # @option options [String] :action_separator the sepatator between controller and
       #   action name. (defaults to `ACTION_SEPARATOR`)
       #
-      #
-      #
       # @return [Lotus::Routing::EndpointResolver] self
       #
-      #
-      #
       # @since 0.1.0
       #
-      #
-      #
       # @example Specify custom endpoint class
       #   require 'lotus/router'
       #
@@ -91,8 +63,6 @@ module Lotus
       #
       #   router.get('/', to: endpoint).dest # => #<CustomEndpoint:0x007f97f3359570 ...>
       #
-      #
-      #
       # @example Specify custom Ruby namespace
       #   require 'lotus/router'
       #
@@ -100,34 +70,18 @@ module Lotus
       #   router   = Lotus::Router.new(resolver: resolver)
       #
       #   router.get('/', to: 'articles#show')
-      #   # => Will look for:
-      #   #  * MyApp::Articles::Controller::Show
-      #   #  * MyApp::ArticlesController::Show
-      #
-      #
-      #
-      # @example Specify custom controller suffix
-      #   require 'lotus/router'
-      #
-      #   resolver = Lotus::Routing::EndpointResolver.new(suffix: '(Controller::|Ctrl::)')
-      #   router   = Lotus::Router.new(resolver: resolver)
-      #
-      #   router.get('/', to: 'articles#show')
-      #   # => Will look for:
-      #   #  * ArticlesController::Show
-      #   #  * ArticlesCtrl::Show
+      #     # => Will look for: MyApp::Articles::Show
       #
       #
       #
-      # @example Specify custom simple pattern
+      # @example Specify custom pattern
       #   require 'lotus/router'
       #
-      #   resolver = Lotus::Routing::EndpointResolver.new(pattern: 'Controllers::%{controller}::%{action}')
+      #   resolver = Lotus::Routing::EndpointResolver.new(pattern: '%{controller}Controller::%{action}')
       #   router   = Lotus::Router.new(resolver: resolver)
       #
       #   router.get('/', to: 'articles#show')
-      #   # => Will look for:
-      #   #  * Controllers::Articles::Show
+      #     # => Will look for: ArticlesController::Show
       #
       #
       #
@@ -138,15 +92,12 @@ module Lotus
       #   router   = Lotus::Router.new(resolver: resolver)
       #
       #   router.get('/', to: 'articles@show')
-      #   # => Will look for:
-      #   #  * Articles::Controller::Show
-      #   #  * ArticlesController::Show
+      #     # => Will look for: Articles::Show
       def initialize(options = {})
         @endpoint_class   = options[:endpoint]         || Endpoint
         @namespace        = options[:namespace]        || Object
         @action_separator = options[:action_separator] || ACTION_SEPARATOR
-        @pattern          = options[:pattern]          ||
-          "%{controller}#{options[:suffix] || SUFFIX}%{action}"
+        @pattern          = options[:pattern]          || NAMING_PATTERN
       end
 
       # Resolve the given set of HTTP verb, path, endpoint and options.
@@ -156,7 +107,7 @@ module Lotus
       # @param options [Hash] the options required to resolve the endpoint
       #
       # @option options [String,Proc,Class,Object#call] :to the endpoint
-      # @option options [String] :prefix an optional path prefix
+      # @option options [String] :namespace an optional routing namespace
       #
       # @return [Endpoint] this may vary according to the :endpoint option
       #   passed to #initialize
@@ -194,14 +145,18 @@ module Lotus
       #   require 'lotus/router'
       #
       #   router = Lotus::Router.new
-      #   router.get '/', to: ArticlesController::Show
+      #   router.get '/', to: Articles::Show
       #
-      # @example Resolve with a path prefix
+      # @example Resolve a redirect with a namespace
       #   require 'lotus/router'
       #
       #   router = Lotus::Router.new
-      #   router.get '/dashboard', to: BackendApp.new, prefix: 'backend'
-      #     # => Will be available under '/backend/dashboard'
+      #   router.namespace 'users' do
+      #     get '/home',           to: ->(env) { ... }
+      #     redirect '/dashboard', to: '/home'
+      #   end
+      #
+      #   # GET /users/dashboard => 301 Location: "/users/home"
       def resolve(options, &endpoint)
         result = endpoint || find(options)
         resolve_callable(result) || resolve_matchable(result) || default
@@ -211,17 +166,13 @@ module Lotus
       #
       # @param options [Hash] the path description
       # @option options [String,Proc,Class,Object#call] :to the endpoint
-      # @option options [String] :prefix an optional path prefix
+      # @option options [String] :namespace an optional namespace
       #
       # @since 0.1.0
       #
       # @return [Object]
       def find(options)
-        if prefix = options[:prefix]
-          prefix.join(options[:to])
-        else
-          options[:to]
-        end
+        options[:to]
       end
 
       protected

data/lib/lotus/routing/http_router.rb

@@ -2,6 +2,7 @@ require 'http_router'
 require 'lotus/utils/io'
 require 'lotus/routing/endpoint_resolver'
 require 'lotus/routing/route'
+require 'lotus/routing/parsers'
 
 Lotus::Utils::IO.silence_warnings do
   HttpRouter::Route::VALID_HTTP_VERBS = %w{GET POST PUT PATCH DELETE HEAD OPTIONS TRACE}
@@ -14,7 +15,7 @@ module Lotus
     # given arguments.
     #
     # @since 0.1.0
-    class InvalidRouteException < ::Exception
+    class InvalidRouteException < ::StandardError
     end
 
     # HTTP router
@@ -41,6 +42,7 @@ module Lotus
         @default_port   = options[:port]     if options[:port]
         @route_class    = options[:route]    || Routing::Route
         @resolver       = options[:resolver] || Routing::EndpointResolver.new(options)
+        @parsers        = Routing::Parsers.new(options[:parsers])
       end
 
       # Separator between controller and action name.
@@ -105,6 +107,11 @@ module Lotus
         )
       end
 
+      # @api private
+      def raw_call(env, &blk)
+        super(@parsers.call(env))
+      end
+
       # @api private
       def reset!
         uncompile

data/lib/lotus/routing/namespace.rb

@@ -60,19 +60,19 @@ module Lotus
       # @api private
       # @since 0.1.0
       def resource(name, options = {})
-        super name, options.merge(prefix: @name)
+        super name, options.merge(namespace: @name.relative_join(options[:namespace]))
       end
 
       # @api private
       # @since 0.1.0
       def resources(name, options = {})
-        super name, options.merge(prefix: @name)
+        super name, options.merge(namespace: @name.relative_join(options[:namespace]))
       end
 
       # @api private
       # @since 0.1.0
       def redirect(path, options = {}, &endpoint)
-        super(@name.join(path), options.merge(prefix: @name), &endpoint)
+        super(@name.join(path), options.merge(to: @name.join(options[:to])), &endpoint)
       end
 
       # Supports nested namespaces

data/lib/lotus/routing/parsers.rb

@@ -0,0 +1,71 @@
+require 'lotus/routing/parsing/parser'
+
+module Lotus
+  module Routing
+    class Parsers
+      CONTENT_TYPE       = 'CONTENT_TYPE'.freeze
+      MEDIA_TYPE_MATCHER = /\s*[;,]\s*/.freeze
+
+      RACK_INPUT    = 'rack.input'.freeze
+      ROUTER_PARAMS = 'router.params'.freeze
+
+      def initialize(parsers)
+        @parsers = prepare(parsers)
+        _redefine_call
+      end
+
+      def call(env)
+        env
+      end
+
+      private
+      def prepare(args)
+        result  = Hash.new
+        args    = Array(args)
+        return result if args.empty?
+
+        args.each do |arg|
+          parser = Parsing::Parser.for(arg)
+
+          parser.mime_types.each do |mime|
+            result[mime] = parser
+          end
+        end
+
+        result.default = Parsing::Parser.new
+        result
+      end
+
+      def _redefine_call
+        return if @parsers.empty?
+
+        define_singleton_method :call do |env|
+          body = env[RACK_INPUT].read
+          return env if body.empty?
+
+          env[RACK_INPUT].rewind    # somebody might try to read this stream
+          env[ROUTER_PARAMS] ||= {} # prepare params
+
+          env[ROUTER_PARAMS].merge!(
+            @parsers[
+              media_type(env)
+            ].parse(body)
+          )
+
+          env
+        end
+      end
+
+      def media_type(env)
+        if ct = content_type(env)
+          ct.split(MEDIA_TYPE_MATCHER, 2).first.downcase
+        end
+      end
+
+      def content_type(env)
+        content_type = env[CONTENT_TYPE]
+        content_type.nil? || content_type.empty? ? nil : content_type
+      end
+    end
+  end
+end

data/lib/lotus/routing/parsing/json_parser.rb

@@ -0,0 +1,17 @@
+require 'json'
+
+module Lotus
+  module Routing
+    module Parsing
+      class JsonParser < Parser
+        def mime_types
+          ['application/json']
+        end
+
+        def parse(body)
+          JSON.parse(body)
+        end
+      end
+    end
+  end
+end

data/lib/lotus/routing/parsing/parser.rb

@@ -0,0 +1,43 @@
+require 'lotus/utils/class'
+require 'lotus/utils/string'
+
+module Lotus
+  module Routing
+    module Parsing
+      class UnknownParserError < ::StandardError
+        def initialize(parser)
+          super("Unknown Parser: `#{ parser }'")
+        end
+      end
+
+      class Parser
+        def self.for(parser)
+          case parser
+          when String, Symbol
+            require_parser(parser)
+          else
+            parser
+          end
+        end
+
+        def mime_types
+          raise NotImplementedError
+        end
+
+        def parse(body)
+          Hash.new
+        end
+
+        private
+        def self.require_parser(parser)
+          require "lotus/routing/parsing/#{ parser }_parser"
+
+          parser = Utils::String.new(parser).classify
+          Utils::Class.load!("Lotus::Routing::Parsing::#{ parser }Parser").new
+        rescue LoadError, NameError
+          raise UnknownParserError.new(parser)
+        end
+      end
+    end
+  end
+end

data/lib/lotus/routing/resource.rb

@@ -54,19 +54,19 @@ module Lotus
 
       private
       def generate(&blk)
+        instance_eval(&blk) if block_given?
+
         @options.actions.each do |action|
           self.class.action.generate(@router, action, @options)
         end
-
-        instance_eval(&blk) if block_given?
       end
 
       def member(&blk)
-        self.class.member.new(@router, @options.merge(prefix: @name), &blk)
+        self.class.member.new(@router, @options, &blk)
       end
 
       def collection(&blk)
-        self.class.collection.new(@router, @options.merge(prefix: @name), &blk)
+        self.class.collection.new(@router, @options, &blk)
       end
     end
   end