rack-mount 0.0.1

data/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 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</tt>:: generates 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/analysis/frequency.rb

@@ -0,0 +1,51 @@
+module Rack::Mount
+  module Analysis
+    class Frequency #:nodoc:
+      extend Mixover
+
+      def initialize(*keys)
+        clear
+        keys.each { |key| self << key }
+      end
+
+      def clear
+        @raw_keys = []
+        @key_frequency = Analysis::Histogram.new
+        self
+      end
+
+      def <<(key)
+        raise ArgumentError unless key.is_a?(Hash)
+        @raw_keys << key
+        nil
+      end
+
+      def possible_keys
+        @possible_keys ||= begin
+          @raw_keys.map do |key|
+            key.inject({}) { |requirements, (method, requirement)|
+              process_key(requirements, method, requirement)
+              requirements
+            }
+          end
+        end
+      end
+
+      def process_key(requirements, method, requirement)
+        if requirement.is_a?(Regexp)
+          requirements[method] = Utils.extract_static_regexp(requirement)
+        else
+          requirements[method] = requirement
+        end
+      end
+
+      def report
+        @report ||= begin
+          possible_keys.each { |keys| keys.each_pair { |key, _| @key_frequency << key } }
+          return [] if @key_frequency.count <= 1
+          @key_frequency.select_upper
+        end
+      end
+    end
+  end
+end

data/lib/rack/mount/analysis/histogram.rb

@@ -0,0 +1,25 @@
+module Rack::Mount
+  module Analysis
+    class Histogram < Hash #:nodoc:
+      attr_reader :count
+
+      def initialize
+        @count = 0
+        super(0)
+      end
+
+      def <<(value)
+        @count += 1
+        self[value] += 1 if value
+      end
+
+      def select_upper
+        values = sort_by { |_, value| value }
+        values.reverse!
+        values = values.select { |_, value| value >= count / size }
+        values.map! { |key, _| key }
+        values
+      end
+    end
+  end
+end

data/lib/rack/mount/analysis/splitting.rb

@@ -0,0 +1,145 @@
+module Rack::Mount
+  module Analysis
+    module Splitting
+      class Key < Array
+        def initialize(method, index, separators)
+          replace([method, index, separators])
+        end
+
+        def self.split(value, separator_pattern)
+          keys = value.split(separator_pattern)
+          keys.shift if keys[0] == Const::EMPTY_STRING
+          keys << Const::NULL
+          keys
+        end
+
+        def call(cache, obj)
+          (cache[self[0]] ||= self.class.split(obj.send(self[0]), self[2]))[self[1]]
+        end
+
+        def call_source(cache, obj)
+          "(#{cache}[:#{self[0]}] ||= Analysis::Splitting::Key.split(#{obj}.#{self[0]}, #{self[2].inspect}))[#{self[1]}]"
+        end
+      end
+
+      def clear
+        @boundaries = {}
+        super
+      end
+
+      def <<(key)
+        super
+        key.each_pair do |k, v|
+          analyze_capture_boundaries(v, @boundaries[k] ||= Histogram.new)
+        end
+      end
+
+      def separators(key)
+        @boundaries[key].select_upper
+      end
+
+      def process_key(requirements, method, requirement)
+        separators = separators(method)
+        if requirement.is_a?(Regexp) && separators.any?
+          generate_split_keys(requirement, separators).each_with_index do |value, index|
+            requirements[Key.new(method, index, Regexp.union(*separators))] = value
+          end
+        else
+          super
+        end
+      end
+
+      private
+        def analyze_capture_boundaries(regexp, boundaries) #:nodoc:
+          return boundaries unless regexp.is_a?(Regexp)
+
+          parts = Utils.extract_regexp_parts(regexp) rescue []
+          parts.each_with_index do |part, index|
+            break if part == Const::NULL
+
+            if index > 0
+              previous = parts[index-1]
+              if previous.is_a?(Utils::Capture)
+                previous = Utils.extract_static_regexp(previous.last_part) rescue nil
+              end
+              boundaries << previous[-1..-1] if previous.is_a?(String)
+            end
+
+            if index < parts.length
+              following = parts[index+1]
+              if following.is_a?(Utils::Capture)
+                following = Utils.extract_static_regexp(following.first_part) rescue nil
+              end
+              if following.is_a?(String) && following != Const::NULL
+                boundaries << following[0..0] == '\\' ? following[1..1] : following[0..0]
+              end
+            end
+          end
+          boundaries
+        end
+
+        def generate_split_keys(regexp, separators) #:nodoc:
+          escaped_separators = separators.map { |s| Regexp.escape(s) }
+          separators_regexp = Regexp.union(*escaped_separators)
+          segments, previous = [], nil
+          regexp_options = regexp.options
+
+          begin
+            Utils.extract_regexp_parts(regexp).each do |part|
+              if part.respond_to?(:optional?) && part.optional?
+                if escaped_separators.include?(part.first)
+                  append_to_segments!(segments, previous, separators, regexp_options)
+                end
+
+                raise ArgumentError
+              end
+
+              append_to_segments!(segments, previous, separators, regexp_options)
+              previous = nil
+
+              if part == Const::NULL
+                segments << Const::NULL
+                raise ArgumentError
+              end
+
+              if part.is_a?(Utils::Capture)
+                source = part.map { |p| p.to_s }.join
+                append_to_segments!(segments, source, separators, regexp_options)
+              else
+                parts = part.split(separators_regexp)
+                parts.shift if parts[0] == Const::EMPTY_STRING
+                previous = parts.pop
+                parts.each { |p| append_to_segments!(segments, p, separators, regexp_options) }
+              end
+            end
+
+            append_to_segments!(segments, previous, separators, regexp_options)
+          rescue ArgumentError
+            # generation failed somewhere, but lets take what we can get
+          end
+
+          while segments.length > 0 && (segments.last.nil? || segments.last == '')
+            segments.pop
+          end
+
+          segments
+        end
+
+        def append_to_segments!(segments, s, separators, regexp_options) #:nodoc:
+          return unless s
+          separators.each do |separator|
+            if s.gsub(/\[[^\]]+\]/, '').include?(separator)
+              raise ArgumentError
+            end
+
+            if Regexp.compile("\\A#{s}\\Z") =~ separator
+              raise ArgumentError
+            end
+          end
+
+          static = Utils.extract_static_regexp(s, regexp_options)
+          segments << (static.is_a?(String) ? static : static)
+        end
+      end
+  end
+end

