signpost 0.1.0

data/lib/signpost/builder/namespace.rb

@@ -0,0 +1,13 @@
+class Signpost
+  class Builder
+    class Namespace < Nested
+
+    private
+
+      def root_name
+        :root
+      end
+
+    end
+  end
+end

data/lib/signpost/builder/nested.rb

@@ -0,0 +1,34 @@
+class Signpost
+  class Builder
+    class Nested < self
+      attr_reader :builders
+
+      ##
+      # Add middleware to routes
+      #
+      # Params:
+      # - middleware {String|Class} middleware or middleware name
+      # - *args                     middleware arguments which will be used for instantiating
+      #
+      # Example:
+      #
+      #     use Rack::Errors
+      #     use AuthMiddleware, 'admin', 'seCrEt'
+      #
+      def use(middleware, *args, &block)
+        @options[:middlewares] << Middleware.new(middleware, args, block)
+      end
+
+      def build
+        Router.new(@builders, @options)
+      end
+
+    private
+
+      def root_name
+        nil
+      end
+
+    end
+  end
+end

data/lib/signpost/endpoint/action.rb

@@ -0,0 +1,54 @@
+class Signpost
+  module Endpoint
+    class Action
+
+      class Context
+
+        attr_reader :params, :env, :headers
+
+        def body(text)
+          @body = [text]
+        end
+
+        def status(code)
+          @status = code.to_i
+        end
+
+        def expand(path, data={})
+          @router.expand(path, data)
+        end
+
+        def result
+          [@status, @headers, @body]
+        end
+
+      private
+
+        def initialize(block, router, env, params)
+          @router = router
+          @env    = env
+          @params = params
+
+          @status  = 200
+          @headers = {}
+          @body    = []
+
+          instance_eval(&block)
+        end
+      end
+
+      def call(env)
+        Context.new(@block, @router, env, env[@params_key]).result
+      end
+
+    private
+
+      def initialize(block, router)
+        @block      = block
+        @router     = router
+        @params_key = router.params_key
+      end
+
+    end
+  end
+end

data/lib/signpost/endpoint/builder.rb

@@ -0,0 +1,22 @@
+class Signpost
+  module Endpoint
+    class Builder
+
+      ##
+      # Build middleware stack
+      #
+      # Returns: {Proc}
+      #
+      def build
+        @middlewares.reverse_each.inject(@endpoint) { |app, m| m.middleware.new(app, *m.args, &m.block) }
+      end
+
+    private
+
+      def initialize(endpoint, middlewares)
+        @endpoint    = endpoint
+        @middlewares = middlewares
+      end
+    end
+  end
+end

data/lib/signpost/endpoint/dynamic.rb

@@ -0,0 +1,24 @@
+class Signpost
+  module Endpoint
+    class Dynamic
+      def call(env)
+        controller, action = env[@params_key].values_at('controller', 'action')
+
+        resolver = Resolver.new({
+          controller: @spec[:controller] || controller,
+          action: @spec[:action] || action
+        }, @options).resolve
+
+        resolver.endpoint.call(env)
+      end
+
+    private
+
+      def initialize(options, spec={})
+        @options = options
+        @spec = spec
+        @params_key = options[:params_key]
+      end
+    end
+  end
+end

data/lib/signpost/endpoint/redirect.rb

@@ -0,0 +1,65 @@
+class Signpost
+  module Endpoint
+    class Redirect
+
+      class Context
+
+        attr_reader :params, :env
+
+        def expand(path, data={})
+          @router.expand(path, data)
+        end
+
+      private
+
+        def initialize(router, env, params)
+          @router = router
+          @env    = env
+          @params = params
+        end
+      end
+
+      attr_reader :status
+
+      CODES = {
+        permanent: 301,
+        temporary: 303
+      }.freeze
+
+      def call(env)
+        [status, headers(env), body]
+      end
+
+    private
+
+      def initialize(to, router, status=303)
+        @to     = to
+        @status = status.is_a?(Fixnum) ? status : CODES[status.to_sym]
+        @router = router
+        @params_key = router.params_key
+      end
+
+      def headers(env)
+        { 'Location' => to(env) }
+      end
+
+      def to(env)
+        params = env[@params_key]
+
+        case @to
+          when Proc
+            Context.new(@router, env, params).instance_exec(&@to)
+          when Symbol
+            params = @router.expand(@to, params)
+          else
+            @to.expand(params)
+        end
+      end
+
+      def body
+        []
+      end
+
+    end
+  end
+end

data/lib/signpost/endpoint/resolver.rb

