josh-rack-mount 0.0.1

data/lib/rack/mount/path_prefix.rb

@@ -0,0 +1,20 @@
+module Rack
+  module Mount
+    class PathPrefix #:nodoc:
+      def initialize(app, path_prefix = nil)
+        @app, @path_prefix = app, /^#{Regexp.escape(path_prefix)}/.freeze
+      end
+
+      def call(env)
+        path_info = Const::PATH_INFO
+
+        if env[path_info] =~ @path_prefix
+          env[path_info].sub!(@path_prefix, Const::EMPTY_STRING)
+          env[path_info] = Const::SLASH if env[path_info].empty?
+        end
+
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rack/mount/recognition.rb

@@ -0,0 +1,8 @@
+module Rack
+  module Mount
+    module Recognition #:nodoc:
+      autoload :Route, 'rack/mount/recognition/route'
+      autoload :RouteSet, 'rack/mount/recognition/route_set'
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require 'strscan'
+
+module Rack
+  module Mount
+    module Recognition
+      module Route #:nodoc:
+        def initialize(*args)
+          super
+
+          @path_keys      = path_keys(@path, %w( / ))
+          @named_captures = named_captures(@path)
+        end
+
+        def call(env)
+          method = env[Const::REQUEST_METHOD]
+          path = env[Const::PATH_INFO]
+
+          if (@method.nil? || method == @method) && path =~ @path
+            routing_args, param_matches = @defaults.dup, $~.captures
+            @named_captures.each { |k, i|
+              if v = param_matches[i]
+                routing_args[k] = v
+              end
+            }
+            env[Const::RACK_ROUTING_ARGS] = routing_args
+            @app.call(env)
+          else
+            @throw
+          end
+        end
+
+        def path_keys_at(index)
+          @path_keys[index]
+        end
+
+        private
+          # Keys for inserting into NestedSet
+          # #=> ['people', /[0-9]+/, 'edit']
+          def path_keys(regexp, separators)
+            escaped_separators = separators.map { |s| Regexp.escape(s) }
+            separators = Regexp.compile(escaped_separators.join('|'))
+            segments = []
+
+            begin
+              Utils.extract_regexp_parts(regexp).each do |part|
+                raise ArgumentError if part.is_a?(Utils::Capture)
+
+                part = part.dup
+                part.gsub!(/\\\//, '/')
+                part.gsub!(/^\//, '')
+
+                scanner = StringScanner.new(part)
+
+                until scanner.eos?
+                  unless s = scanner.scan_until(separators)
+                    s = scanner.rest
+                    scanner.terminate
+                  end
+
+                  s.gsub!(/\/$/, '')
+                  segments << (clean_regexp?(s) ? s : nil)
+                end
+              end
+
+              segments << Const::EOS_KEY
+            rescue ArgumentError
+              # generation failed somewhere, but lets take what we can get
+            end
+
+            # Pop off trailing nils
+            while segments.length > 0 && segments.last.nil?
+              segments.pop
+            end
+
+            segments.freeze
+          end
+
+          # Maps named captures to their capture index
+          # #=> { :controller => 0, :action => 1, :id => 2, :format => 4 }
+          def named_captures(regexp)
+            named_captures = {}
+            regexp.named_captures.each { |k, v|
+              named_captures[k.to_sym] = v.last - 1
+            }
+            named_captures.freeze
+          end
+
+          def clean_regexp?(source)
+            source =~ /^\w+$/
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Rack
+  module Mount
+    module Recognition
+      module RouteSet
+        DEFAULT_KEYS = [:method, [:path_keys_at, 0].freeze].freeze
+        DEFAULT_CATCH_STATUS = 404
+
+        def initialize(options = {})
+          @catch = options.delete(:catch) || DEFAULT_CATCH_STATUS
+          @throw = Const::NOT_FOUND_RESPONSE.dup
+          @throw[0] = @catch
+          @throw.freeze
+
+          @recognition_keys = options.delete(:keys) || DEFAULT_KEYS
+          @recognition_keys.freeze
+
+          @recognition_graph = NestedSet.new
+          super
+        end
+
+        def add_route(*args)
+          route = super
+          route.throw = @throw
+
+          keys = @recognition_keys.map { |key| route.send(*key) }
+          @recognition_graph[*keys] = route
+
+          route
+        end
+
+        def call(env)
+          raise 'route set not finalized' unless frozen?
+
+          req = Request.new(env)
+          keys = @recognition_keys.map { |key| req.send(*key) }
+          @recognition_graph[*keys].each do |route|
+            result = route.call(env)
+            return result unless result[0] == @catch
+          end
+          @throw
+        end
+
+        def freeze
+          @recognition_graph.freeze
+          super
+        end
+
+        def height #:nodoc:
+          @recognition_graph.height
+        end
+      end
+    end
+  end
+end

data/lib/rack/mount/regexp_with_named_groups.rb

@@ -0,0 +1,38 @@
+require 'strscan'
+
+module Rack
+  module Mount
+    unless Const::SUPPORTS_NAMED_CAPTURES
+      class RegexpWithNamedGroups < Regexp #:nodoc:
+        def self.new(regexp)
+          if regexp.is_a?(RegexpWithNamedGroups)
+            regexp
+          else
+            super
+          end
+        end
+
+        attr_reader :named_captures, :names
+
+        def initialize(regexp)
+          names = nil if names && !names.any?
+          regexp, @names = Utils.extract_named_captures(regexp)
+
+          @names = nil unless @names.any?
+
+          if @names
+            @named_captures = {}
+            @names.each_with_index { |n, i| @named_captures[n] = [i+1] if n }
+          end
+
+          (@named_captures ||= {}).freeze
+          (@names ||= []).freeze
+
+          super(regexp)
+        end
+      end
+    else
+      RegexpWithNamedGroups = Regexp
+    end
+  end
+end

data/lib/rack/mount/request.rb

@@ -0,0 +1,30 @@
+module Rack
+  module Mount
+    class Request #:nodoc:
+      def initialize(env)
+        @env = env
+      end
+
+      def method
+        @method ||= @env[Const::REQUEST_METHOD] || Const::GET
+      end
+
+      def path
+        @path ||= @env[Const::PATH_INFO] || Const::SLASH
+      end
+
+      def path_keys_at(index)
+        path_keys[index]
+      end
+
+      def path_keys
+        @path_keys ||= begin
+          keys = path.split(%r{/|\.|\?})
+          keys.shift
+          keys << Const::EOS_KEY
+          keys
+        end
+      end
+    end
+  end
+end

data/lib/rack/mount/route.rb

@@ -0,0 +1,63 @@
+module Rack
+  module Mount
+    class Route #:nodoc:
+      module Base #:nodoc:
+        # TODO: Support any method on Request object
+        VALID_CONDITIONS = [:method, :path].freeze
+
+        attr_reader :app, :conditions, :defaults, :name
+        attr_reader :path, :method
+        attr_writer :throw
+
+        def initialize(app, conditions, defaults, name)
+          @app = app
+          validate_app!
+
+          @throw = Const::NOT_FOUND_RESPONSE
+
+          @name = name.to_sym if name
+          @defaults = (defaults || {}).freeze
+
+          @conditions = conditions
+          validate_conditions!
+
+          method = @conditions.delete(:method)
+          @method = method.to_s.upcase if method
+
+          path = @conditions.delete(:path)
+          if path.is_a?(Regexp)
+            @path = RegexpWithNamedGroups.new(path)
+          elsif path.is_a?(String)
+            path = "/#{path}" unless path =~ /^\//
+            @path = RegexpWithNamedGroups.compile("^#{path}$")
+          end
+          @path.freeze
+
+          @conditions.freeze
+        end
+
+        private
+          def validate_app!
+            unless @app.respond_to?(:call)
+              raise ArgumentError, 'app must be a valid rack application' \
+                ' and respond to call'
+            end
+          end
+
+          def validate_conditions!
+            unless @conditions.is_a?(Hash)
+              raise ArgumentError, 'conditions must be a Hash'
+            end
+
+            unless @conditions.keys.all? { |k| VALID_CONDITIONS.include?(k) }
+              raise ArgumentError, 'conditions may only include ' +
+                VALID_CONDITIONS.inspect
+            end
+          end
+      end
+      include Base
+
+      include Generation::Route, Recognition::Route
+    end
+  end
+end

data/lib/rack/mount/route_set.rb

@@ -0,0 +1,34 @@
+module Rack
+  module Mount
+    class RouteSet
+      module Base
+        def initialize(options = {})
+          if options.delete(:optimize) == true
+            extend Generation::Optimizations
+          end
+
+          if block_given?
+            yield self
+            freeze
+          end
+        end
+
+        # Builder method to add a route to the set
+        #
+        # <tt>app</tt>:: A valid Rack app to call if the conditions are met.
+        # <tt>conditions</tt>:: A hash of conditions to match against.
+        #                       Conditions may be expressed as strings or
+        #                       regexps to match against.
+        # <tt>defaults</tt>:: A hash of values that always gets merged in
+        # <tt>name</tt>:: Symbol identifier for the route used with named 
+        #                 route generations
+        def add_route(app, conditions = {}, defaults = {}, name = nil)
+          Route.new(app, conditions, defaults, name)
+        end
+      end
+      include Base
+
+      include Generation::RouteSet, Recognition::RouteSet
+    end
+  end
+end

data/lib/rack/mount/utils.rb

@@ -0,0 +1,149 @@
+require 'strscan'
+
+module Rack
+  module Mount
+    module Utils #:nodoc:
+      GLOB_REGEXP = /\/\\\*(\w+)$/
+      OPTIONAL_SEGMENT_REGEXP = /\\\((.+)\\\)/
+      SEGMENT_REGEXP = /(:([a-z](_?[a-z0-9])*))/
+
+      def convert_segment_string_to_regexp(str, requirements = {}, separators = [])
+        raise ArgumentError unless str.is_a?(String)
+
+        str = Regexp.escape(str.dup)
+        requirements = requirements || {}
+        str.replace("/#{str}") unless str =~ /^\//
+
+        re = ''
+
+        while m = (str.match(SEGMENT_REGEXP))
+          re << m.pre_match unless m.pre_match.empty?
+          if requirement = requirements[$2.to_sym]
+            re << Const::REGEXP_NAMED_CAPTURE % [$2, requirement.source]
+          else
+            re << Const::REGEXP_NAMED_CAPTURE % [$2, "[^#{separators.join}]+"]
+          end
+          str = m.post_match
+        end
+
+        re << str unless str.empty?
+
+        if m = re.match(GLOB_REGEXP)
+          re.sub!(GLOB_REGEXP, "/#{Const::REGEXP_NAMED_CAPTURE % [$1, '.*']}")
+        end
+
+        while re =~ OPTIONAL_SEGMENT_REGEXP
+          re.gsub!(OPTIONAL_SEGMENT_REGEXP, '(\1)?')
+        end
+
+        RegexpWithNamedGroups.new("^#{re}$")
+      end
+      module_function :convert_segment_string_to_regexp
+
+      class Capture < Array #:nodoc:
+        attr_reader :name, :optional
+        alias_method :optional?, :optional
+
+        def initialize(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+
+          @name = options.delete(:name)
+          @name = @name.to_s if @name
+
+          @optional = options.delete(:optional) || false
+
+          super(args)
+        end
+
+        def ==(obj)
+          @name == obj.name && @optional == obj.optional && super
+        end
+
+        def optionalize!
+          @optional = true
+          self
+        end
+
+        def named?
+          name && name != ''
+        end
+
+        def freeze
+          each { |e| e.freeze }
+          super
+        end
+      end
+
+      def extract_regexp_parts(regexp)
+        unless regexp.is_a?(RegexpWithNamedGroups)
+          regexp = RegexpWithNamedGroups.new(regexp)
+        end
+
+        if regexp.source =~ /\?<([^>]+)>/
+          regexp, names = extract_named_captures(regexp)
+        else
+          names = regexp.names
+        end
+        source = regexp.source
+
+        source =~ /^\^/ ? source.gsub!(/^\^/, '') :
+          raise(ArgumentError, "#{source} needs to match the start of the string")
+        source.gsub!(/\$$/, '')
+
+        scanner = StringScanner.new(source)
+        stack = [[]]
+
+        capture_index = 0
+        until scanner.eos?
+          char = scanner.getch
+          cur  = stack.last
+
+          if char == '('
+            name = names[capture_index]
+            capture = Capture.new(:name => name)
+            capture_index += 1
+            cur.push(capture)
+            stack.push(capture)
+          elsif char == ')'
+            capture = stack.pop
+            if scanner.peek(1) == '?'
+              scanner.pos += 1
+              capture.optionalize!
+            end
+          else
+            cur.push('') unless cur.last.is_a?(String)
+            cur.last << char
+          end
+        end
+
+        result = stack.pop
+        result.each { |e| e.freeze }
+        result
+      end
+      module_function :extract_regexp_parts
+
+      if Const::SUPPORTS_NAMED_CAPTURES
+        NAMED_CAPTURE_REGEXP = /\?<([^>]+)>/.freeze
+      else
+        NAMED_CAPTURE_REGEXP = /\?:<([^>]+)>/.freeze
+      end
+
+      def extract_named_captures(regexp)
+        source = Regexp.compile(regexp).source
+        names, scanner = [], StringScanner.new(source)
+
+        while scanner.skip_until(/\(/)
+          if scanner.scan(NAMED_CAPTURE_REGEXP)
+            names << scanner[1]
+          else
+            names << nil
+          end
+        end
+
+        source.gsub!(NAMED_CAPTURE_REGEXP, '')
+        return Regexp.compile(source), names
+      end
+      module_function :extract_named_captures
+    end
+  end
+end