data/lib/rack/mount/const.rb

@@ -0,0 +1,45 @@
+module Rack::Mount
+  module Const
+    RACK_ROUTING_ARGS = 'rack.routing_args'.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
+
+    EMPTY_ARRAY = [].freeze
+    EMPTY_HASH = {}.freeze
+
+    NULL = "\0".freeze
+
+    CONTENT_TYPE    = 'Content-Type'.freeze
+    CONTINUE        = '100-continue'.freeze
+    DELETE          = 'PUT'.freeze
+    EMPTY_STRING    = ''.freeze
+    EXPECT          = 'Expect'.freeze
+    GET             = 'GET'.freeze
+    HEAD            = 'HEAD'.freeze
+    PATH_INFO       = 'PATH_INFO'.freeze
+    POST            = 'POST'.freeze
+    PUT             = 'PUT'.freeze
+    REQUEST_METHOD  = 'REQUEST_METHOD'.freeze
+    SCRIPT_NAME     = 'SCRIPT_NAME'.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
+    EXPECTATION_FAILED = 'Expectation failed'.freeze
+
+    OK_RESPONSE = [200, DEFAULT_CONTENT_TYPE_HEADERS, [OK].freeze].freeze
+    NOT_FOUND_RESPONSE = [404, DEFAULT_CONTENT_TYPE_HEADERS, [NOT_FOUND].freeze].freeze
+    EXPECTATION_FAILED_RESPONSE = [417, DEFAULT_CONTENT_TYPE_HEADERS, [EXPECTATION_FAILED].freeze].freeze
+  end
+end

data/lib/rack/mount/exceptions.rb

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

data/lib/rack/mount/generatable_regexp.rb

