josh-rack-mount 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Joshua Peek
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,28 @@
+= Rack::Mount
+
+A stackable dynamic tree based Rack router.
+
+Rack::Mount supports Rack's Cascade style of trying several routes until it finds one that is not a 404. This allows multiple routes to be nested or stacked on top of each other. Since the application endpoint can trigger the router to continue matching, middleware can be used to add arbitrary conditions to any route. This allows you to route based on other request attributes, session information, or even data dynamically pulled pulled from a database.
+
+=== Usage
+
+Rack::Mount provides a plugin API to build custom DSLs on top of.
+
+The API is extremely minimal and only 3 methods are exposed as the public API.
+
+<tt>Rack::Mount::RouteSet#add_route</tt>:: builder method for adding routes to the set
+<tt>Rack::Mount::RouteSet#call</tt>:: Rack compatible recognition and dispatching method
+<tt>Rack::Mount::RouteSet#url_for</tt>:: generatess path from identifiers or significant keys
+
+=== Example
+
+  require 'rack/mount'
+  Routes = Rack::Mount::RouteSet.new do |set|
+    # add_route takes a rack application and conditions to match with
+    # conditions may be strings or regexps
+    # See Rack::Mount::RouteSet#add_route for more options.
+    set.add_route FooApp, :method => 'get' :path => %{/foo}
+  end
+
+  # The route set itself is a simple rack app you mount
+  run Routes

data/lib/rack/mount.rb

@@ -0,0 +1,18 @@
+require 'rack/utils'
+require 'rack/mount/exceptions'
+
+module Rack #:nodoc:
+  module Mount #:nodoc:
+    autoload :Const, 'rack/mount/const'
+    autoload :Generation, 'rack/mount/generation'
+    autoload :NestedSet, 'rack/mount/nested_set'
+    autoload :NestedSetExt, 'rack/mount/nested_set_ext'
+    autoload :PathPrefix, 'rack/mount/path_prefix'
+    autoload :Recognition, 'rack/mount/recognition'
+    autoload :RegexpWithNamedGroups, 'rack/mount/regexp_with_named_groups'
+    autoload :Request, 'rack/mount/request'
+    autoload :Route, 'rack/mount/route'
+    autoload :RouteSet, 'rack/mount/route_set'
+    autoload :Utils, 'rack/mount/utils'
+  end
+end

data/lib/rack/mount/const.rb

@@ -0,0 +1,39 @@
+module Rack
+  module Mount
+    module Const #:nodoc:
+      RACK_ROUTING_ARGS = 'rack.routing_args'.freeze
+      RACK_MOUNT_DEBUG  = 'RACKMOUNT_DEBUG'.freeze
+
+      begin
+        eval('/(?<foo>.*)/').named_captures
+        SUPPORTS_NAMED_CAPTURES = true
+        REGEXP_NAMED_CAPTURE = '(?<%s>%s)'.freeze
+      rescue SyntaxError, NoMethodError
+        SUPPORTS_NAMED_CAPTURES = false
+        REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze
+      end
+
+      EOS_KEY = '$'.freeze
+
+      CONTENT_TYPE    = 'Content-Type'.freeze
+      DELETE          = 'PUT'.freeze
+      EMPTY_STRING    = ''.freeze
+      GET             = 'GET'.freeze
+      HEAD            = 'HEAD'.freeze
+      PATH_INFO       = 'PATH_INFO'.freeze
+      POST            = 'POST'.freeze
+      PUT             = 'PUT'.freeze
+      REQUEST_METHOD  = 'REQUEST_METHOD'.freeze
+      SLASH           = '/'.freeze
+      TEXT_SLASH_HTML = 'text/html'.freeze
+
+      DEFAULT_CONTENT_TYPE_HEADERS = {CONTENT_TYPE => TEXT_SLASH_HTML}.freeze
+      HTTP_METHODS = [GET, HEAD, POST, PUT, DELETE].freeze
+
+      OK = 'OK'.freeze
+      NOT_FOUND = 'Not Found'.freeze
+      OK_RESPONSE = [200, DEFAULT_CONTENT_TYPE_HEADERS, [OK].freeze].freeze
+      NOT_FOUND_RESPONSE = [404, DEFAULT_CONTENT_TYPE_HEADERS, [NOT_FOUND].freeze].freeze
+    end
+  end
+end

