class ActionDispatch::Routing::RouteSet

def self.default_resources_path_names
  { :new => 'new', :edit => 'edit' }
end

def _generate_prefix(options = {})
  nil
end

def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
  raise ArgumentError, "Invalid route name: '#{name}'" unless name.blank? || name.to_s.match(/^[_a-z]\w*$/i)
  if name && named_routes[name]
    raise ArgumentError, "Invalid route name, already in use: '#{name}' \n" \
      "You may have defined two routes with the same name using the `:as` option, or " \
      "you may be overriding a route already defined by a resource with the same naming. " \
      "For the latter, you can restrict the routes created with `resources` as explained here: \n" \
      "http://guides.rubyonrails.org/routing.html#restricting-the-routes-created"
  end
  path = build_path(conditions.delete(:path_info), requirements, SEPARATORS, anchor)
  conditions = build_conditions(conditions, path.names.map { |x| x.to_sym })
  route = @set.add_route(app, path, conditions, defaults, name)
  named_routes[name] = route if name
  route
end

def append(&block)
  @append << block
end

def build_conditions(current_conditions, path_values)
  conditions = current_conditions.dup
  # Rack-Mount requires that :request_method be a regular expression.
  # :request_method represents the HTTP verb that matches this route.
  #
  # Here we munge values before they get sent on to rack-mount.
  verbs = conditions[:request_method] || []
  unless verbs.empty?
    conditions[:request_method] = %r[^#{verbs.join('|')}$]
  end
  conditions.keep_if do |k, _|
    k == :action || k == :controller || k == :required_defaults ||
      @request_class.public_method_defined?(k) || path_values.include?(k)
  end
end

def build_path(path, requirements, separators, anchor)
  strexp = Journey::Router::Strexp.new(
      path,
      requirements,
      SEPARATORS,
      anchor)
  pattern = Journey::Path::Pattern.new(strexp)
  builder = Journey::GTG::Builder.new pattern.spec
  # Get all the symbol nodes followed by literals that are not the
  # dummy node.
  symbols = pattern.spec.grep(Journey::Nodes::Symbol).find_all { |n|
    builder.followpos(n).first.literal?
  }
  # Get all the symbol nodes preceded by literals.
  symbols.concat pattern.spec.find_all(&:literal?).map { |n|
    builder.followpos(n).first
  }.find_all(&:symbol?)
  symbols.each { |x|
    x.regexp = /(?:#{Regexp.union(x.regexp, '-')})+/
  }
  pattern
end

def call(env)
  @router.call(env)
end

def clear!
  @finalized = false
  named_routes.clear
  set.clear
  formatter.clear
  @prepend.each { |blk| eval_block(blk) }
end

def define_mounted_helper(name)
  return if MountedHelpers.method_defined?(name)
  routes = self
  MountedHelpers.class_eval do
    define_method "_#{name}" do
      RoutesProxy.new(routes, _routes_context)
    end
  end
  MountedHelpers.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
    def #{name}
      @_#{name} ||= _#{name}
    end
  RUBY
end

def draw(&block)
  clear! unless @disable_clear_and_finalize
  eval_block(block)
  finalize! unless @disable_clear_and_finalize
  nil
end

def empty?
  routes.empty?
end

def eval_block(block)
  if block.arity == 1
    raise "You are using the old router DSL which has been removed in Rails 3.1. " <<
      "Please check how to update your routes file at: http://www.engineyard.com/blog/2010/the-lowdown-on-routes-in-rails-3/"
  end
  mapper = Mapper.new(self)
  if default_scope
    mapper.with_default_scope(default_scope, &block)
  else
    mapper.instance_exec(&block)
  end
end

def extra_keys(options, recall={})
  generate_extras(options, recall).last
end

def extract_authentication(options)
  if options[:user] && options[:password]
    [options.delete(:user), options.delete(:password)]
  else
    nil
  end
end

def finalize!
  return if @finalized
  @append.each { |blk| eval_block(blk) }
  @finalized = true
end

def generate(options, recall = {})
  Generator.new(options, recall, self).generate
end

def generate_extras(options, recall={})
  path, params = generate(options, recall)
  return path, params.keys
end

def initialize(request_class = ActionDispatch::Request)
  self.named_routes = NamedRouteCollection.new
  self.resources_path_names = self.class.default_resources_path_names.dup
  self.default_url_options = {}
  self.request_class = request_class
  @append                     = []
  @prepend                    = []
  @disable_clear_and_finalize = false
  @finalized                  = false
  @set    = Journey::Routes.new
  @router = Journey::Router.new(@set, {
    :parameters_key => PARAMETERS_KEY,
    :request_class  => request_class})
  @formatter = Journey::Formatter.new @set
end

def mounted?
  false
end

def mounted_helpers
  MountedHelpers
end

def optimize_routes_generation?
  !mounted? && default_url_options.empty?
end

def prepend(&block)
  @prepend << block
end

def recognize_path(path, environment = {})
  method = (environment[:method] || "GET").to_s.upcase
  path = Journey::Router::Utils.normalize_path(path) unless path =~ %r{://}
  extras = environment[:extras] || {}
  begin
    env = Rack::MockRequest.env_for(path, {:method => method})
  rescue URI::InvalidURIError => e
    raise ActionController::RoutingError, e.message
  end
  req = @request_class.new(env)
  @router.recognize(req) do |route, _matches, params|
    params.merge!(extras)
    params.each do |key, value|
      if value.is_a?(String)
        value = value.dup.force_encoding(Encoding::BINARY)
        params[key] = URI.parser.unescape(value)
      end
    end
    old_params = env[::ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
    env[::ActionDispatch::Routing::RouteSet::PARAMETERS_KEY] = (old_params || {}).merge(params)
    dispatcher = route.app
    while dispatcher.is_a?(Mapper::Constraints) && dispatcher.matches?(env) do
      dispatcher = dispatcher.app
    end
    if dispatcher.is_a?(Dispatcher)
      if dispatcher.controller(params, false)
        dispatcher.prepare_params!(params)
        return params
      else
        raise ActionController::RoutingError, "A route matches #{path.inspect}, but references missing controller: #{params[:controller].camelize}Controller"
      end
    end
  end
  raise ActionController::RoutingError, "No route matches #{path.inspect}"
end

def url_for(options)
  options = default_url_options.merge(options || {})
  user, password = extract_authentication(options)
  recall  = options.delete(:_recall)
  original_script_name = options.delete(:original_script_name).presence
  script_name = options.delete(:script_name).presence || _generate_prefix(options)
  if script_name && original_script_name
    script_name = original_script_name + script_name
  end
  path_options = options.except(*RESERVED_OPTIONS)
  path_options = yield(path_options) if block_given?
  path, params = generate(path_options, recall || {})
  params.merge!(options[:params] || {})
  ActionDispatch::Http::URL.url_for(options.merge!({
    :path => path,
    :script_name => script_name,
    :params => params,
    :user => user,
    :password => password
  }))
end

def url_helpers
  @url_helpers ||= begin
    routes = self
    Module.new do
      extend ActiveSupport::Concern
      include UrlFor
      # Define url_for in the singleton level so one can do:
      # Rails.application.routes.url_helpers.url_for(args)
      @_routes = routes
      class << self
        delegate :url_for, :optimize_routes_generation?, :to => '@_routes'
      end
      # Make named_routes available in the module singleton
      # as well, so one can do:
      # Rails.application.routes.url_helpers.posts_path
      extend routes.named_routes.module
      # Any class that includes this module will get all
      # named routes...
      include routes.named_routes.module
      # plus a singleton class method called _routes ...
      included do
        singleton_class.send(:redefine_method, :_routes) { routes }
      end
      # And an instance method _routes. Note that
      # UrlFor (included in this module) add extra
      # conveniences for working with @_routes.
      define_method(:_routes) { @_routes || routes }
    end
  end
end