@@ -0,0 +1,163 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  class GeneratableRegexp < Regexp #:nodoc:
+    class DynamicSegment #:nodoc:
+      attr_reader :name, :requirement
+
+      def initialize(name, requirement)
+        @name, @requirement = name.to_sym, bound_expression(requirement)
+        freeze
+      end
+
+      def ==(obj)
+        @name == obj.name && @requirement == obj.requirement
+      end
+
+      def =~(str)
+        @requirement =~ str
+      end
+
+      def to_hash
+        { @name => @requirement }
+      end
+
+      def inspect
+        "/(?<#{@name}>#{@requirement.source})/"
+      end
+
+      private
+        def bound_expression(regexp)
+          source, options = regexp.source, regexp.options
+          source = "\\A#{source}\\Z"
+          Regexp.compile(source, options).freeze
+        end
+    end
+
+    module InstanceMethods
+      def self.extended(obj)
+        obj.segments
+      end
+
+      def generatable?
+        segments.any?
+      end
+
+      def generate(params = {}, recall = {}, defaults = {})
+        merged = recall.merge(params)
+        generate_from_segments(segments, params, merged, defaults)
+      end
+
+      def segments
+        @segments ||= begin
+          parse_segments(Utils.extract_regexp_parts(self))
+        rescue ArgumentError
+          Const::EMPTY_ARRAY
+        end
+      end
+
+      def captures
+        segments.flatten.find_all { |s| s.is_a?(DynamicSegment) }
+      end
+
+      def required_captures
+        segments.find_all { |s| s.is_a?(DynamicSegment) }
+      end
+
+      private
+        def parse_segments(segments)
+          s = []
+          segments.each do |part|
+            if part.is_a?(String) && part == Const::NULL
+              return s
+            elsif part.is_a?(Utils::Capture)
+              if part.named?
+                source = part.map { |p| p.to_s }.join
+                requirement = Regexp.compile(source)
+                s << DynamicSegment.new(part.name, requirement)
+              else
+                s << parse_segments(part)
+              end
+            else
+              part = part.gsub('\\/', '/')
+              static = Utils.extract_static_regexp(part)
+              if static.is_a?(String)
+                s << static.freeze
+              else
+                raise ArgumentError, "failed to parse #{part.inspect}"
+              end
+            end
+          end
+
+          s.freeze
+        end
+
+        def generate_from_segments(segments, params, merged, defaults, optional = false)
+          if optional
+            return Const::EMPTY_STRING if segments.all? { |s| s.is_a?(String) }
+            return Const::EMPTY_STRING unless segments.flatten.any? { |s|
+              params[s.name] if s.is_a?(DynamicSegment)
+            }
+            return Const::EMPTY_STRING if segments.any? { |segment|
+              if segment.is_a?(DynamicSegment)
+                value = merged[segment.name] || defaults[segment.name]
+                value = value.to_param if value.respond_to?(:to_param)
+
+                merged_value = merged[segment.name]
+                merged_value = merged_value.to_param if merged_value.respond_to?(:to_param)
+
+                default_value = defaults[segment.name]
+                default_value = default_value.to_param if default_value.respond_to?(:to_param)
+
+                if value.nil? || segment !~ value
+                  true
+                elsif merged_value == default_value
+                  # Nasty control flow
+                  return :clear_remaining_segments
+                  true
+                else
+                  false
+                end
+              end
+            }
+          end
+
+          generated = segments.map do |segment|
+            case segment
+            when String
+              segment
+            when DynamicSegment
+              value = params[segment.name] || merged[segment.name] || defaults[segment.name]
+              value = value.to_param if value.respond_to?(:to_param)
+              if value && segment =~ value.to_s
+                value
+              else
+                return
+              end
+            when Array
+              value = generate_from_segments(segment, params, merged, defaults, true)
+              if value == :clear_remaining_segments
+                segment.each { |s| params.delete(s.name) if s.is_a?(DynamicSegment) }
+                Const::EMPTY_STRING
+              elsif value.nil?
+                Const::EMPTY_STRING
+              else
+                value
+              end
+            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
+    include InstanceMethods
+
+    def initialize(regexp)
+      super
+      segments
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  module Generation
+    module Route #:nodoc:
+      attr_reader :generation_keys
+
+      def initialize(*args)
+        super
+
+        @required_params = {}
+        @required_defaults = {}
+        @generation_keys = @defaults.dup
+
+        @conditions.each do |method, condition|
+          @required_params[method] = @conditions[method].required_captures.map { |s| s.name }.reject { |s| @defaults.include?(s) }.freeze
+          @required_defaults[method] = @defaults.dup
+          @conditions[method].captures.inject({}) { |h, s| h.merge!(s.to_hash) }.keys.each { |name|
+            @required_defaults[method].delete(name)
+            @generation_keys.delete(name) if @defaults.include?(name)
+          }
+          @required_defaults[method].freeze
+        end
+
+        @required_params.freeze
+        @required_defaults.freeze
+        @generation_keys.freeze
+      end
+
+      def generate(methods, params = {}, recall = {})
+        if methods.is_a?(Array)
+          result = methods.map { |m| generate_method(m, params, recall, @defaults) || (return nil) }
+        else
+          result = generate_method(methods, params, recall, @defaults)
+        end
+
+        if result
+          @defaults.each do |key, value|
+            params.delete(key) if params[key] == value
+          end
+        end
+
+        result
+      end
+
+      private
+        def generate_method(method, params, recall, defaults)
+          merged = recall.merge(params)
+          return nil unless condition = @conditions[method]
+          return nil if condition.segments.empty?
+          return nil unless @required_params[method].all? { |p| merged.include?(p) }
+          return nil unless @required_defaults[method].all? { |k, v| merged[k] == v }
+          condition.generate(params, recall, defaults)
+        end
+    end
+  end
+end