diff options
Diffstat (limited to 'actionpack/lib')
35 files changed, 1 insertions, 4014 deletions
diff --git a/actionpack/lib/action_dispatch/routing/route_set.rb b/actionpack/lib/action_dispatch/routing/route_set.rb index 1b1a221c60..36c52eb65a 100644 --- a/actionpack/lib/action_dispatch/routing/route_set.rb +++ b/actionpack/lib/action_dispatch/routing/route_set.rb @@ -1,10 +1,8 @@ +require 'rack/mount' require 'forwardable' require 'active_support/core_ext/object/to_query' require 'action_dispatch/routing/deprecated_mapper' -$: << File.expand_path('../../vendor/rack-mount-0.6.6.pre', __FILE__) -require 'rack/mount' - module ActionDispatch module Routing class RouteSet #:nodoc: diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount.rb deleted file mode 100644 index 9fbf707724..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount.rb +++ /dev/null @@ -1,32 +0,0 @@ -require 'rack' - -module Rack #:nodoc: - # 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. - module Mount - autoload :CodeGeneration, 'rack/mount/code_generation' - autoload :GeneratableRegexp, 'rack/mount/generatable_regexp' - autoload :Multimap, 'rack/mount/multimap' - autoload :Prefix, 'rack/mount/prefix' - autoload :RegexpWithNamedGroups, 'rack/mount/regexp_with_named_groups' - autoload :Route, 'rack/mount/route' - autoload :RouteSet, 'rack/mount/route_set' - autoload :RoutingError, 'rack/mount/route_set' - autoload :Strexp, 'rack/mount/strexp' - autoload :Utils, 'rack/mount/utils' - autoload :Version, 'rack/mount/version' - - module Analysis #:nodoc: - autoload :Frequency, 'rack/mount/analysis/frequency' - autoload :Histogram, 'rack/mount/analysis/histogram' - autoload :Splitting, 'rack/mount/analysis/splitting' - end - end -end 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 deleted file mode 100644 index 671258f807..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/frequency.rb +++ /dev/null @@ -1,60 +0,0 @@ -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 deleted file mode 100644 index 20aaa132f9..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/histogram.rb +++ /dev/null @@ -1,74 +0,0 @@ -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 deleted file mode 100644 index 8a8c551302..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/splitting.rb +++ /dev/null @@ -1,159 +0,0 @@ -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 diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/code_generation.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/code_generation.rb deleted file mode 100644 index 903c79fdc6..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/code_generation.rb +++ /dev/null @@ -1,113 +0,0 @@ -module Rack::Mount - module CodeGeneration #:nodoc: - def _expired_recognize(env) #:nodoc: - raise 'route set not finalized' - end - - def rehash - super - optimize_recognize! - end - - private - def expire! - if @optimized_recognize_defined - remove_metaclass_method :recognize - - class << self - alias_method :recognize, :_expired_recognize - end - - @optimized_recognize_defined = false - end - - super - end - - def optimize_container_iterator(container) - body = [] - - container.each_with_index { |route, i| - body << "route = self[#{i}]" - body << 'matches = {}' - body << 'params = route.defaults.dup' - - conditions = [] - route.conditions.each do |method, condition| - b = [] - if condition.is_a?(Regexp) - b << "if m = obj.#{method}.match(#{condition.inspect})" - b << "matches[:#{method}] = m" - if (named_captures = route.named_captures[method]) && named_captures.any? - b << 'captures = m.captures' - b << 'p = nil' - b << named_captures.map { |k, j| "params[#{k.inspect}] = p if p = captures[#{j}]" }.join('; ') - end - else - b << "if m = obj.#{method} == route.conditions[:#{method}]" - end - b << 'true' - b << 'end' - conditions << "(#{b.join('; ')})" - end - - body << <<-RUBY - if #{conditions.join(' && ')} - yield route, matches, params - end - RUBY - } - - container.instance_eval(<<-RUBY, __FILE__, __LINE__) - def optimized_each(obj) - #{body.join("\n")} - nil - end - RUBY - end - - def optimize_recognize! - keys = @recognition_keys.map { |key| - if key.respond_to?(:call_source) - key.call_source(:cache, :obj) - else - "obj.#{key}" - end - }.join(', ') - - @optimized_recognize_defined = true - - remove_metaclass_method :recognize - - instance_eval(<<-RUBY, __FILE__, __LINE__) - def recognize(obj) - cache = {} - container = @recognition_graph[#{keys}] - optimize_container_iterator(container) unless container.respond_to?(:optimized_each) - - if block_given? - container.optimized_each(obj) do |route, matches, params| - yield route, matches, params - end - else - container.optimized_each(obj) do |route, matches, params| - return route, matches, params - end - end - - nil - end - RUBY - end - - # method_defined? can't distinguish between instance - # and meta methods. So we have to rescue if the method - # has not been defined in the metaclass yet. - def remove_metaclass_method(symbol) - metaclass = class << self; self; end - metaclass.send(:remove_method, symbol) - rescue NameError => e - nil - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/generatable_regexp.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/generatable_regexp.rb deleted file mode 100644 index 47bbab3784..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/generatable_regexp.rb +++ /dev/null @@ -1,210 +0,0 @@ -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, 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 - end - - module InstanceMethods - def self.extended(obj) - obj.segments - end - - def defaults=(defaults) - @required_captures = nil - @required_params = nil - @required_defaults = nil - @defaults = defaults - end - - def defaults - @defaults ||= {} - end - - def generatable? - segments.any? - end - - def generate(params = {}, recall = {}, options = {}) - return nil unless generatable? - - merged = recall.merge(params) - return nil unless required_params.all? { |p| merged.include?(p) } - return nil unless required_defaults.all? { |k, v| merged[k] == v } - - generate_from_segments(segments, params, merged, options) - end - - def segments - @segments ||= begin - defaults - segments = [] - catch(:halt) do - expression = Utils.parse_regexp(self) - segments = parse_segments(expression) - end - segments - end - end - - def captures - segments.flatten.find_all { |s| s.is_a?(DynamicSegment) } - end - - def required_captures - @required_captures ||= segments.find_all { |s| - s.is_a?(DynamicSegment) && !@defaults.include?(s.name) - }.freeze - end - - def required_params - @required_params ||= required_captures.map { |s| s.name }.freeze - end - - def required_defaults - @required_defaults ||= begin - required_defaults = @defaults.dup - captures.inject({}) { |h, s| h.merge!(s.to_hash) }.keys.each { |name| - required_defaults.delete(name) - } - required_defaults - end - end - - def freeze - segments - captures - required_captures - required_params - required_defaults - super - end - - private - def parse_segments(segments) - s = [] - segments.each_with_index do |part, index| - case part - when Regin::Anchor - # ignore - when Regin::Character - throw :halt unless part.literal? - - if s.last.is_a?(String) - s.last << part.value.dup - else - s << part.value.dup - end - when Regin::Group - if part.name - s << DynamicSegment.new(part.name, part.expression.to_regexp(true)) - else - s << parse_segments(part.expression) - end - when Regin::Expression - return parse_segments(part) - else - throw :halt - end - end - - s - end - - EMPTY_STRING = ''.freeze - - def generate_from_segments(segments, params, merged, options, optional = false) - if optional - return EMPTY_STRING if segments.all? { |s| s.is_a?(String) } - return EMPTY_STRING unless segments.flatten.any? { |s| - params.has_key?(s.name) if s.is_a?(DynamicSegment) - } - return EMPTY_STRING if segments.any? { |segment| - if segment.is_a?(DynamicSegment) - value = merged[segment.name] || @defaults[segment.name] - value = parameterize(segment.name, value, options) - - merged_value = parameterize(segment.name, merged[segment.name], options) - default_value = parameterize(segment.name, @defaults[segment.name], options) - - if value.nil? || segment !~ value - true - elsif merged_value == default_value - # Nasty control flow - return :clear_remaining_segments - 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 = parameterize(segment.name, value, options) - if value && segment =~ value.to_s - value - else - return - end - when Array - value = generate_from_segments(segment, params, merged, options, true) - if value == :clear_remaining_segments - segment.each { |s| params.delete(s.name) if s.is_a?(DynamicSegment) } - EMPTY_STRING - elsif value.nil? - 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 - - def parameterize(name, value, options) - if block = options[:parameterize] - block.call(name, value) - else - value - end - end - end - include InstanceMethods - - def initialize(regexp) - super - segments - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/multimap.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/multimap.rb deleted file mode 100644 index 0f8eaaec67..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/multimap.rb +++ /dev/null @@ -1,53 +0,0 @@ -begin - require 'nested_multimap' -rescue LoadError - $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/multimap')) - require 'nested_multimap' -end - -module Rack::Mount - class Multimap < NestedMultimap #:nodoc: - def store(*args) - keys = args.dup - value = keys.pop - key = keys.shift - - raise ArgumentError, 'wrong number of arguments (1 for 2)' unless value - - unless key.respond_to?(:=~) - raise ArgumentError, "unsupported key: #{args.first.inspect}" - end - - if key.is_a?(Regexp) - if keys.empty? - @hash.each_pair { |k, l| l << value if k =~ key } - self.default << value - else - @hash.each_pair { |k, _| - if k =~ key - args[0] = k - super(*args) - end - } - - self.default = self.class.new(default) unless default.is_a?(self.class) - default[*keys.dup] = value - end - else - super(*args) - end - end - alias_method :[]=, :store - - undef :index, :invert - - def height - containers_with_default.max { |a, b| a.length <=> b.length }.length - end - - def average_height - lengths = containers_with_default.map { |e| e.length } - lengths.inject(0) { |sum, len| sum += len }.to_f / lengths.size - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/prefix.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/prefix.rb deleted file mode 100644 index 58892e4c4f..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/prefix.rb +++ /dev/null @@ -1,36 +0,0 @@ -require 'rack/mount/utils' - -module Rack::Mount - class Prefix #:nodoc: - EMPTY_STRING = ''.freeze - PATH_INFO = 'PATH_INFO'.freeze - SCRIPT_NAME = 'SCRIPT_NAME'.freeze - SLASH = '/'.freeze - - KEY = 'rack.mount.prefix'.freeze - - def initialize(app, prefix = nil) - @app, @prefix = app, prefix.freeze - freeze - end - - def call(env) - if prefix = env[KEY] || @prefix - old_path_info = env[PATH_INFO].dup - old_script_name = env[SCRIPT_NAME].dup - - begin - env[PATH_INFO] = Utils.normalize_path(env[PATH_INFO].sub(prefix, EMPTY_STRING)) - env[PATH_INFO] = EMPTY_STRING if env[PATH_INFO] == SLASH - env[SCRIPT_NAME] = Utils.normalize_path(env[SCRIPT_NAME].to_s + prefix) - @app.call(env) - ensure - env[PATH_INFO] = old_path_info - env[SCRIPT_NAME] = old_script_name - end - else - @app.call(env) - end - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/regexp_with_named_groups.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/regexp_with_named_groups.rb deleted file mode 100644 index c11292b2a2..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/regexp_with_named_groups.rb +++ /dev/null @@ -1,69 +0,0 @@ -module Rack::Mount - if Regin.regexp_supports_named_captures? - RegexpWithNamedGroups = Regexp - else - require 'strscan' - - # A wrapper that adds shim named capture support to older - # versions of Ruby. - # - # Because the named capture syntax causes a parse error, an - # alternate syntax is used to indicate named captures. - # - # Ruby 1.9+ named capture syntax: - # - # /(?<foo>[a-z]+)/ - # - # Ruby 1.8 shim syntax: - # - # /(?:<foo>[a-z]+)/ - class RegexpWithNamedGroups < Regexp - def self.new(regexp) #:nodoc: - if regexp.is_a?(RegexpWithNamedGroups) - regexp - else - super - end - end - - # Wraps Regexp with named capture support. - def initialize(regexp) - regexp = Regexp.compile(regexp) unless regexp.is_a?(Regexp) - source, options = regexp.source, regexp.options - @names, scanner = [], StringScanner.new(source) - - while scanner.skip_until(/\(/) - if scanner.scan(/\?:<([^>]+)>/) - @names << scanner[1] - elsif scanner.scan(/\?(i?m?x?\-?i?m?x?)?:/) - # ignore noncapture - else - @names << nil - end - end - source.gsub!(/\?:<([^>]+)>/, '') - - @names = [] unless @names.any? - @names.freeze - - super(source, options) - end - - def names - @names.dup - end - - def named_captures - named_captures = {} - names.each_with_index { |n, i| - named_captures[n] = [i+1] if n - } - named_captures - end - - def eql?(other) - super && @names.eql?(other.names) - end - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route.rb deleted file mode 100644 index 680c40f147..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route.rb +++ /dev/null @@ -1,130 +0,0 @@ -require 'rack/mount/generatable_regexp' -require 'rack/mount/regexp_with_named_groups' -require 'rack/mount/utils' - -module Rack::Mount - # Route is an internal class used to wrap a single route attributes. - # - # Plugins should not depend on any method on this class or instantiate - # new Route objects. Instead use the factory method, RouteSet#add_route - # to create new routes and add them to the set. - class Route - # Valid rack application to call if conditions are met - attr_reader :app - - # A hash of conditions to match against. Conditions may be expressed - # as strings or regexps to match against. - attr_reader :conditions - - # A hash of values that always gets merged into the parameters hash - attr_reader :defaults - - # Symbol identifier for the route used with named route generations - attr_reader :name - - attr_reader :named_captures - - def initialize(app, conditions, defaults, name) - unless app.respond_to?(:call) - raise ArgumentError, 'app must be a valid rack application' \ - ' and respond to call' - end - @app = app - - @name = name ? name.to_sym : nil - @defaults = (defaults || {}).freeze - - @conditions = {} - - conditions.each do |method, pattern| - next unless method && pattern - - pattern = Regexp.compile("\\A#{Regexp.escape(pattern)}\\Z") if pattern.is_a?(String) - - if pattern.is_a?(Regexp) - pattern = Utils.normalize_extended_expression(pattern) - pattern = RegexpWithNamedGroups.new(pattern) - pattern.extend(GeneratableRegexp::InstanceMethods) - pattern.defaults = @defaults - end - - @conditions[method] = pattern.freeze - end - - @named_captures = {} - @conditions.map { |method, condition| - next unless condition.respond_to?(:named_captures) - @named_captures[method] = condition.named_captures.inject({}) { |named_captures, (k, v)| - named_captures[k.to_sym] = v.last - 1 - named_captures - }.freeze - } - @named_captures.freeze - - @has_significant_params = @conditions.any? { |method, condition| - (condition.respond_to?(:required_params) && condition.required_params.any?) || - (condition.respond_to?(:required_defaults) && condition.required_defaults.any?) - } - - if @conditions.has_key?(:path_info) && - !Utils.regexp_anchored?(@conditions[:path_info]) - @prefix = true - @app = Prefix.new(@app) - else - @prefix = false - end - - @conditions.freeze - end - - def prefix? - @prefix - end - - - def generation_keys - @conditions.inject({}) { |keys, (method, condition)| - if condition.respond_to?(:required_defaults) - keys.merge!(condition.required_defaults) - else - keys - end - } - end - - def significant_params? - @has_significant_params - end - - def generate(method, params = {}, recall = {}, options = {}) - if method.nil? - result = @conditions.inject({}) { |h, (m, condition)| - if condition.respond_to?(:generate) - h[m] = condition.generate(params, recall, options) - end - h - } - return nil if result.values.compact.empty? - else - if condition = @conditions[method] - if condition.respond_to?(:generate) - result = condition.generate(params, recall, options) - end - end - end - - if result - @defaults.each do |key, value| - params.delete(key) if params[key] == value - end - end - - result - end - - - def inspect #:nodoc: - "#<#{self.class.name} @app=#{@app.inspect} @conditions=#{@conditions.inspect} @defaults=#{@defaults.inspect} @name=#{@name.inspect}>" - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route_set.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route_set.rb deleted file mode 100644 index 0e5a65a640..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route_set.rb +++ /dev/null @@ -1,409 +0,0 @@ -require 'rack/mount/multimap' -require 'rack/mount/route' -require 'rack/mount/utils' - -module Rack::Mount - class RoutingError < StandardError; end - - class RouteSet - # Initialize a new RouteSet without optimizations - def self.new_without_optimizations(options = {}, &block) - new(options.merge(:_optimize => false), &block) - end - - # Basic RouteSet initializer. - # - # If a block is given, the set is yielded and finalized. - # - # See other aspects for other valid options: - # - <tt>Generation::RouteSet.new</tt> - # - <tt>Recognition::RouteSet.new</tt> - def initialize(options = {}, &block) - @parameters_key = options.delete(:parameters_key) || 'rack.routing_args' - @parameters_key.freeze - - @named_routes = {} - - @recognition_key_analyzer = Analysis::Splitting.new - @generation_key_analyzer = Analysis::Frequency.new - - @request_class = options.delete(:request_class) || Rack::Request - @valid_conditions = @request_class.public_instance_methods.map! { |m| m.to_sym } - - extend CodeGeneration unless options[:_optimize] == false - @optimized_recognize_defined = false - - @routes = [] - expire! - - if block_given? - yield self - rehash - 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) - unless conditions.is_a?(Hash) - raise ArgumentError, 'conditions must be a Hash' - end - - unless conditions.all? { |method, pattern| - @valid_conditions.include?(method) - } - raise ArgumentError, 'conditions may only include ' + - @valid_conditions.inspect - end - - route = Route.new(app, conditions, defaults, name) - @routes << route - - @recognition_key_analyzer << route.conditions - - @named_routes[route.name] = route if route.name - @generation_key_analyzer << route.generation_keys - - expire! - route - end - - def recognize(obj) - raise 'route set not finalized' unless @recognition_graph - - cache = {} - keys = @recognition_keys.map { |key| - if key.respond_to?(:call) - key.call(cache, obj) - else - obj.send(key) - end - } - - @recognition_graph[*keys].each do |route| - matches = {} - params = route.defaults.dup - - if route.conditions.all? { |method, condition| - value = obj.send(method) - if condition.is_a?(Regexp) && (m = value.match(condition)) - matches[method] = m - captures = m.captures - route.named_captures[method].each do |k, i| - if v = captures[i] - params[k] = v - end - end - true - elsif value == condition - true - else - false - end - } - if block_given? - yield route, matches, params - else - return route, matches, params - end - end - end - - nil - end - - X_CASCADE = 'X-Cascade'.freeze - PASS = 'pass'.freeze - PATH_INFO = 'PATH_INFO'.freeze - - # Rack compatible recognition and dispatching method. Routes are - # tried until one returns a non-catch status code. If no routes - # match, the catch status code is returned. - # - # This method can only be invoked after the RouteSet has been - # finalized. - def call(env) - raise 'route set not finalized' unless @recognition_graph - - env[PATH_INFO] = Utils.normalize_path(env[PATH_INFO]) - - request = nil - req = @request_class.new(env) - recognize(req) do |route, matches, params| - # TODO: We only want to unescape params from uri related methods - params.each { |k, v| params[k] = Utils.unescape_uri(v) if v.is_a?(String) } - - if route.prefix? - env[Prefix::KEY] = matches[:path_info].to_s - end - - env[@parameters_key] = params - result = route.app.call(env) - return result unless result[1][X_CASCADE] == PASS - end - - request || [404, {'Content-Type' => 'text/html', 'X-Cascade' => 'pass'}, ['Not Found']] - end - - # Generates a url from Rack env and identifiers or significant keys. - # - # To generate a url by named route, pass the name in as a +Symbol+. - # url(env, :dashboard) # => "/dashboard" - # - # Additional parameters can be passed in as a hash - # url(env, :people, :id => "1") # => "/people/1" - # - # If no name route is given, it will fall back to a slower - # generation search. - # url(env, :controller => "people", :action => "show", :id => "1") - # # => "/people/1" - def url(env, *args) - named_route, params = nil, {} - - case args.length - when 2 - named_route, params = args[0], args[1].dup - when 1 - if args[0].is_a?(Hash) - params = args[0].dup - else - named_route = args[0] - end - else - raise ArgumentError - end - - only_path = params.delete(:only_path) - recall = env[@parameters_key] || {} - - unless result = generate(:all, named_route, params, recall, - :parameterize => lambda { |name, param| Utils.escape_uri(param) }) - return - end - - parts, params = result - return unless parts - - params.each do |k, v| - if v - params[k] = v - else - params.delete(k) - end - end - - req = stubbed_request_class.new(env) - req._stubbed_values = parts.merge(:query_string => Utils.build_nested_query(params)) - only_path ? req.fullpath : req.url - end - - def generate(method, *args) #:nodoc: - raise 'route set not finalized' unless @generation_graph - - method = nil if method == :all - named_route, params, recall, options = extract_params!(*args) - merged = recall.merge(params) - route = nil - - if named_route - if route = @named_routes[named_route.to_sym] - recall = route.defaults.merge(recall) - url = route.generate(method, params, recall, options) - [url, params] - else - raise RoutingError, "#{named_route} failed to generate from #{params.inspect}" - end - else - keys = @generation_keys.map { |key| - if k = merged[key] - k.to_s - else - nil - end - } - @generation_graph[*keys].each do |r| - next unless r.significant_params? - if url = r.generate(method, params, recall, options) - return [url, params] - end - end - - raise RoutingError, "No route matches #{params.inspect}" - end - end - - # Number of routes in the set - def length - @routes.length - end - - def rehash #:nodoc: - @recognition_keys = build_recognition_keys - @recognition_graph = build_recognition_graph - @generation_keys = build_generation_keys - @generation_graph = build_generation_graph - end - - # Finalizes the set and builds optimized data structures. You *must* - # freeze the set before you can use <tt>call</tt> and <tt>url</tt>. - # So remember to call freeze after you are done adding routes. - def freeze - unless frozen? - rehash - - @recognition_key_analyzer = nil - @generation_key_analyzer = nil - @valid_conditions = nil - - @routes.each { |route| route.freeze } - @routes.freeze - end - - super - end - - def marshal_dump #:nodoc: - hash = {} - - instance_variables_to_serialize.each do |ivar| - hash[ivar] = instance_variable_get(ivar) - end - - if graph = hash[:@recognition_graph] - hash[:@recognition_graph] = graph.dup - end - - hash - end - - def marshal_load(hash) #:nodoc: - hash.each do |ivar, value| - instance_variable_set(ivar, value) - end - end - - protected - def recognition_stats - { :keys => @recognition_keys, - :keys_size => @recognition_keys.size, - :graph_size => @recognition_graph.size, - :graph_height => @recognition_graph.height, - :graph_average_height => @recognition_graph.average_height } - end - - private - def expire! #:nodoc: - @recognition_keys = @recognition_graph = nil - @recognition_key_analyzer.expire! - - @generation_keys = @generation_graph = nil - @generation_key_analyzer.expire! - end - - def instance_variables_to_serialize - instance_variables.map { |ivar| ivar.to_sym } - [:@stubbed_request_class, :@optimized_recognize_defined] - end - - # An internal helper method for constructing a nested set from - # the linear route set. - # - # build_nested_route_set([:request_method, :path_info]) { |route, method| - # route.send(method) - # } - def build_nested_route_set(keys, &block) - graph = Multimap.new - @routes.each_with_index do |route, index| - catch(:skip) do - k = keys.map { |key| block.call(key, index) } - Utils.pop_trailing_nils!(k) - k.map! { |key| key || /.+/ } - graph[*k] = route - end - end - graph - end - - def build_recognition_graph - build_nested_route_set(@recognition_keys) { |k, i| - @recognition_key_analyzer.possible_keys[i][k] - } - end - - def build_recognition_keys - @recognition_key_analyzer.report - end - - def build_generation_graph - build_nested_route_set(@generation_keys) { |k, i| - throw :skip unless @routes[i].significant_params? - - if k = @generation_key_analyzer.possible_keys[i][k] - k.to_s - else - nil - end - } - end - - def build_generation_keys - @generation_key_analyzer.report - end - - def extract_params!(*args) - case args.length - when 4 - named_route, params, recall, options = args - when 3 - if args[0].is_a?(Hash) - params, recall, options = args - else - named_route, params, recall = args - end - when 2 - if args[0].is_a?(Hash) - params, recall = args - else - named_route, params = args - end - when 1 - if args[0].is_a?(Hash) - params = args[0] - else - named_route = args[0] - end - else - raise ArgumentError - end - - named_route ||= nil - params ||= {} - recall ||= {} - options ||= {} - - [named_route, params.dup, recall.dup, options.dup] - end - - def stubbed_request_class - @stubbed_request_class ||= begin - klass = Class.new(@request_class) - klass.public_instance_methods.each do |method| - next if method =~ /^__|object_id/ - klass.class_eval <<-RUBY - def #{method}(*args, &block) - @_stubbed_values[:#{method}] || super - end - RUBY - end - klass.class_eval { attr_accessor :_stubbed_values } - klass - end - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp.rb deleted file mode 100644 index d0d8797008..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp.rb +++ /dev/null @@ -1,68 +0,0 @@ -require 'rack/mount/strexp/parser' - -module Rack::Mount - class Strexp - class << self - # Parses segmented string expression and converts it into a Regexp - # - # Strexp.compile('foo') - # # => %r{\Afoo\Z} - # - # Strexp.compile('foo/:bar', {}, ['/']) - # # => %r{\Afoo/(?<bar>[^/]+)\Z} - # - # Strexp.compile(':foo.example.com') - # # => %r{\A(?<foo>.+)\.example\.com\Z} - # - # Strexp.compile('foo/:bar', {:bar => /[a-z]+/}, ['/']) - # # => %r{\Afoo/(?<bar>[a-z]+)\Z} - # - # Strexp.compile('foo(.:extension)') - # # => %r{\Afoo(\.(?<extension>.+))?\Z} - # - # Strexp.compile('src/*files') - # # => %r{\Asrc/(?<files>.+)\Z} - def compile(str, requirements = {}, separators = [], anchor = true) - return Regexp.compile(str) if str.is_a?(Regexp) - - requirements = requirements ? requirements.dup : {} - normalize_requirements!(requirements, separators) - - parser = StrexpParser.new - parser.anchor = anchor - parser.requirements = requirements - - begin - re = parser.scan_str(str) - rescue Racc::ParseError => e - raise RegexpError, e.message - end - - Regexp.compile(re) - end - alias_method :new, :compile - - private - def normalize_requirements!(requirements, separators) - requirements.each do |key, value| - if value.is_a?(Regexp) - if regexp_has_modifiers?(value) - requirements[key] = value - else - requirements[key] = value.source - end - else - requirements[key] = Regexp.escape(value) - end - end - requirements.default ||= separators.any? ? - "[^#{separators.join}]+" : '.+' - requirements - end - - def regexp_has_modifiers?(regexp) - regexp.options & (Regexp::IGNORECASE | Regexp::EXTENDED) != 0 - end - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.rb deleted file mode 100644 index cfe05afc61..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.rb +++ /dev/null @@ -1,160 +0,0 @@ -# -# DO NOT MODIFY!!!! -# This file is automatically generated by Racc 1.4.6 -# from Racc grammer file "". -# - -require 'racc/parser.rb' - -require 'rack/mount/utils' -require 'rack/mount/strexp/tokenizer' - -module Rack - module Mount - class StrexpParser < Racc::Parser - - -if Regin.regexp_supports_named_captures? - REGEXP_NAMED_CAPTURE = '(?<%s>%s)'.freeze -else - REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze -end - -attr_accessor :anchor, :requirements -##### State transition tables begin ### - -racc_action_table = [ - 1, 2, 3, 9, 4, 1, 2, 3, 12, 4, - 1, 2, 3, 11, 4, 1, 2, 3, nil, 4 ] - -racc_action_check = [ - 0, 0, 0, 5, 0, 3, 3, 3, 9, 3, - 8, 8, 8, 8, 8, 6, 6, 6, nil, 6 ] - -racc_action_pointer = [ - -2, nil, nil, 3, nil, 3, 13, nil, 8, 8, - nil, nil, nil ] - -racc_action_default = [ - -8, -4, -5, -8, -7, -8, -1, -3, -8, -8, - -2, -6, 13 ] - -racc_goto_table = [ - 6, 5, 10, 8, 10 ] - -racc_goto_check = [ - 2, 1, 3, 2, 3 ] - -racc_goto_pointer = [ - nil, 1, 0, -4 ] - -racc_goto_default = [ - nil, nil, nil, 7 ] - -racc_reduce_table = [ - 0, 0, :racc_error, - 1, 8, :_reduce_1, - 2, 9, :_reduce_2, - 1, 9, :_reduce_none, - 1, 10, :_reduce_4, - 1, 10, :_reduce_5, - 3, 10, :_reduce_6, - 1, 10, :_reduce_7 ] - -racc_reduce_n = 8 - -racc_shift_n = 13 - -racc_token_table = { - false => 0, - :error => 1, - :PARAM => 2, - :GLOB => 3, - :LPAREN => 4, - :RPAREN => 5, - :CHAR => 6 } - -racc_nt_base = 7 - -racc_use_result_var = true - -Racc_arg = [ - racc_action_table, - racc_action_check, - racc_action_default, - racc_action_pointer, - racc_goto_table, - racc_goto_check, - racc_goto_default, - racc_goto_pointer, - racc_nt_base, - racc_reduce_table, - racc_token_table, - racc_shift_n, - racc_reduce_n, - racc_use_result_var ] - -Racc_token_to_s_table = [ - "$end", - "error", - "PARAM", - "GLOB", - "LPAREN", - "RPAREN", - "CHAR", - "$start", - "target", - "expr", - "token" ] - -Racc_debug_parser = false - -##### State transition tables end ##### - -# reduce 0 omitted - -def _reduce_1(val, _values, result) - result = anchor ? "\\A#{val.join}\\Z" : "\\A#{val.join}" - result -end - -def _reduce_2(val, _values, result) - result = val.join - result -end - -# reduce 3 omitted - -def _reduce_4(val, _values, result) - name = val[0].to_sym - requirement = requirements[name] - result = REGEXP_NAMED_CAPTURE % [name, requirement] - - result -end - -def _reduce_5(val, _values, result) - name = val[0].to_sym - requirement = requirements[name] - result = REGEXP_NAMED_CAPTURE % [name, '.+' || requirement] - - result -end - -def _reduce_6(val, _values, result) - result = "(?:#{val[1]})?" - result -end - -def _reduce_7(val, _values, result) - result = Regexp.escape(val[0]) - result -end - -def _reduce_none(val, _values, result) - val[0] -end - - end # class StrexpParser - end # module Mount -end # module Rack diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.y b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.y deleted file mode 100644 index ffbd9fae11..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.y +++ /dev/null @@ -1,34 +0,0 @@ -class Rack::Mount::StrexpParser -rule - target: expr { result = anchor ? "\\A#{val.join}\\Z" : "\\A#{val.join}" } - - expr: expr token { result = val.join } - | token - - token: PARAM { - name = val[0].to_sym - requirement = requirements[name] - result = REGEXP_NAMED_CAPTURE % [name, requirement] - } - | GLOB { - name = val[0].to_sym - requirement = requirements[name] - result = REGEXP_NAMED_CAPTURE % [name, '.+' || requirement] - } - | LPAREN expr RPAREN { result = "(?:#{val[1]})?" } - | CHAR { result = Regexp.escape(val[0]) } -end - ----- header ---- -require 'rack/mount/utils' -require 'rack/mount/strexp/tokenizer' - ----- inner - -if Regin.regexp_supports_named_captures? - REGEXP_NAMED_CAPTURE = '(?<%s>%s)'.freeze -else - REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze -end - -attr_accessor :anchor, :requirements diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rb deleted file mode 100644 index 0ff7f67661..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rb +++ /dev/null @@ -1,83 +0,0 @@ -#-- -# DO NOT MODIFY!!!! -# This file is automatically generated by rex 1.0.5.beta1 -# from lexical definition file "lib/rack/mount/strexp/tokenizer.rex". -#++ - -require 'racc/parser' -class Rack::Mount::StrexpParser < Racc::Parser - require 'strscan' - - class ScanError < StandardError ; end - - attr_reader :lineno - attr_reader :filename - attr_accessor :state - - def scan_setup(str) - @ss = StringScanner.new(str) - @lineno = 1 - @state = nil - end - - def action - yield - end - - def scan_str(str) - scan_setup(str) - do_parse - end - alias :scan :scan_str - - def load_file( filename ) - @filename = filename - open(filename, "r") do |f| - scan_setup(f.read) - end - end - - def scan_file( filename ) - load_file(filename) - do_parse - end - - - def next_token - return if @ss.eos? - - text = @ss.peek(1) - @lineno += 1 if text == "\n" - token = case @state - when nil - case - when (text = @ss.scan(/\\(\(|\)|:|\*)/)) - action { [:CHAR, @ss[1]] } - - when (text = @ss.scan(/\:([a-zA-Z_]\w*)/)) - action { [:PARAM, @ss[1]] } - - when (text = @ss.scan(/\*([a-zA-Z_]\w*)/)) - action { [:GLOB, @ss[1]] } - - when (text = @ss.scan(/\(/)) - action { [:LPAREN, text] } - - when (text = @ss.scan(/\)/)) - action { [:RPAREN, text] } - - when (text = @ss.scan(/./)) - action { [:CHAR, text] } - - else - text = @ss.string[@ss.pos .. -1] - raise ScanError, "can not match: '" + text + "'" - end # if - - else - raise ScanError, "undefined state: '" + state.to_s + "'" - end # case state - token - end # def next_token - -end # class diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rex b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rex deleted file mode 100644 index 473bd096e1..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rex +++ /dev/null @@ -1,12 +0,0 @@ -class Rack::Mount::StrexpParser -macro - RESERVED \(|\)|:|\* - ALPHA_U [a-zA-Z_] -rule - \\({RESERVED}) { [:CHAR, @ss[1]] } - \:({ALPHA_U}\w*) { [:PARAM, @ss[1]] } - \*({ALPHA_U}\w*) { [:GLOB, @ss[1]] } - \( { [:LPAREN, text] } - \) { [:RPAREN, text] } - . { [:CHAR, text] } -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/utils.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/utils.rb deleted file mode 100644 index aa23b1162f..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/utils.rb +++ /dev/null @@ -1,148 +0,0 @@ -begin - require 'regin' -rescue LoadError - $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/regin')) - require 'regin' -end - -require 'uri' - -module Rack::Mount - # Private utility methods used throughout Rack::Mount. - #-- - # This module is a trash can. Try to move these functions into - # more appropriate contexts. - #++ - module Utils - # Normalizes URI path. - # - # Strips off trailing slash and ensures there is a leading slash. - # - # normalize_path("/foo") # => "/foo" - # normalize_path("/foo/") # => "/foo" - # normalize_path("foo") # => "/foo" - # normalize_path("") # => "/" - def normalize_path(path) - path = "/#{path}" - path.squeeze!('/') - path.sub!(%r{/+\Z}, '') - path = '/' if path == '' - path - end - module_function :normalize_path - - # Removes trailing nils from array. - # - # pop_trailing_nils!([1, 2, 3]) # => [1, 2, 3] - # pop_trailing_nils!([1, 2, 3, nil, nil]) # => [1, 2, 3] - # pop_trailing_nils!([nil]) # => [] - def pop_trailing_nils!(ary) - while ary.length > 0 && ary.last.nil? - ary.pop - end - ary - end - module_function :pop_trailing_nils! - - RESERVED_PCHAR = ':@&=+$,;%' - SAFE_PCHAR = "#{URI::REGEXP::PATTERN::UNRESERVED}#{RESERVED_PCHAR}" - if RUBY_VERSION >= '1.9' - UNSAFE_PCHAR = Regexp.new("[^#{SAFE_PCHAR}]", false).freeze - else - UNSAFE_PCHAR = Regexp.new("[^#{SAFE_PCHAR}]", false, 'N').freeze - end - - Parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI - - def escape_uri(uri) - Parser.escape(uri.to_s, UNSAFE_PCHAR) - end - module_function :escape_uri - - if ''.respond_to?(:force_encoding) - def unescape_uri(uri) - Parser.unescape(uri).force_encoding('utf-8') - end - else - def unescape_uri(uri) - URI.unescape(uri) - end - end - module_function :unescape_uri - - # Taken from Rack 1.1.x to build nested query strings - def build_nested_query(value, prefix = nil) #:nodoc: - case value - when Array - value.map { |v| - build_nested_query(v, "#{prefix}[]") - }.join("&") - when Hash - value.map { |k, v| - build_nested_query(v, prefix ? "#{prefix}[#{Rack::Utils.escape(k)}]" : Rack::Utils.escape(k)) - }.join("&") - when String - raise ArgumentError, "value must be a Hash" if prefix.nil? - "#{prefix}=#{Rack::Utils.escape(value)}" - else - prefix - end - end - module_function :build_nested_query - - # Determines whether the regexp must match the entire string. - # - # regexp_anchored?(/^foo$/) # => true - # regexp_anchored?(/foo/) # => false - # regexp_anchored?(/^foo/) # => false - # regexp_anchored?(/foo$/) # => false - def regexp_anchored?(regexp) - regexp.source =~ /\A(\\A|\^).*(\\Z|\$)\Z/m ? true : false - end - module_function :regexp_anchored? - - def normalize_extended_expression(regexp) - return regexp unless regexp.options & Regexp::EXTENDED != 0 - source = regexp.source - source.gsub!(/#.+$/, '') - source.gsub!(/\s+/, '') - source.gsub!(/\\\//, '/') - Regexp.compile(source) - end - module_function :normalize_extended_expression - - def parse_regexp(regexp) - cache = @@_parse_regexp_cache ||= {} - - if expression = cache[regexp] - return expression - end - - unless regexp.is_a?(RegexpWithNamedGroups) - regexp = RegexpWithNamedGroups.new(regexp) - end - - expression = Regin.parse(regexp) - - unless Regin.regexp_supports_named_captures? - tag_captures = Proc.new do |group| - case group - when Regin::Group - # TODO: dup instead of mutating - group.instance_variable_set('@name', regexp.names[group.index]) if group.index - tag_captures.call(group.expression) - when Regin::Expression - group.each { |child| tag_captures.call(child) } - end - end - tag_captures.call(expression) - end - - cache[regexp] = expression.freeze - expression - rescue Racc::ParseError, Regin::Parser::ScanError - [] - end - module_function :parse_regexp - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multimap.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multimap.rb deleted file mode 100644 index 0b49b49280..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multimap.rb +++ /dev/null @@ -1,569 +0,0 @@ -require 'forwardable' -require 'multiset' - -# Multimap is a generalization of a map or associative array -# abstract data type in which more than one value may be associated -# with and returned for a given key. -# -# == Example -# -# require 'multimap' -# map = Multimap.new -# map["a"] = 100 -# map["b"] = 200 -# map["a"] = 300 -# map["a"] # -> [100, 300] -# map["b"] # -> [200] -# map.keys # -> #<Multiset: {a, a, b}> -class Multimap - extend Forwardable - - include Enumerable - - # call-seq: - # Multimap[ [key =>|, value]* ] => multimap - # - # Creates a new multimap populated with the given objects. - # - # Multimap["a", 100, "b", 200] #=> {"a"=>[100], "b"=>[200]} - # Multimap["a" => 100, "b" => 200] #=> {"a"=>[100], "b"=>[200]} - def self.[](*args) - default = [] - - if args.size == 2 && args.last.is_a?(Hash) - default = args.shift - elsif !args.first.is_a?(Hash) && args.size % 2 == 1 - default = args.shift - end - - if args.size == 1 && args.first.is_a?(Hash) - args[0] = args.first.inject({}) { |hash, (key, value)| - unless value.is_a?(default.class) - value = (default.dup << value) - end - hash[key] = value - hash - } - else - index = 0 - args.map! { |value| - unless index % 2 == 0 || value.is_a?(default.class) - value = (default.dup << value) - end - index += 1 - value - } - end - - map = new - map.instance_variable_set(:@hash, Hash[*args]) - map.default = default - map - end - - # call-seq: - # Multimap.new => multimap - # Multimap.new(default) => multimap - # - # Returns a new, empty multimap. - # - # map = Multimap.new(Set.new) - # h["a"] = 100 - # h["b"] = 200 - # h["a"] #=> [100].to_set - # h["c"] #=> [].to_set - def initialize(default = []) - @hash = Hash.new(default) - end - - def initialize_copy(original) #:nodoc: - @hash = Hash.new(original.default.dup) - original._internal_hash.each_pair do |key, container| - @hash[key] = container.dup - end - end - - def_delegators :@hash, :clear, :default, :default=, :empty?, - :fetch, :has_key?, :key? - - # Retrieves the <i>value</i> object corresponding to the - # <i>*keys</i> object. - def [](key) - @hash[key] - end - - # call-seq: - # map[key] = value => value - # map.store(key, value) => value - # - # Associates the value given by <i>value</i> with the key - # given by <i>key</i>. Unlike a regular hash, multiple can be - # assoicated with the same value. - # - # map = Multimap["a" => 100, "b" => 200] - # map["a"] = 9 - # map["c"] = 4 - # map #=> {"a" => [100, 9], "b" => [200], "c" => [4]} - def store(key, value) - update_container(key) do |container| - container << value - container - end - end - alias_method :[]=, :store - - # call-seq: - # map.delete(key, value) => value - # map.delete(key) => value - # - # Deletes and returns a key-value pair from <i>map</i>. If only - # <i>key</i> is given, all the values matching that key will be - # deleted. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.delete("b", 300) #=> 300 - # map.delete("a") #=> [100] - def delete(key, value = nil) - if value - @hash[key].delete(value) - else - @hash.delete(key) - end - end - - # call-seq: - # map.each { |key, value| block } => map - # - # Calls <i>block</i> for each key/value pair in <i>map</i>, passing - # the key and value to the block as a two-element array. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.each { |key, value| puts "#{key} is #{value}" } - # - # <em>produces:</em> - # - # a is 100 - # b is 200 - # b is 300 - def each - each_pair do |key, value| - yield [key, value] - end - end - - # call-seq: - # map.each_association { |key, container| block } => map - # - # Calls <i>block</i> once for each key/container in <i>map</i>, passing - # the key and container to the block as parameters. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.each_association { |key, container| puts "#{key} is #{container}" } - # - # <em>produces:</em> - # - # a is [100] - # b is [200, 300] - def each_association(&block) - @hash.each_pair(&block) - end - - # call-seq: - # map.each_container { |container| block } => map - # - # Calls <i>block</i> for each container in <i>map</i>, passing the - # container as a parameter. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.each_container { |container| puts container } - # - # <em>produces:</em> - # - # [100] - # [200, 300] - def each_container - each_association do |_, container| - yield container - end - end - - # call-seq: - # map.each_key { |key| block } => map - # - # Calls <i>block</i> for each key in <i>hsh</i>, passing the key - # as a parameter. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.each_key { |key| puts key } - # - # <em>produces:</em> - # - # a - # b - # b - def each_key - each_pair do |key, _| - yield key - end - end - - # call-seq: - # map.each_pair { |key_value_array| block } => map - # - # Calls <i>block</i> for each key/value pair in <i>map</i>, - # passing the key and value as parameters. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.each_pair { |key, value| puts "#{key} is #{value}" } - # - # <em>produces:</em> - # - # a is 100 - # b is 200 - # b is 300 - def each_pair - each_association do |key, values| - values.each do |value| - yield key, value - end - end - end - - # call-seq: - # map.each_value { |value| block } => map - # - # Calls <i>block</i> for each key in <i>map</i>, passing the - # value as a parameter. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.each_value { |value| puts value } - # - # <em>produces:</em> - # - # 100 - # 200 - # 300 - def each_value - each_pair do |_, value| - yield value - end - end - - def ==(other) #:nodoc: - case other - when Multimap - @hash == other._internal_hash - else - @hash == other - end - end - - def eql?(other) #:nodoc: - case other - when Multimap - @hash.eql?(other._internal_hash) - else - @hash.eql?(other) - end - end - - def freeze #:nodoc: - each_container { |container| container.freeze } - default.freeze - super - end - - # call-seq: - # map.has_value?(value) => true or false - # map.value?(value) => true or false - # - # Returns <tt>true</tt> if the given value is present for any key - # in <i>map</i>. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.has_value?(300) #=> true - # map.has_value?(999) #=> false - def has_value?(value) - values.include?(value) - end - alias_method :value?, :has_value? - - # call-seq: - # map.index(value) => key - # - # Returns the key for a given value. If not found, returns - # <tt>nil</tt>. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.index(100) #=> "a" - # map.index(200) #=> "b" - # map.index(999) #=> nil - def index(value) - invert[value] - end - - # call-seq: - # map.delete_if {| key, value | block } -> map - # - # Deletes every key-value pair from <i>map</i> for which <i>block</i> - # evaluates to <code>true</code>. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.delete_if {|key, value| value >= 300 } - # #=> Multimap["a" => 100, "b" => 200] - # - def delete_if - each_association do |key, container| - container.delete_if do |value| - yield [key, value] - end - end - self - end - - # call-seq: - # map.reject {| key, value | block } -> map - # - # Same as <code>Multimap#delete_if</code>, but works on (and returns) a - # copy of the <i>map</i>. Equivalent to - # <code><i>map</i>.dup.delete_if</code>. - # - def reject(&block) - dup.delete_if(&block) - end - - # call-seq: - # map.reject! {| key, value | block } -> map or nil - # - # Equivalent to <code>Multimap#delete_if</code>, but returns - # <code>nil</code> if no changes were made. - # - def reject!(&block) - old_size = size - delete_if(&block) - old_size == size ? nil : self - end - - # call-seq: - # map.replace(other_map) => map - # - # Replaces the contents of <i>map</i> with the contents of - # <i>other_map</i>. - # - # map = Multimap["a" => 100, "b" => 200] - # map.replace({ "c" => 300, "d" => 400 }) - # #=> Multimap["c" => 300, "d" => 400] - def replace(other) - case other - when Array - @hash.replace(self.class[self.default, *other]) - when Hash - @hash.replace(self.class[self.default, other]) - when self.class - @hash.replace(other) - else - raise ArgumentError - end - end - - # call-seq: - # map.invert => multimap - # - # Returns a new multimap created by using <i>map</i>'s values as keys, - # and the keys as values. - # - # map = Multimap["n" => 100, "m" => 100, "d" => [200, 300]] - # map.invert #=> Multimap[100 => ["n", "m"], 200 => "d", 300 => "d"] - def invert - h = self.class.new(default.dup) - each_pair { |key, value| h[value] = key } - h - end - - # call-seq: - # map.keys => multiset - # - # Returns a new +Multiset+ populated with the keys from this hash. See also - # <tt>Multimap#values</tt> and <tt>Multimap#containers</tt>. - # - # map = Multimap["a" => 100, "b" => [200, 300], "c" => 400] - # map.keys #=> Multiset.new(["a", "b", "b", "c"]) - def keys - keys = Multiset.new - each_key { |key| keys << key } - keys - end - - # Returns true if the given key is present in Multimap. - def include?(key) - keys.include?(key) - end - alias_method :member?, :include? - - # call-seq: - # map.length => fixnum - # map.size => fixnum - # - # Returns the number of key-value pairs in the map. - # - # map = Multimap["a" => 100, "b" => [200, 300], "c" => 400] - # map.length #=> 4 - # map.delete("a") #=> 100 - # map.length #=> 3 - def size - values.size - end - alias_method :length, :size - - # call-seq: - # map.merge(other_map) => multimap - # - # Returns a new multimap containing the contents of <i>other_map</i> and - # the contents of <i>map</i>. - # - # map1 = Multimap["a" => 100, "b" => 200] - # map2 = Multimap["a" => 254, "c" => 300] - # map2.merge(map2) #=> Multimap["a" => 100, "b" => [200, 254], "c" => 300] - # map1 #=> Multimap["a" => 100, "b" => 200] - def merge(other) - dup.update(other) - end - - # call-seq: - # map.merge!(other_map) => multimap - # map.update(other_map) => multimap - # - # Adds each pair from <i>other_map</i> to <i>map</i>. - # - # map1 = Multimap["a" => 100, "b" => 200] - # map2 = Multimap["b" => 254, "c" => 300] - # - # map1.merge!(map2) - # #=> Multimap["a" => 100, "b" => [200, 254], "c" => 300] - def update(other) - case other - when self.class - other.each_pair { |key, value| store(key, value) } - when Hash - update(self.class[self.default, other]) - else - raise ArgumentError - end - self - end - alias_method :merge!, :update - - # call-seq: - # map.select { |key, value| block } => multimap - # - # Returns a new Multimap consisting of the pairs for which the - # block returns true. - # - # map = Multimap["a" => 100, "b" => 200, "c" => 300] - # map.select { |k,v| k > "a" } #=> Multimap["b" => 200, "c" => 300] - # map.select { |k,v| v < 200 } #=> Multimap["a" => 100] - def select - inject(self.class.new) { |map, (key, value)| - map[key] = value if yield([key, value]) - map - } - end - - # call-seq: - # map.to_a => array - # - # Converts <i>map</i> to a nested array of [<i>key, - # value</i>] arrays. - # - # map = Multimap["a" => 100, "b" => [200, 300], "c" => 400] - # map.to_a #=> [["a", 100], ["b", 200], ["b", 300], ["c", 400]] - def to_a - ary = [] - each_pair do |key, value| - ary << [key, value] - end - ary - end - - # call-seq: - # map.to_hash => hash - # - # Converts <i>map</i> to a basic hash. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.to_hash #=> { "a" => [100], "b" => [200, 300] } - def to_hash - @hash.dup - end - - # call-seq: - # map.containers => array - # - # Returns a new array populated with the containers from <i>map</i>. See - # also <tt>Multimap#keys</tt> and <tt>Multimap#values</tt>. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.containers #=> [[100], [200, 300]] - def containers - containers = [] - each_container { |container| containers << container } - containers - end - - # call-seq: - # map.values => array - # - # Returns a new array populated with the values from <i>map</i>. See - # also <tt>Multimap#keys</tt> and <tt>Multimap#containers</tt>. - # - # map = Multimap["a" => 100, "b" => [200, 300]] - # map.values #=> [100, 200, 300] - def values - values = [] - each_value { |value| values << value } - values - end - - # Return an array containing the values associated with the given keys. - def values_at(*keys) - @hash.values_at(*keys) - end - - def marshal_dump #:nodoc: - @hash - end - - def marshal_load(hash) #:nodoc: - @hash = hash - end - - def to_yaml(opts = {}) #:nodoc: - YAML::quick_emit(self, opts) do |out| - out.map(taguri, to_yaml_style) do |map| - @hash.each do |k, v| - map.add(k, v) - end - map.add('__default__', @hash.default) - end - end - end - - def yaml_initialize(tag, val) #:nodoc: - default = val.delete('__default__') - @hash = val - @hash.default = default - self - end - - protected - def _internal_hash #:nodoc: - @hash - end - - def update_container(key) #:nodoc: - container = @hash[key] - container = container.dup if container.equal?(default) - container = yield(container) - @hash[key] = container - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multiset.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multiset.rb deleted file mode 100644 index 119bf12646..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multiset.rb +++ /dev/null @@ -1,185 +0,0 @@ -require 'set' - -# Multiset implements a collection of unordered values and -# allows duplicates. -# -# == Example -# -# require 'multiset' -# s1 = Multiset.new [1, 2] # -> #<Multiset: {1, 2}> -# s1.add(2) # -> #<Multiset: {1, 2, 2}> -# s1.merge([2, 6]) # -> #<Multiset: {1, 2, 2, 2, 3}> -# s1.multiplicity(2) # -> 3 -# s1.multiplicity(3) # -> 1 -class Multiset < Set - def initialize(*args, &block) #:nodoc: - @hash = Hash.new(0) - super - end - - # Returns the number of times an element belongs to the multiset. - def multiplicity(e) - @hash[e] - end - - # Returns the total number of elements in a multiset, including - # repeated memberships - def cardinality - @hash.inject(0) { |s, (e, m)| s += m } - end - alias_method :size, :cardinality - alias_method :length, :cardinality - - # Converts the set to an array. The order of elements is uncertain. - def to_a - inject([]) { |ary, (key, _)| ary << key } - end - - # Returns true if the set is a superset of the given set. - def superset?(set) - set.is_a?(self.class) or raise ArgumentError, "value must be a set" - return false if cardinality < set.cardinality - set.all? { |o| set.multiplicity(o) <= multiplicity(o) } - end - - # Returns true if the set is a proper superset of the given set. - def proper_superset?(set) - set.is_a?(self.class) or raise ArgumentError, "value must be a set" - return false if cardinality <= set.cardinality - set.all? { |o| set.multiplicity(o) <= multiplicity(o) } - end - - # Returns true if the set is a subset of the given set. - def subset?(set) - set.is_a?(self.class) or raise ArgumentError, "value must be a set" - return false if set.cardinality < cardinality - all? { |o| multiplicity(o) <= set.multiplicity(o) } - end - - # Returns true if the set is a proper subset of the given set. - def proper_subset?(set) - set.is_a?(self.class) or raise ArgumentError, "value must be a set" - return false if set.cardinality <= cardinality - all? { |o| multiplicity(o) <= set.multiplicity(o) } - end - - # Calls the given block once for each element in the set, passing - # the element as parameter. Returns an enumerator if no block is - # given. - def each - @hash.each_pair do |key, multiplicity| - multiplicity.times do - yield(key) - end - end - self - end - - # Adds the given object to the set and returns self. Use +merge+ to - # add many elements at once. - def add(o) - @hash[o] ||= 0 - @hash[o] += 1 - self - end - alias << add - - undef :add? - - # Deletes all the identical object from the set and returns self. - # If +n+ is given, it will remove that amount of identical objects - # from the set. Use +subtract+ to delete many different items at - # once. - def delete(o, n = nil) - if n - @hash[o] ||= 0 - @hash[o] -= n if @hash[o] > 0 - @hash.delete(o) if @hash[o] == 0 - else - @hash.delete(o) - end - self - end - - undef :delete? - - # Deletes every element of the set for which block evaluates to - # true, and returns self. - def delete_if - each { |o| delete(o) if yield(o) } - self - end - - # Merges the elements of the given enumerable object to the set and - # returns self. - def merge(enum) - enum.each { |o| add(o) } - self - end - - # Deletes every element that appears in the given enumerable object - # and returns self. - def subtract(enum) - enum.each { |o| delete(o, 1) } - self - end - - # Returns a new set containing elements common to the set and the - # given enumerable object. - def &(enum) - s = dup - n = self.class.new - enum.each { |o| - if s.include?(o) - s.delete(o, 1) - n.add(o) - end - } - n - end - alias intersection & - - # Returns a new set containing elements exclusive between the set - # and the given enumerable object. (set ^ enum) is equivalent to - # ((set | enum) - (set & enum)). - def ^(enum) - n = self.class.new(enum) - each { |o| n.include?(o) ? n.delete(o, 1) : n.add(o) } - n - end - - # Returns true if two sets are equal. Two multisets are equal if - # they have the same cardinalities and each element has the same - # multiplicity in both sets. The equality of each element inside - # the multiset is defined according to Object#eql?. - def eql?(set) - return true if equal?(set) - set = self.class.new(set) unless set.is_a?(self.class) - return false unless cardinality == set.cardinality - superset?(set) && subset?(set) - end - alias_method :==, :eql? - - def marshal_dump #:nodoc: - @hash - end - - def marshal_load(hash) #:nodoc: - @hash = hash - end - - def to_yaml(opts = {}) #:nodoc: - YAML::quick_emit(self, opts) do |out| - out.map(taguri, to_yaml_style) do |map| - @hash.each do |k, v| - map.add(k, v) - end - end - end - end - - def yaml_initialize(tag, val) #:nodoc: - @hash = val - self - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/nested_multimap.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/nested_multimap.rb deleted file mode 100644 index 4eb088b91a..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/nested_multimap.rb +++ /dev/null @@ -1,158 +0,0 @@ -require 'multimap' - -# NestedMultimap allows values to be assoicated with a nested -# set of keys. -class NestedMultimap < Multimap - # call-seq: - # multimap[*keys] = value => value - # multimap.store(*keys, value) => value - # - # Associates the value given by <i>value</i> with multiple key - # given by <i>keys</i>. - # - # map = NestedMultimap.new - # map["a"] = 100 - # map["a", "b"] = 101 - # map["a"] = 102 - # map #=> {"a"=>{"b"=>[100, 101, 102], default => [100, 102]}} - def store(*args) - keys = args - value = args.pop - - raise ArgumentError, 'wrong number of arguments (1 for 2)' unless value - - if keys.length > 1 - update_container(keys.shift) do |container| - container = self.class.new(container) unless container.is_a?(self.class) - container[*keys] = value - container - end - elsif keys.length == 1 - super(keys.first, value) - else - self << value - end - end - alias_method :[]=, :store - - # call-seq: - # multimap << obj => multimap - # - # Pushes the given object on to the end of all the containers. - # - # map = NestedMultimap["a" => [100], "b" => [200, 300]] - # map << 300 - # map["a"] #=> [100, 300] - # map["c"] #=> [300] - def <<(value) - @hash.each_value { |container| container << value } - self.default << value - self - end - - # call-seq: - # multimap[*keys] => value - # multimap[key1, key2, key3] => value - # - # Retrieves the <i>value</i> object corresponding to the - # <i>*keys</i> object. - def [](*keys) - i, l, r, k = 0, keys.length, self, self.class - while r.is_a?(k) - r = i < l ? r._internal_hash[keys[i]] : r.default - i += 1 - end - r - end - - # call-seq: - # multimap.each_association { |key, container| block } => multimap - # - # Calls <i>block</i> once for each key/container in <i>map</i>, passing - # the key and container to the block as parameters. - # - # map = NestedMultimap.new - # map["a"] = 100 - # map["a", "b"] = 101 - # map["a"] = 102 - # map["c"] = 200 - # map.each_association { |key, container| puts "#{key} is #{container}" } - # - # <em>produces:</em> - # - # ["a", "b"] is [100, 101, 102] - # "c" is [200] - def each_association - super() do |key, container| - if container.respond_to?(:each_association) - container.each_association do |nested_key, value| - yield [key, nested_key].flatten, value - end - else - yield key, container - end - end - end - - # call-seq: - # multimap.each_container_with_default { |container| block } => map - # - # Calls <i>block</i> for every container in <i>map</i> including - # the default, passing the container as a parameter. - # - # map = NestedMultimap.new - # map["a"] = 100 - # map["a", "b"] = 101 - # map["a"] = 102 - # map.each_container_with_default { |container| puts container } - # - # <em>produces:</em> - # - # [100, 101, 102] - # [100, 102] - # [] - def each_container_with_default(&block) - @hash.each_value do |container| - iterate_over_container(container, &block) - end - iterate_over_container(default, &block) - self - end - - # call-seq: - # multimap.containers_with_default => array - # - # Returns a new array populated with all the containers from - # <i>map</i> including the default. - # - # map = NestedMultimap.new - # map["a"] = 100 - # map["a", "b"] = 101 - # map["a"] = 102 - # map.containers_with_default #=> [[100, 101, 102], [100, 102], []] - def containers_with_default - containers = [] - each_container_with_default { |container| containers << container } - containers - end - - def inspect #:nodoc: - super.gsub(/\}$/, ", default => #{default.inspect}}") - end - - private - def iterate_over_container(container) - if container.respond_to?(:each_container_with_default) - container.each_container_with_default do |value| - yield value - end - else - yield container - end - end -end - -begin - require 'nested_multimap_ext' -rescue LoadError -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin.rb deleted file mode 100644 index d38922bcc6..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin.rb +++ /dev/null @@ -1,45 +0,0 @@ -module Regin - autoload :Alternation, 'regin/alternation' - autoload :Anchor, 'regin/anchor' - autoload :Atom, 'regin/atom' - autoload :Character, 'regin/character' - autoload :CharacterClass, 'regin/character_class' - autoload :Collection, 'regin/collection' - autoload :Expression, 'regin/expression' - autoload :Group, 'regin/group' - autoload :Options, 'regin/options' - autoload :Parser, 'regin/parser' - - class << self - begin - eval('foo = /(?<foo>.*)/').named_captures - - # Returns true if the interpreter is using the Oniguruma Regexp lib - # and supports named captures. - # - # /(?<foo>bar)/ - def regexp_supports_named_captures? - true - end - rescue SyntaxError, NoMethodError - def regexp_supports_named_captures? #:nodoc: - false - end - end - - # Parses Regexp and returns a Expression data structure. - def parse(regexp) - Parser.parse_regexp(regexp) - end - - # Recompiles Regexp by parsing it and turning it back into a Regexp. - # - # (In the future Regin will perform some Regexp optimizations - # such as removing unnecessary captures and options) - def compile(source) - regexp = Regexp.compile(source) - expression = parse(regexp) - Regexp.compile(expression.to_s(true), expression.flags) - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/alternation.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/alternation.rb deleted file mode 100644 index ce4f52bfdb..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/alternation.rb +++ /dev/null @@ -1,40 +0,0 @@ -module Regin - class Alternation < Collection - def initialize(*args) - args, options = extract_options(args) - - if args.length == 1 && args.first.instance_of?(Array) - super(args.first) - else - super(args) - end - - if options.key?(:ignorecase) - @array.map! { |e| e.dup(:ignorecase => options[:ignorecase]) } - end - end - - # Returns true if expression could be treated as a literal string. - # - # Alternation groups are never literal. - def literal? - false - end - - def flags - 0 - end - - def dup(options = {}) - self.class.new(to_a, options) - end - - def to_s(parent = false) - map { |e| e.to_s(parent) }.join('|') - end - - def inspect #:nodoc: - to_s.inspect - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/anchor.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/anchor.rb deleted file mode 100644 index 05520dd5e0..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/anchor.rb +++ /dev/null @@ -1,4 +0,0 @@ -module Regin - class Anchor < Atom - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/atom.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/atom.rb deleted file mode 100644 index eb1923a5a1..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/atom.rb +++ /dev/null @@ -1,59 +0,0 @@ -module Regin - class Atom - attr_reader :value, :ignorecase - - def initialize(value, options = {}) - @value = value - @ignorecase = options[:ignorecase] - end - - def option_names - %w( ignorecase ) - end - - # Returns true if expression could be treated as a literal string. - def literal? - false - end - - def casefold? - ignorecase ? true : false - end - - def dup(options = {}) - original_options = option_names.inject({}) do |h, m| - h[m.to_sym] = send(m) - h - end - self.class.new(value, original_options.merge(options)) - end - - def to_s(parent = false) - "#{value}" - end - - def inspect #:nodoc: - "#<#{self.class.to_s.sub('Regin::', '')} #{to_s.inspect}>" - end - - def ==(other) #:nodoc: - case other - when String - other == to_s - else - eql?(other) - end - end - - def eql?(other) #:nodoc: - other.instance_of?(self.class) && - self.value.eql?(other.value) && - (!!self.ignorecase).eql?(!!other.ignorecase) - end - - def freeze #:nodoc: - value.freeze - super - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character.rb deleted file mode 100644 index 12a9199d2a..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character.rb +++ /dev/null @@ -1,56 +0,0 @@ -module Regin - class Character < Atom - attr_reader :quantifier - - def initialize(value, options = {}) - @quantifier = options[:quantifier] - super - end - - def option_names - %w( quantifier ) + super - end - - # Returns true if expression could be treated as a literal string. - # - # A Character is literal is there is no quantifier attached to it. - def literal? - quantifier.nil? && !ignorecase - end - - def to_s(parent = false) - if !parent && ignorecase - "(?i-mx:#{value})#{quantifier}" - else - "#{value}#{quantifier}" - end - end - - def to_regexp(anchored = false) - re = to_s(true) - re = "\\A#{re}\\Z" if anchored - Regexp.compile(re, ignorecase) - end - - def match(char) - to_regexp(true).match(char) - end - - def include?(char) - if ignorecase - value.downcase == char.downcase - else - value == char - end - end - - def eql?(other) #:nodoc: - super && quantifier.eql?(other.quantifier) - end - - def freeze #:nodoc: - quantifier.freeze if quantifier - super - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character_class.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character_class.rb deleted file mode 100644 index caed5ef9d0..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character_class.rb +++ /dev/null @@ -1,55 +0,0 @@ -module Regin - class CharacterClass < Character - def initialize(value, options = {}) - @negate = options[:negate] - super - end - - def option_names - %w( negate ) + super - end - - attr_reader :negate - - def negated? - negate ? true : false - end - - # Returns true if expression could be treated as a literal string. - # - # A CharacterClass is never literal. - def literal? - false - end - - def bracketed? - value != '.' && value !~ /^\\[dDsSwW]$/ - end - - def to_s(parent = false) - if bracketed? - if !parent && ignorecase - "(?i-mx:[#{negate && '^'}#{value}])#{quantifier}" - else - "[#{negate && '^'}#{value}]#{quantifier}" - end - else - super - end - end - - def include?(char) - re = quantifier ? to_s.sub(/#{Regexp.escape(quantifier)}$/, '') : to_s - Regexp.compile("\\A#{re}\\Z").match(char) - end - - def eql?(other) #:nodoc: - super && negate == other.negate - end - - def freeze #:nodoc: - negate.freeze if negate - super - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/collection.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/collection.rb deleted file mode 100644 index b60353268a..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/collection.rb +++ /dev/null @@ -1,83 +0,0 @@ -module Regin - class Collection - include Enumerable - - def initialize(*args) - @array = Array.new(*args) - end - - def each - @array.each{ |item| yield item } - end - - def [](i) - @array[i] - end - - def length - @array.length - end - alias_method :size, :length - - def first - @array.first - end - - def last - @array.last - end - - def +(other) - ary = other.is_a?(self.class) ? other.internal_array : other - self.class.new(@array + ary) - end - - def to_regexp(anchored = false) - re = to_s(true) - re = "\\A#{re}\\Z" if anchored - Regexp.compile(re, flags) - end - - def match(char) - to_regexp.match(char) - end - - def include?(char) - any? { |e| e.include?(char) } - end - - def ==(other) #:nodoc: - case other - when String - other == to_s - when Array - other == @array - else - eql?(other) - end - end - - def eql?(other) #:nodoc: - other.instance_of?(self.class) && @array.eql?(other.internal_array) - end - - def freeze #:nodoc: - each { |e| e.freeze } - @array.freeze - super - end - - protected - def internal_array #:nodoc: - @array - end - - def extract_options(args) - if args.last.is_a?(Hash) - return args[0..-2], args.last - else - return args, {} - end - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/expression.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/expression.rb deleted file mode 100644 index 18e4965097..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/expression.rb +++ /dev/null @@ -1,126 +0,0 @@ -module Regin - class Expression < Collection - attr_reader :ignorecase, :multiline, :extended - - def initialize(*args) - args, options = extract_options(args) - - @multiline = @ignorecase = @extended = nil - - if args.length == 1 && args.first.instance_of?(Array) - super(args.first) - else - args = args.map { |e| e.instance_of?(String) ? Character.new(e) : e } - super(args) - end - - self.multiline = options[:multiline] if options.key?(:multiline) - self.ignorecase = options[:ignorecase] if options.key?(:ignorecase) - self.extended = options[:extended] if options.key?(:extended) - end - - # Returns true if expression could be treated as a literal string. - # - # A Expression is literal if all its elements are literal. - def literal? - !ignorecase && all? { |e| e.literal? } - end - - def anchored? - anchored_to_start? && anchored_to_end? - end - - def anchored_to_start? - first.is_a?(Anchor) && first == '\A' - end - - def anchored_to_end? - last.is_a?(Anchor) && last == '\Z' - end - - def anchored_to_line? - anchored_to_start_of_line? && anchored_to_end_of_line? - end - - def anchored_to_start_of_line? - anchored_to_start? || (first.is_a?(Anchor) && first == '^') - end - - def anchored_to_end_of_line? - anchored_to_end? || (last.is_a?(Anchor) && last == '$') - end - - def options? - options.any?(true) - end - - def flags - options.to_i - end - - def +(other) - ary = other.is_a?(self.class) ? other.internal_array : other - ary = @array + ary + [options.to_h(true)] - self.class.new(*ary) - end - - def dup(options = {}) - expression = super() - expression.multiline = options[:multiline] if options.key?(:multiline) - expression.ignorecase = options[:ignorecase] if options.key?(:ignorecase) - expression.extended = options[:extended] if options.key?(:extended) - expression - end - - def to_s(parent = false) - if parent || !options? - map { |e| e.to_s(parent) }.join - else - with, without = [], [] - multiline ? (with << 'm') : (without << 'm') - ignorecase ? (with << 'i') : (without << 'i') - extended ? (with << 'x') : (without << 'x') - - with = with.join - without = without.any? ? "-#{without.join}" : '' - - "(?#{with}#{without}:#{map { |e| e.to_s(true) }.join})" - end - end - - def inspect #:nodoc: - "#<Expression #{to_s.inspect}>" - end - - def casefold? - ignorecase - end - - def eql?(other) #:nodoc: - super && - !!self.multiline == !!other.multiline && - !!self.ignorecase == !!other.ignorecase && - !!self.extended == !!other.extended - end - - protected - def options - Options.new(multiline, ignorecase, extended) - end - - def multiline=(multiline) - @multiline = multiline - end - - def ignorecase=(ignorecase) - if @ignorecase.nil? - @array.map! { |e| e.dup(:ignorecase => ignorecase) } - @ignorecase = ignorecase - end - end - - def extended=(extended) - @extended = extended - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/group.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/group.rb deleted file mode 100644 index d682148bd9..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/group.rb +++ /dev/null @@ -1,90 +0,0 @@ -module Regin - class Group - attr_reader :expression, :quantifier, :capture, :index, :name - - def initialize(expression, options = {}) - @quantifier = @index = @name = nil - @capture = true - @expression = expression.dup(options) - - @quantifier = options[:quantifier] if options.key?(:quantifier) - @capture = options[:capture] if options.key?(:capture) - @index = options[:index] if options.key?(:index) - @name = options[:name] if options.key?(:name) - end - - def option_names - %w( quantifier capture index name ) - end - - # Returns true if expression could be treated as a literal string. - # - # A Group is literal if its expression is literal and it has no quantifier. - def literal? - quantifier.nil? && expression.literal? - end - - def to_s(parent = false) - if !expression.options? - "(#{capture ? '' : '?:'}#{expression.to_s(parent)})#{quantifier}" - elsif capture == false - "#{expression.to_s}#{quantifier}" - else - "(#{expression.to_s})#{quantifier}" - end - end - - def to_regexp(anchored = false) - re = to_s - re = "\\A#{re}\\Z" if anchored - Regexp.compile(re) - end - - def dup(options = {}) - original_options = option_names.inject({}) do |h, m| - h[m.to_sym] = send(m) - h - end - self.class.new(expression, original_options.merge(options)) - end - - def inspect #:nodoc: - to_s.inspect - end - - def match(char) - to_regexp.match(char) - end - - def include?(char) - expression.include?(char) - end - - def capture? - capture - end - - def ==(other) #:nodoc: - case other - when String - other == to_s - else - eql?(other) - end - end - - def eql?(other) #:nodoc: - other.is_a?(self.class) && - self.expression == other.expression && - self.quantifier == other.quantifier && - self.capture == other.capture && - self.index == other.index && - self.name == other.name - end - - def freeze #:nodoc: - expression.freeze if expression - super - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/options.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/options.rb deleted file mode 100644 index 03ba29d9a5..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/options.rb +++ /dev/null @@ -1,55 +0,0 @@ -module Regin - class Options - def self.from_int(flags) - multiline = flags & Regexp::MULTILINE != 0 - ignorecase = flags & Regexp::IGNORECASE != 0 - extended = flags & Regexp::EXTENDED != 0 - - new(multiline, ignorecase, extended) - end - - attr_reader :multiline, :ignorecase, :extended - - def initialize(*args) - if args.first.is_a?(Hash) - @multiline = args[0][:multiline] - @ignorecase = args[0][:ignorecase] - @extended = args[0][:extended] - else - @multiline = args[0] - @ignorecase = args[1] - @extended = args[2] - end - end - - def any?(explicit = false) - if explicit - !multiline.nil? || !ignorecase.nil? || !extended.nil? - else - multiline || ignorecase || extended - end - end - - def to_h(explicit = false) - if explicit - options = {} - options[:multiline] = multiline unless multiline.nil? - options[:ignorecase] = ignorecase unless ignorecase.nil? - options[:extended] = extended unless extended.nil? - options - else - { :multiline => multiline, - :ignorecase => ignorecase, - :extended => extended } - end - end - - def to_i - flag = 0 - flag |= Regexp::MULTILINE if multiline - flag |= Regexp::IGNORECASE if ignorecase - flag |= Regexp::EXTENDED if extended - flag - end - end -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/parser.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/parser.rb deleted file mode 100644 index 0bb9b87e9c..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/parser.rb +++ /dev/null @@ -1,415 +0,0 @@ -# -# DO NOT MODIFY!!!! -# This file is automatically generated by Racc 1.4.6 -# from Racc grammer file "". -# - -require 'racc/parser.rb' -module Regin - class Parser < Racc::Parser #:nodoc: all - -def self.parse_regexp(regexp) - options = Options.from_int(regexp.options) - - parser = new - parser.options_stack << options.to_h - - expression = parser.scan_str(regexp.source) - expression = expression.dup(options.to_h) if options.any? - expression -end - -attr_accessor :options_stack - -def initialize - @capture_index = 0 - @capture_index_stack = [] - @options_stack = [] -end - -##### State transition tables begin ### - -racc_action_table = [ - 2, 18, 19, 19, 8, 10, 11, 13, 48, 19, - 2, 45, 3, 5, 8, 10, 11, 13, 64, 47, - 2, 55, 3, 5, 8, 10, 11, 13, 29, 19, - 2, 16, 3, 5, 8, 10, 11, 13, 61, 19, - 2, 63, 3, 5, 8, 10, 11, 13, 60, 36, - 2, 34, 3, 5, 8, 10, 11, 13, 28, 49, - 2, nil, 3, 5, 8, 10, 11, 13, nil, nil, - 2, nil, 3, 5, 8, 10, 11, 13, nil, 26, - 42, 43, 3, 5, 37, 38, 40, 21, 44, 37, - 38, 40, 22, 23, 24, 14, nil, 15, 31, 32, - 16, nil, 33, 46, 32, nil, nil, 33, 51, 37, - 38, 40, 58, 37, 38, 40, 37, 38, 40, 37, - 38, 40, 37, 38, 40, 37, 38, 40, 37, 38, - 40 ] - -racc_action_check = [ - 0, 4, 27, 4, 0, 0, 0, 0, 36, 56, - 49, 27, 0, 0, 49, 49, 49, 49, 56, 36, - 43, 48, 49, 49, 43, 43, 43, 43, 15, 53, - 6, 15, 43, 43, 6, 6, 6, 6, 53, 52, - 42, 55, 6, 6, 42, 42, 42, 42, 52, 24, - 35, 18, 42, 42, 35, 35, 35, 35, 14, 39, - 19, nil, 35, 35, 19, 19, 19, 19, nil, nil, - 13, nil, 19, 19, 13, 13, 13, 13, nil, 13, - 26, 26, 13, 13, 54, 54, 54, 9, 26, 26, - 26, 26, 9, 9, 9, 2, nil, 2, 17, 17, - 2, nil, 17, 30, 30, nil, nil, 30, 41, 41, - 41, 41, 50, 50, 50, 50, 44, 44, 44, 59, - 59, 59, 58, 58, 58, 51, 51, 51, 62, 62, - 62 ] - -racc_action_pointer = [ - -3, nil, 91, nil, 1, nil, 27, nil, nil, 75, - nil, nil, nil, 67, 53, 22, nil, 93, 51, 57, - nil, nil, nil, nil, 40, nil, 67, 0, nil, nil, - 98, nil, nil, nil, nil, 47, -1, nil, nil, 46, - nil, 87, 37, 17, 94, nil, nil, nil, 12, 7, - 91, 103, 37, 27, 62, 21, 7, nil, 100, 97, - nil, nil, 106, nil, nil, nil, nil, nil ] - -racc_action_default = [ - -37, -13, -37, -19, -37, -20, -2, -4, -11, -6, - -12, -14, -7, -37, -37, -29, -28, -37, -37, -37, - -3, -23, -21, -22, -37, -5, -37, -37, -8, -29, - -37, -9, -27, -26, 68, -1, -37, -34, -35, -37, - -36, -37, -37, -37, -37, -15, -10, -25, -37, -37, - -37, -37, -37, -37, -37, -37, -37, -33, -37, -37, - -17, -18, -37, -24, -16, -32, -31, -30 ] - -racc_goto_table = [ - 4, 41, 20, 35, 17, 39, 25, nil, nil, nil, - nil, nil, nil, 27, nil, nil, 50, 30, nil, 54, - nil, nil, nil, nil, nil, 57, 59, nil, nil, 62, - nil, 20, nil, 65, 66, nil, nil, 67, nil, nil, - nil, nil, 52, 53, nil, nil, nil, nil, nil, 56 ] - -racc_goto_check = [ - 1, 10, 3, 2, 7, 9, 5, nil, nil, nil, - nil, nil, nil, 1, nil, nil, 10, 7, nil, 10, - nil, nil, nil, nil, nil, 10, 10, nil, nil, 10, - nil, 3, nil, 10, 10, nil, nil, 10, nil, nil, - nil, nil, 1, 1, nil, nil, nil, nil, nil, 1 ] - -racc_goto_pointer = [ - nil, 0, -16, -4, nil, -3, nil, 2, nil, -21, - -25 ] - -racc_goto_default = [ - nil, nil, 6, 7, 9, nil, 12, nil, 1, nil, - nil ] - -racc_reduce_table = [ - 0, 0, :racc_error, - 3, 26, :_reduce_1, - 1, 26, :_reduce_2, - 2, 27, :_reduce_3, - 1, 27, :_reduce_4, - 2, 28, :_reduce_5, - 1, 28, :_reduce_none, - 1, 29, :_reduce_none, - 3, 29, :_reduce_8, - 3, 29, :_reduce_9, - 4, 29, :_reduce_10, - 1, 29, :_reduce_11, - 1, 29, :_reduce_12, - 1, 29, :_reduce_13, - 1, 29, :_reduce_14, - 3, 31, :_reduce_15, - 6, 31, :_reduce_16, - 5, 31, :_reduce_17, - 5, 31, :_reduce_18, - 1, 33, :_reduce_none, - 1, 33, :_reduce_none, - 1, 30, :_reduce_none, - 1, 30, :_reduce_none, - 1, 30, :_reduce_none, - 5, 30, :_reduce_24, - 3, 30, :_reduce_25, - 2, 32, :_reduce_26, - 2, 32, :_reduce_27, - 1, 32, :_reduce_none, - 1, 32, :_reduce_none, - 4, 34, :_reduce_30, - 4, 34, :_reduce_31, - 4, 34, :_reduce_32, - 3, 34, :_reduce_33, - 1, 35, :_reduce_34, - 1, 35, :_reduce_35, - 1, 35, :_reduce_36 ] - -racc_reduce_n = 37 - -racc_shift_n = 68 - -racc_token_table = { - false => 0, - :error => 1, - :BAR => 2, - :LBRACK => 3, - :CTYPE => 4, - :RBRACK => 5, - :NEGATE => 6, - :CCLASS => 7, - :DOT => 8, - :CHAR => 9, - :LPAREN => 10, - :RPAREN => 11, - :QMARK => 12, - :COLON => 13, - :NAME => 14, - :L_ANCHOR => 15, - :R_ANCHOR => 16, - :STAR => 17, - :PLUS => 18, - :LCURLY => 19, - :RCURLY => 20, - :MINUS => 21, - :MULTILINE => 22, - :IGNORECASE => 23, - :EXTENDED => 24 } - -racc_nt_base = 25 - -racc_use_result_var = true - -Racc_arg = [ - racc_action_table, - racc_action_check, - racc_action_default, - racc_action_pointer, - racc_goto_table, - racc_goto_check, - racc_goto_default, - racc_goto_pointer, - racc_nt_base, - racc_reduce_table, - racc_token_table, - racc_shift_n, - racc_reduce_n, - racc_use_result_var ] - -Racc_token_to_s_table = [ - "$end", - "error", - "BAR", - "LBRACK", - "CTYPE", - "RBRACK", - "NEGATE", - "CCLASS", - "DOT", - "CHAR", - "LPAREN", - "RPAREN", - "QMARK", - "COLON", - "NAME", - "L_ANCHOR", - "R_ANCHOR", - "STAR", - "PLUS", - "LCURLY", - "RCURLY", - "MINUS", - "MULTILINE", - "IGNORECASE", - "EXTENDED", - "$start", - "expression", - "subexpression", - "quantified_atom", - "atom", - "quantifier", - "group", - "bracket_expression", - "anchor", - "options", - "modifier" ] - -Racc_debug_parser = false - -##### State transition tables end ##### - -# reduce 0 omitted - -def _reduce_1(val, _values, result) - # TODO remove this conditional by breaking - # it into another production - if val[0][0].is_a?(Regin::Alternation) - alt = val[0][0] + [Expression.new(val[2])] - else - alt = Alternation.new(val[0], Expression.new(val[2])) - end - result = Expression.new(alt) - - result -end - -def _reduce_2(val, _values, result) - result = Expression.new(val[0]) - result -end - -def _reduce_3(val, _values, result) - result = val[0] + [val[1]] - result -end - -def _reduce_4(val, _values, result) - result = [val[0]] - result -end - -def _reduce_5(val, _values, result) - result = val[0].dup(:quantifier => val[1]) - result -end - -# reduce 6 omitted - -# reduce 7 omitted - -def _reduce_8(val, _values, result) - result = CharacterClass.new(val[1]) - result -end - -def _reduce_9(val, _values, result) - result = CharacterClass.new(val[1]) - result -end - -def _reduce_10(val, _values, result) - result = CharacterClass.new(val[2], :negate => true) - result -end - -def _reduce_11(val, _values, result) - result = CharacterClass.new(val[0]) - result -end - -def _reduce_12(val, _values, result) - result = CharacterClass.new('.') - result -end - -def _reduce_13(val, _values, result) - result = Anchor.new(val[0]) - result -end - -def _reduce_14(val, _values, result) - result = Character.new(val[0]) - result -end - -def _reduce_15(val, _values, result) - result = Group.new(val[1], :index => @capture_index_stack.pop) - - result -end - -def _reduce_16(val, _values, result) - result = Group.new(val[4], val[2].merge(:capture => false)) - @options_stack.pop - - result -end - -def _reduce_17(val, _values, result) - result = Group.new(val[3], :capture => false); - - result -end - -def _reduce_18(val, _values, result) - result = Group.new(val[3], :name => val[2], :index => @capture_index_stack.pop); - - result -end - -# reduce 19 omitted - -# reduce 20 omitted - -# reduce 21 omitted - -# reduce 22 omitted - -# reduce 23 omitted - -def _reduce_24(val, _values, result) - result = val.join - result -end - -def _reduce_25(val, _values, result) - result = val.join - result -end - -def _reduce_26(val, _values, result) - result = val.join - result -end - -def _reduce_27(val, _values, result) - result = val.join - result -end - -# reduce 28 omitted - -# reduce 29 omitted - -def _reduce_30(val, _values, result) - @options_stack << result = { val[1] => false, val[2] => false, val[3] => false } - - result -end - -def _reduce_31(val, _values, result) - @options_stack << result = { val[0] => true, val[2] => false, val[3] => false } - - result -end - -def _reduce_32(val, _values, result) - @options_stack << result = { val[0] => true, val[1] => true, val[3] => false } - - result -end - -def _reduce_33(val, _values, result) - @options_stack << result = { val[0] => true, val[1] => true, val[2] => true } - - result -end - -def _reduce_34(val, _values, result) - result = :multiline - result -end - -def _reduce_35(val, _values, result) - result = :ignorecase - result -end - -def _reduce_36(val, _values, result) - result = :extended - result -end - -def _reduce_none(val, _values, result) - val[0] -end - - end # class Parser -end # module Regin - -require 'regin/tokenizer' diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/tokenizer.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/tokenizer.rb deleted file mode 100644 index 59e4ffb611..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/tokenizer.rb +++ /dev/null @@ -1,213 +0,0 @@ -#-- -# DO NOT MODIFY!!!! -# This file is automatically generated by rex 1.0.5.beta1 -# from lexical definition file "lib/regin/tokenizer.rex". -#++ - -require 'racc/parser' -class Regin::Parser < Racc::Parser - require 'strscan' - - class ScanError < StandardError ; end - - attr_reader :lineno - attr_reader :filename - attr_accessor :state - - def scan_setup(str) - @ss = StringScanner.new(str) - @lineno = 1 - @state = nil - end - - def action - yield - end - - def scan_str(str) - scan_setup(str) - do_parse - end - alias :scan :scan_str - - def load_file( filename ) - @filename = filename - open(filename, "r") do |f| - scan_setup(f.read) - end - end - - def scan_file( filename ) - load_file(filename) - do_parse - end - - - def next_token - return if @ss.eos? - - text = @ss.peek(1) - @lineno += 1 if text == "\n" - token = case @state - when nil - case - when (text = @ss.scan(/\\[dDsSwW]/)) - action { [:CCLASS, text] } - - when (text = @ss.scan(/\^|\\A/)) - action { [:L_ANCHOR, text] } - - when (text = @ss.scan(/\$|\\Z/)) - action { [:R_ANCHOR, text] } - - when (text = @ss.scan(/<(\w+)>/)) - action { [:NAME, @ss[1]] } - - when (text = @ss.scan(/\(/)) - action { - @capture_index_stack << @capture_index - @capture_index += 1 - @state = :OPTIONS if @ss.peek(1) == '?'; - [:LPAREN, text] - } - - - when (text = @ss.scan(/\)/)) - action { [:RPAREN, text] } - - when (text = @ss.scan(/\[/)) - action { @state = :CCLASS; [:LBRACK, text] } - - when (text = @ss.scan(/\{/)) - action { [:LCURLY, text] } - - when (text = @ss.scan(/\}/)) - action { [:RCURLY, text] } - - when (text = @ss.scan(/\|/)) - action { [:BAR, text] } - - when (text = @ss.scan(/\./)) - action { [:DOT, text] } - - when (text = @ss.scan(/\?/)) - action { [:QMARK, text] } - - when (text = @ss.scan(/\+(?:\?)/)) - action { [:PLUS, text] } - - when (text = @ss.scan(/\*(?:\?)/)) - action { [:STAR, text] } - - when (text = @ss.scan(/\#/)) - action { - if @options_stack[-1][:extended] - @state = :COMMENT; - next_token - else - [:CHAR, text] - end - } - - - when (text = @ss.scan(/\s|\n/)) - action { - if @options_stack[-1][:extended] - next_token - else - [:CHAR, text] - end - } - - - when (text = @ss.scan(/\\(.)/)) - action { [:CHAR, @ss[1]] } - - when (text = @ss.scan(/./)) - action { [:CHAR, text] } - - else - text = @ss.string[@ss.pos .. -1] - raise ScanError, "can not match: '" + text + "'" - end # if - - when :CCLASS - case - when (text = @ss.scan(/\]/)) - action { @state = nil; [:RBRACK, text] } - - when (text = @ss.scan(/\^/)) - action { [:NEGATE, text] } - - when (text = @ss.scan(/:(alnum|alpha|ascii|blank|cntrl|digit|graph|lower|print|punct|space|upper|word|xdigit):/)) - action { [:CTYPE, text] } - - when (text = @ss.scan(/\\-/)) - action { [:CHAR, text] } - - when (text = @ss.scan(/\\(.)/)) - action { [:CHAR, @ss[1]] } - - when (text = @ss.scan(/./)) - action { [:CHAR, text] } - - else - text = @ss.string[@ss.pos .. -1] - raise ScanError, "can not match: '" + text + "'" - end # if - - when :OPTIONS - case - when (text = @ss.scan(/\?/)) - action { - @state = nil unless @ss.peek(1) =~ /-|m|i|x|:/ - [:QMARK, text] - } - - - when (text = @ss.scan(/\-/)) - action { [:MINUS, text] } - - when (text = @ss.scan(/m/)) - action { [:MULTILINE, text] } - - when (text = @ss.scan(/i/)) - action { [:IGNORECASE, text] } - - when (text = @ss.scan(/x/)) - action { [:EXTENDED, text] } - - when (text = @ss.scan(/\:/)) - action { - @capture_index_stack.pop - @capture_index -= 1 - @state = nil; - [:COLON, text] - } - - - else - text = @ss.string[@ss.pos .. -1] - raise ScanError, "can not match: '" + text + "'" - end # if - - when :COMMENT - case - when (text = @ss.scan(/\n/)) - action { @state = nil; next_token } - - when (text = @ss.scan(/./)) - action { next_token } - - else - text = @ss.string[@ss.pos .. -1] - raise ScanError, "can not match: '" + text + "'" - end # if - - else - raise ScanError, "undefined state: '" + state.to_s + "'" - end # case state - token - end # def next_token - -end # class diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/version.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/version.rb deleted file mode 100644 index 7ad2a5a25e..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/version.rb +++ /dev/null @@ -1,3 +0,0 @@ -module Regin - Version = '0.3.3' -end diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/version.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/version.rb deleted file mode 100644 index a3688b102e..0000000000 --- a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/version.rb +++ /dev/null @@ -1,5 +0,0 @@ -module Rack - module Mount - Version = '0.6.6.pre' - end -end |