data/lib/rack/mount/exceptions.rb

@@ -0,0 +1,5 @@
+module Rack
+  module Mount
+    class RoutingError < StandardError; end
+  end
+end

data/lib/rack/mount/generation.rb

@@ -0,0 +1,9 @@
+module Rack
+  module Mount
+    module Generation #:nodoc:
+      autoload :Optimizations, 'rack/mount/generation/optimizations'
+      autoload :Route, 'rack/mount/generation/route'
+      autoload :RouteSet, 'rack/mount/generation/route_set'
+    end
+  end
+end

data/lib/rack/mount/generation/optimizations.rb

@@ -0,0 +1,83 @@
+module Rack
+  module Mount
+    module Generation
+      module Optimizations #:nodoc:
+        def freeze
+          optimize_call! unless frozen?
+          super
+        end
+
+        if ENV[Const::RACK_MOUNT_DEBUG]
+          def instance_eval(*args)
+            puts
+            puts "#{args[1]}##{args[2]}"
+            puts args[0]
+            puts
+
+            super
+          end
+        end
+
+        private
+          def optimize_call!
+            @recognition_graph.lists.each do |list|
+              body = (0...list.length).zip(list).map { |i, route|
+                assign_index_params = assign_index_params(route)
+                <<-EOS
+                  if #{route.method ? "method == #{route.method.inspect} && " : ''}path =~ #{route.path.inspect}
+                    route = self[#{i}]
+                    #{if assign_index_params.any?
+                      'routing_args, param_matches = route.defaults.dup, $~.captures'
+                    else
+                      'routing_args = route.defaults.dup'
+                    end}
+                    #{assign_index_params.join("\n                  ")}
+                    env[Const::RACK_ROUTING_ARGS] = routing_args
+                    result = route.app.call(env)
+                    return result unless result[0] == #{@catch}
+                  end
+                EOS
+              }.join
+
+              method = <<-EOS, __FILE__, __LINE__
+                def optimized_each(env)
+                  method = env[Const::REQUEST_METHOD]
+                  path = env[Const::PATH_INFO]
+#{body}
+                  nil
+                end
+              EOS
+
+              puts method if ENV[Const::RACK_MOUNT_DEBUG]
+              list.instance_eval(*method)
+            end
+
+            instance_eval(<<-EOS, __FILE__, __LINE__)
+              def call(env)
+                req = Request.new(env)
+                keys = [#{convert_keys_to_method_calls}]
+                @recognition_graph[*keys].optimized_each(env) || @throw
+              end
+            EOS
+          end
+
+          def convert_keys_to_method_calls
+            @recognition_keys.map { |key|
+              if key.is_a?(Array)
+                key = key.dup
+                "req.#{key.shift}(#{key.join(',')})"
+              else
+                "req.#{key}"
+              end
+            }.join(', ')
+          end
+
+          def assign_index_params(route)
+            route.instance_variable_get("@named_captures").map { |k, index|
+              "routing_args[#{k.inspect}] = param_matches[#{index}] if param_matches[#{index}]"
+            }
+          end
+      end
+    end
+  end
+end

data/lib/rack/mount/generation/route.rb

@@ -0,0 +1,108 @@
+module Rack
+  module Mount
+    module Generation
+      module Route #:nodoc:
+        class DynamicSegment #:nodoc:
+          attr_reader :name, :requirement
+
+          def initialize(name, requirement)
+            @name, @requirement = name.to_sym, requirement
+          end
+
+          def ==(obj)
+            @name == obj.name && @requirement == obj.requirement
+          end
+        end
+
+        def initialize(*args)
+          super
+
+          @segments = segments(@path).freeze
+          @required_params = @segments.find_all { |s|
+            s.is_a?(DynamicSegment)
+          }.map { |s| s.name }.freeze
+        end
+
+        def url_for(params = {})
+          params = (params || {}).dup
+
+          return nil if @segments.empty?
+          return nil unless @required_params.all? { |p| params.include?(p) }
+
+          path = generate_from_segments(@segments, params, @defaults)
+
+          @defaults.each do |key, value|
+            params.delete(key)
+          end
+
+          if params.any?
+            path << "?#{Rack::Utils.build_query(params)}"
+          end
+
+          path
+        end
+
+        private
+          # Segment data structure used for generations
+          # => ['/people', ['.', :format]]
+          def segments(regexp)
+            parse_segments(Utils.extract_regexp_parts(regexp))
+          rescue ArgumentError
+            []
+          end
+
+          def parse_segments(segments)
+            s = []
+            segments.each do |part|
+              if part.is_a?(Utils::Capture)
+                if part.named?
+                  source = part.map { |p| p.is_a?(Array) ? "(#{p.join})?" : p }.join
+                  requirement = Regexp.compile(source)
+                  s << DynamicSegment.new(part.name, requirement)
+                else
+                  s << parse_segments(part)
+                end
+              else
+                source = part.gsub('\\.', '.').gsub('\\/', '/')
+                if Regexp.compile("^(#{part})$") =~ source
+                  s << source
+                else
+                  raise ArgumentError, "failed to parse #{part.inspect}"
+                end
+              end
+            end
+            s
+          end
+
+          def generate_from_segments(segments, params, defaults, optional = false)
+            if optional
+              return Const::EMPTY_STRING if segments.all? { |s| s.is_a?(String) }
+              return Const::EMPTY_STRING if segments.flatten.all? { |s|
+                if s.is_a?(DynamicSegment) && params[s.name]
+                  params[s.name].to_s !~ s.requirement
+                else
+                  true
+                end
+              }
+            end
+
+            generated = segments.map do |segment|
+              case segment
+              when String
+                segment
+              when DynamicSegment
+                params[segment.name] || defaults[segment.name]
+              when Array
+                generate_from_segments(segment, params, defaults, true) || Const::EMPTY_STRING
+              end
+            end
+
+            # Delete any used items from the params
+            segments.each { |s| params.delete(s.name) if s.is_a?(DynamicSegment) }
+
+            generated.join
+          end
+      end
+    end
+  end
+end

data/lib/rack/mount/generation/route_set.rb

@@ -0,0 +1,60 @@
+module Rack
+  module Mount
+    module Generation
+      module RouteSet
+        DEFAULT_KEYS = [] # [:controller, :action].freeze
+
+        def initialize(options = {})
+          @named_routes = {}
+          @generation_keys = DEFAULT_KEYS
+          @generation_graph = NestedSet.new
+          super
+        end
+
+        def add_route(*args)
+          route = super
+
+          @named_routes[route.name] = route if route.name
+
+          keys = @generation_keys.map { |key| route.defaults[key] }
+          @generation_graph[*keys] = route
+
+          route
+        end
+
+        def url_for(*args)
+          params = args.last.is_a?(Hash) ? args.pop : {}
+          named_route = args.shift
+          route = nil
+
+          if named_route
+            unless route = @named_routes[named_route.to_sym]
+              raise RoutingError, "#{named_route} failed to generate from #{params.inspect}"
+            end
+          else
+            keys = @generation_keys.map { |key| params[key] }
+            @generation_graph[*keys].each do |r|
+              if r.defaults.all? { |k, v| params[k] == v }
+                route = r
+                break
+              end
+            end
+
+            unless route
+              raise RoutingError, "No route matches #{params.inspect}"
+            end
+          end
+
+          route.url_for(params)
+        end
+
+        def freeze
+          @named_routes.freeze
+          @generation_keys.freeze
+          @generation_graph.freeze
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rack/mount/mappers/merb.rb

@@ -0,0 +1,143 @@
+require 'active_support/inflector'
+require 'merb-core/dispatch/router'
+require 'rack/request'
+
+module Rack
+  module Mount
+    class RouteSet
+      def prepare(*args, &block)
+        Mappers::Merb.new(self).prepare(*args, &block)
+        freeze
+      end
+    end
+
+    module Mappers
+      class Merb
+        class ::Merb::Router::Behavior
+          def to_route
+            raise Error, 'The route has already been committed.' if @route
+
+            controller = @params[:controller]
+
+            if prefixes = @options[:controller_prefix]
+              controller ||= ':controller'
+
+              prefixes.reverse_each do |prefix|
+                break if controller =~ %r{^/(.*)} && controller = $1
+                controller = "#{prefix}/#{controller}"
+              end
+            end
+
+            @params.merge!(:controller => controller.to_s.gsub(%r{^/}, '')) if controller
+
+            identifiers = @identifiers.sort { |(first,_),(sec,_)| first <=> sec || 1 }
+
+            Thread.current[:merb_routes] << [
+              @conditions.dup,
+              @params,
+              @blocks,
+              { :defaults => @defaults.dup, :identifiers => identifiers }
+            ]
+
+            self
+          end
+        end
+
+        class DeferredProc
+          def initialize(app, deferred_procs)
+            @app, @proc = app, deferred_procs.cache
+          end
+
+          def call(env)
+            # TODO: Change this to a Merb request
+            request = Rack::Request.new(env)
+            params  = env[Const::RACK_ROUTING_ARGS]
+            result  = @proc.call(request, params)
+
+            if result
+              @app.call(env)
+            else
+              Const::NOT_FOUND_RESPONSE
+            end
+          end
+        end
+
+        class RequestConditions
+          def initialize(app, conditions)
+            @app, @conditions = app, conditions
+          end
+
+          def call(env)
+            # TODO: Change this to a Merb request
+            request = Rack::Request.new(env)
+
+            @conditions.each do |method, expected|
+              unless request.send(method) == expected
+                return Const::NOT_FOUND_RESPONSE
+              end
+            end
+
+            @app.call(env)
+          end
+        end
+
+        DynamicController = lambda { |env|
+          app = ActiveSupport::Inflector.camelize("#{env[Const::RACK_ROUTING_ARGS][:controller]}Controller")
+          app = ActiveSupport::Inflector.constantize(app)
+          app.call(env)
+        }
+
+        attr_accessor :root_behavior
+
+        def initialize(set)
+          @set = set
+          @root_behavior = ::Merb::Router::Behavior.new.defaults(:action => 'index')
+        end
+
+        def prepare(first = [], last = [], &block)
+          Thread.current[:merb_routes] = []
+          begin
+            root_behavior._with_proxy(&block)
+            routes = Thread.current[:merb_routes]
+            routes.each { |route| add_route(*route) }
+            self
+          ensure
+            Thread.current[:merb_routes] = nil
+          end
+        end
+
+        def add_route(conditions, params, deferred_procs, options = {})
+          new_conditions = {}
+          new_conditions[:path] = conditions.delete(:path)[0]
+          new_conditions[:method] = conditions.delete(:method)
+
+          requirements = {}
+          conditions.each do |k, v|
+            if v.is_a?(Regexp)
+              requirements[k.to_sym] = conditions.delete(k)
+            end
+          end
+
+          if new_conditions[:path].is_a?(String)
+            new_conditions[:path] = Utils.convert_segment_string_to_regexp(
+              new_conditions[:path], requirements, %w( / . ? ))
+          end
+
+          app = params.has_key?(:controller) ?
+            ActiveSupport::Inflector.constantize(ActiveSupport::Inflector.camelize("#{params[:controller]}Controller")) :
+            DynamicController
+
+          if deferred_procs.any?
+            app = DeferredProc.new(app, deferred_procs.first)
+          end
+
+          if conditions.any?
+            app = RequestConditions.new(app, conditions)
+          end
+
+          @set.add_route(app, new_conditions, params)
+        end
+      end
+    end
+  end
+end