Vendor unreleased rack-mount 0.6.6.pre dependency

3 files changed, 293 insertions, 0 deletions

diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/frequency.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/frequency.rb
new file mode 100644
index 0000000000..671258f807
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/frequency.rb
@@ -0,0 +1,60 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  module Analysis
+    class Frequency #:nodoc:
+      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)
+          expression = Utils.parse_regexp(requirement)
+
+          if expression.is_a?(Regin::Expression) && expression.anchored_to_line?
+            expression = Regin::Expression.new(expression.reject { |e| e.is_a?(Regin::Anchor) })
+            return requirements[method] = expression.to_s if expression.literal?
+          end
+        end
+
+        requirements[method] = requirement
+      end
+
+      def report
+        @report ||= begin
+          possible_keys.each { |keys| keys.each_pair { |key, _| @key_frequency << key } }
+          return [] if @key_frequency.count <= 1
+          @key_frequency.keys_in_upper_quartile
+        end
+      end
+
+      def expire!
+        @possible_keys = @report = nil
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/histogram.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/histogram.rb
new file mode 100644
index 0000000000..20aaa132f9
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/histogram.rb
@@ -0,0 +1,74 @@
+module Rack::Mount
+  module Analysis
+    class Histogram < Hash #:nodoc:
+      attr_reader :count
+
+      def initialize
+        @count = 0
+        super(0)
+        expire_caches!
+      end
+
+      def <<(value)
+        @count += 1
+        self[value] += 1 if value
+        expire_caches!
+        self
+      end
+
+      def sorted_by_frequency
+        sort_by { |_, value| value }.reverse!
+      end
+
+      def max
+        @max ||= values.max || 0
+      end
+
+      def min
+        @min ||= values.min || 0
+      end
+
+      def mean
+        @mean ||= calculate_mean
+      end
+
+      def standard_deviation
+        @standard_deviation ||= calculate_standard_deviation
+      end
+
+      def upper_quartile_limit
+        @upper_quartile_limit ||= calculate_upper_quartile_limit
+      end
+
+      def keys_in_upper_quartile
+        @keys_in_upper_quartile ||= compute_keys_in_upper_quartile
+      end
+
+      private
+        def calculate_mean
+          count / size
+        end
+
+        def calculate_variance
+          values.inject(0) { |sum, e| sum + (e - mean) ** 2 } / count.to_f
+        end
+
+        def calculate_standard_deviation
+          Math.sqrt(calculate_variance)
+        end
+
+        def calculate_upper_quartile_limit
+          mean + standard_deviation
+        end
+
+        def compute_keys_in_upper_quartile
+          sorted_by_frequency.select { |_, value| value >= upper_quartile_limit }.map! { |key, _| key }
+        end
+
+        def expire_caches!
+          @max = @min = @mean = @standard_deviation = nil
+          @keys_in_upper_quartile = nil
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/splitting.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/splitting.rb
new file mode 100644
index 0000000000..8a8c551302
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/splitting.rb
@@ -0,0 +1,159 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  module Analysis
+    class Splitting < Frequency
+      NULL = "\0".freeze
+
+      class Key < Struct.new(:method, :index, :separators)
+        def self.split(value, separator_pattern)
+          keys = value.split(separator_pattern)
+          keys.shift if keys[0] == ''
+          keys << NULL
+          keys
+        end
+
+        def call(cache, obj)
+          (cache[method] ||= self.class.split(obj.send(method), separators))[index]
+        end
+
+        def call_source(cache, obj)
+          "(#{cache}[:#{method}] ||= Analysis::Splitting::Key.split(#{obj}.#{method}, #{separators.inspect}))[#{index}]"
+        end
+
+        def inspect
+          "#{method}[#{index}]"
+        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].keys_in_upper_quartile + ['/']).uniq
+      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.parse_regexp(regexp)
+          parts.each_with_index do |part, index|
+            if part.is_a?(Regin::Group)
+              if index > 0
+                previous = parts[index-1]
+                if previous.is_a?(Regin::Character) && previous.literal?
+                  boundaries << previous.to_s
+                end
+              end
+
+              if inside = part.expression[0]
+                if inside.is_a?(Regin::Character) && inside.literal?
+                  boundaries << inside.to_s
+                end
+              end
+
+              if index < parts.length
+                following = parts[index+1]
+                if following.is_a?(Regin::Character) && following.literal?
+                  boundaries << following.to_s
+                end
+              end
+            end
+          end
+
+          boundaries
+        end
+
+        def generate_split_keys(regexp, separators) #:nodoc:
+          segments = []
+          buf = nil
+          parts = Utils.parse_regexp(regexp)
+          parts.each_with_index do |part, index|
+            case part
+            when Regin::Anchor
+              if part.value == '$' || part.value == '\Z'
+                segments << join_buffer(buf, regexp) if buf
+                segments << NULL
+                buf = nil
+                break
+              end
+            when Regin::CharacterClass
+              break if separators.any? { |s| part.include?(s) }
+              buf = nil
+              segments << part.to_regexp(true)
+            when Regin::Character
+              if separators.any? { |s| part.include?(s) }
+                segments << join_buffer(buf, regexp) if buf
+                peek = parts[index+1]
+                if peek.is_a?(Regin::Character) && separators.include?(peek.value)
+                  segments << ''
+                end
+                buf = nil
+              else
+                buf ||= Regin::Expression.new([])
+                buf += [part]
+              end
+            when Regin::Group
+              if part.quantifier == '?'
+                value = part.expression.first
+                if separators.any? { |s| value.include?(s) }
+                  segments << join_buffer(buf, regexp) if buf
+                  buf = nil
+                end
+                break
+              elsif part.quantifier == nil
+                break if separators.any? { |s| part.include?(s) }
+                buf = nil
+                segments << part.to_regexp(true)
+              else
+                break
+              end
+            else
+              break
+            end
+
+            if index + 1 == parts.size
+              segments << join_buffer(buf, regexp) if buf
+              buf = nil
+              break
+            end
+          end
+
+          while segments.length > 0 && (segments.last.nil? || segments.last == '')
+            segments.pop
+          end
+
+          segments
+        end
+
+        def join_buffer(parts, regexp)
+          if parts.literal?
+            parts.to_s
+          else
+            parts.to_regexp(true)
+          end
+        end
+    end
+  end
+end