@@ -0,0 +1,144 @@
+class Signpost
+  module Endpoint
+    UnresolvedError = Class.new(StandardError)
+
+    class Resolver
+      ##
+      # Class: result of resolving
+      #
+      # Here is `#endpoint` is an endpoint class and `#params` is a hash
+      # with controller and action names
+      #
+      Result = Struct.new(:endpoint, :params)
+
+      ##
+      # Resolve endpoint and params
+      #
+      # Returns: {Signpost::Endpoint::Resolver::Result}
+      #
+      def resolve
+        case spec
+          when Hash
+            params = resolve_hash(spec[:controller], spec[:action])
+          when String
+            params = resolve_string
+          else
+            endpoint = spec
+            params   = {}
+        end
+
+        unless endpoint
+          if params[:action].kind_of?(Class)
+            endpoint = params[:action]
+          elsif params[:controller]
+            endpoint = params[:controller]
+          else
+            if params[:action]
+              # Try namespace as endpoint
+              # this must be refactored in new year
+              if options[:namespace]
+                specc = { action: params[:action], controller: options[:namespace] }
+                opts = options.dup
+                opts.delete(:namespace)
+
+                result = self.class.new(specc, opts).resolve
+
+                return result if result
+              end
+            end
+
+            endpoint = Dynamic.new(@options, params)
+          end
+        end
+
+        Result.new(endpoint, params)
+      end
+
+    private
+
+      attr_reader :spec, :options
+
+      ##
+      # Constructor:
+      #
+      # Params:
+      # - spec {String|Hash|Proc}
+      # - options {Hash}
+      #   - :namespace         {String} namespace
+      #   - :controller_format {String} string with controller name pattern
+      #
+      def initialize(spec, options={})
+        @spec = spec
+        @options = options
+      end
+
+      ##
+      # Private: resolve controller and action
+      #
+      # Params:
+      # - controller {String|Class} controller name or constant
+      # - action     {String}       action name
+      #
+      # Returns: {Hash}
+      # - :controller {Module|Class} controller constant
+      # - :action     {String|Class} action name or constant
+      #
+      def resolve_hash(controller, action)
+        if controller.kind_of?(Module)
+          if action
+            pattern = "#{controller}::#{Inflecto.camelize(action)}"
+            action = Inflecto.constantize(pattern) if Object.const_defined?(pattern)
+          end
+        elsif controller
+          name = controller_name(controller)
+
+          return resolve_hash(Inflecto.constantize(Inflecto.camelize(name)), action)
+        end
+
+        { controller: controller, action: action }
+      rescue NameError
+        raise(UnresolvedError)
+      end
+
+      ##
+      # Private: resolve controller and action from string
+      #
+      # Returns: {Hash}
+      # - :controller {Module|Class} controller constant
+      # - :action     {String|Class} action name or constant
+      #
+      def resolve_string
+        controller, action = spec.split('#')
+
+        resolve_hash(controller, action)
+      end
+
+      ##
+      # Private: get controller name from pattern and namespace
+      #
+      # Params:
+      # - controller {String} raw controller name
+      #
+      # Returns: {String} namespaced controller name from pattern
+      #
+      def controller_name(controller)
+        names = {
+          name:          controller,
+          plural_name:   Inflecto.pluralize(controller),
+          singular_name: Inflecto.singularize(controller)
+        }
+
+        pattern = options[:controller_format] || '%{name}'
+
+        name = pattern % names
+
+        if options[:namespace]
+          namespace = Array(options[:namespace]).join('/')
+          name = "#{Inflecto.camelize(namespace)}::#{Inflecto.camelize(name)}"
+        end
+
+        name
+      end
+    end
+  end
+end

data/lib/signpost/middleware.rb

@@ -0,0 +1,17 @@
+class Signpost
+  class Middleware
+    attr_reader :middleware
+
+    attr_reader :args
+
+    attr_reader :block
+
+  private
+
+    def initialize(middleware, args, block)
+      @middleware = middleware
+      @args  = args
+      @block = block
+    end
+  end
+end

data/lib/signpost/route/nested.rb

@@ -0,0 +1,20 @@
+class Signpost
+  class Route
+    class Nested
+      attr_reader :subpath
+
+      def match(path, env)
+        return unless path.start_with?(subpath)
+
+        @router.call(env)
+      end
+
+    private
+
+      def initialize(subpath, router)
+        @subpath = subpath
+        @router  = router
+      end
+    end
+  end
+end

data/lib/signpost/route/simple.rb

@@ -0,0 +1,89 @@
+class Signpost
+  class Route
+    class Simple
+      ##
+      # Route matcher/expander
+      #
+      # Returns: {Mustermann}
+      #
+      attr_reader :matcher
+
+      ##
+      # Rack-compatible endpoint
+      #
+      # Returns: {Proc|Object}
+      #
+      attr_reader :endpoint
+
+      ##
+      # Specific route params
+      #
+      # Returns: {Hash}
+      #
+      attr_reader :params
+
+      ##
+      # Environment constraints
+      #
+      # Returns: {Array}
+      #
+      attr_reader :constraints
+
+      ##
+      # Route name
+      #
+      # Returns: {Symbol}
+      #
+      attr_reader :name
+
+      ##
+      # Match path and return matched data or nil if path doesn't match
+      #
+      # Params:
+      # - path {String} uri path
+      #
+      # Example:
+      #
+      #     route.match('/users/42') #=> { 'controller' => 'Users', 'action' => 'Show', 'id' => '42' }
+      #     route.match('/foo/bar')  #=> nil
+      #
+      # Returns: {Hash|NilClass}
+      #
+      def match(path, env)
+        return unless data = matcher.match(path)
+
+        return unless constraints.all? { |c| c.call(env) }
+
+        params.merge(Hash[data.names.zip(data.captures)])
+      end
+
+      ##
+      # Generate a string from path pattern
+      #
+      # Params:
+      # - data {Hash} key-values for expanding
+      #
+      # Example:
+      #
+      #     route.expand({ id: 42 }) #=> '/users/42'
+      #
+      # Returns: {String}
+      #
+      def expand(data={})
+        matcher.expand(:append, data)
+      end
+
+    private
+
+      def initialize(matcher, endpoint, params={}, constraints=[], name=nil)
+        @matcher     = matcher
+        @endpoint    = endpoint
+        @params      = params.each_with_object({}) { |(k, v), h| h[k.to_s] = v }.freeze
+        @constraints = constraints
+        @name        = name ? name.to_sym : nil
+
+        freeze
+      end
+    end
+  end
+end