module ActionDispatch::Routing::Mapper::Resources

def action_options?(options)
  options[:only] || options[:except]
end

def action_path(name, path = nil)
  path || @scope[:path_names][name.to_sym] || name.to_s
end

def apply_common_behavior_for(method, resources, options, &block)
  if resources.length > 1
    resources.each { |r| send(method, r, options, &block) }
    return true
  end
  if resource_scope?
    nested { send(method, resources.pop, options, &block) }
    return true
  end
  options.keys.each do |k|
    (options[:constraints] ||= {})[k] = options.delete(k) if options[k].is_a?(Regexp)
  end
  scope_options = options.slice!(*RESOURCE_OPTIONS)
  unless scope_options.empty?
    scope(scope_options) do
      send(method, resources.pop, options, &block)
    end
    return true
  end
  unless action_options?(options)
    options.merge!(scope_action_options) if scope_action_options?
  end
  false
end

def canonical_action?(action, flag)
  flag && resource_method_scope? && CANONICAL_ACTIONS.include?(action.to_s)
end

def collection
  unless resource_scope?
    raise ArgumentError, "can't use collection outside resource(s) scope"
  end
  with_scope_level(:collection) do
    scope(parent_resource.collection_scope) do
      yield
    end
  end
end

def id_constraint
  @scope[:constraints][:id]
end

def id_constraint?
  @scope[:constraints] && @scope[:constraints][:id].is_a?(Regexp)
end

def initialize(*args) #:nodoc:
  super
  @scope[:path_names] = @set.resources_path_names
end

def match(*args)
  options = args.extract_options!.dup
  options[:anchor] = true unless options.key?(:anchor)
  if args.length > 1
    args.each { |path| match(path, options.dup) }
    return self
  end
  on = options.delete(:on)
  if VALID_ON_OPTIONS.include?(on)
    args.push(options)
    return send(on){ match(*args) }
  elsif on
    raise ArgumentError, "Unknown scope #{on.inspect} given to :on"
  end
  if @scope[:scope_level] == :resources
    args.push(options)
    return nested { match(*args) }
  elsif @scope[:scope_level] == :resource
    args.push(options)
    return member { match(*args) }
  end
  action = args.first
  path = path_for_action(action, options.delete(:path))
  if action.to_s =~ /^[\w\/]+$/
    options[:action] ||= action unless action.to_s.include?("/")
  else
    action = nil
  end
  if options.key?(:as) && !options[:as]
    options.delete(:as)
  else
    options[:as] = name_for_action(options[:as], action)
  end
  super(path, options)
end

def member
  unless resource_scope?
    raise ArgumentError, "can't use member outside resource(s) scope"
  end
  with_scope_level(:member) do
    scope(parent_resource.member_scope) do
      yield
    end
  end
end

def name_for_action(as, action)
  prefix = prefix_name_for_action(as, action)
  prefix = Mapper.normalize_name(prefix) if prefix
  name_prefix = @scope[:as]
  if parent_resource
    return nil if as.nil? && action.nil?
    collection_name = parent_resource.collection_name
    member_name = parent_resource.member_name
  end
  name = case @scope[:scope_level]
  when :nested
    [name_prefix, prefix]
  when :collection
    [prefix, name_prefix, collection_name]
  when :new
    [prefix, :new, name_prefix, member_name]
  when :member
    [prefix, shallow_scoping? ? @scope[:shallow_prefix] : name_prefix, member_name]
  when :root
    [name_prefix, collection_name, prefix]
  else
    [name_prefix, member_name, prefix]
  end
  candidate = name.select(&:present?).join("_").presence
  candidate unless as.nil? && @set.routes.find { |r| r.name == candidate }
end

def namespace(path, options = {})
  if resource_scope?
    nested { super }
  else
    super
  end
end

def nested
  unless resource_scope?
    raise ArgumentError, "can't use nested outside resource(s) scope"
  end
  with_scope_level(:nested) do
    if shallow?
      with_exclusive_scope do
        if @scope[:shallow_path].blank?
          scope(parent_resource.nested_scope, nested_options) { yield }
        else
          scope(@scope[:shallow_path], :as => @scope[:shallow_prefix]) do
            scope(parent_resource.nested_scope, nested_options) { yield }
          end
        end
      end
    else
      scope(parent_resource.nested_scope, nested_options) { yield }
    end
  end
end

def nested_options
  {}.tap do |options|
    options[:as] = parent_resource.member_name
    options[:constraints] = { "#{parent_resource.singular}_id".to_sym => id_constraint } if id_constraint?
  end
end

def new
  unless resource_scope?
    raise ArgumentError, "can't use new outside resource(s) scope"
  end
  with_scope_level(:new) do
    scope(parent_resource.new_scope(action_path(:new))) do
      yield
    end
  end
end

def parent_resource #:nodoc:
  @scope[:scope_level_resource]
end

def path_for_action(action, path)
  prefix = shallow_scoping? ?
    "#{@scope[:shallow_path]}/#{parent_resource.path}/:id" : @scope[:path]
  path = if canonical_action?(action, path.blank?)
    prefix.to_s
  else
    "#{prefix}/#{action_path(action, path)}"
  end
end

def prefix_name_for_action(as, action)
  if as
    as.to_s
  elsif !canonical_action?(action, @scope[:scope_level])
    action.to_s
  end
end

def resource(*resources, &block)
  options = resources.extract_options!
  if apply_common_behavior_for(:resource, resources, options, &block)
    return self
  end
  resource_scope(SingletonResource.new(resources.pop, options)) do
    yield if block_given?
    collection do
      post :create
    end if parent_resource.actions.include?(:create)
    new do
      get :new
    end if parent_resource.actions.include?(:new)
    member do
      get    :edit if parent_resource.actions.include?(:edit)
      get    :show if parent_resource.actions.include?(:show)
      put    :update if parent_resource.actions.include?(:update)
      delete :destroy if parent_resource.actions.include?(:destroy)
    end
  end
  self
end

def resource_method_scope?
  [:collection, :member, :new].include?(@scope[:scope_level])
end

def resource_scope(resource)
  with_scope_level(resource.is_a?(SingletonResource) ? :resource : :resources, resource) do
    scope(parent_resource.resource_scope) do
      yield
    end
  end
end

def resource_scope?
  [:resource, :resources].include?(@scope[:scope_level])
end

def resources(*resources, &block)
  options = resources.extract_options!
  if apply_common_behavior_for(:resources, resources, options, &block)
    return self
  end
  resource_scope(Resource.new(resources.pop, options)) do
    yield if block_given?
    collection do
      get  :index if parent_resource.actions.include?(:index)
      post :create if parent_resource.actions.include?(:create)
    end
    new do
      get :new
    end if parent_resource.actions.include?(:new)
    member do
      get    :edit if parent_resource.actions.include?(:edit)
      get    :show if parent_resource.actions.include?(:show)
      put    :update if parent_resource.actions.include?(:update)
      delete :destroy if parent_resource.actions.include?(:destroy)
    end
  end
  self
end

def resources_path_names(options)
  @scope[:path_names].merge!(options)
end

def root(options={})
  if @scope[:scope_level] == :resources
    with_scope_level(:root) do
      scope(parent_resource.path) do
        super(options)
      end
    end
  else
    super(options)
  end
end

def scope_action_options
  @scope[:options].slice(:only, :except)
end

def scope_action_options?
  @scope[:options].is_a?(Hash) && (@scope[:options][:only] || @scope[:options][:except])
end

def shallow
  scope(:shallow => true) do
    yield
  end
end

def shallow?
  parent_resource.instance_of?(Resource) && @scope[:shallow]
end

def shallow_scoping?
  shallow? && @scope[:scope_level] == :member
end

def with_exclusive_scope
  begin
    old_name_prefix, old_path = @scope[:as], @scope[:path]
    @scope[:as], @scope[:path] = nil, nil
    with_scope_level(:exclusive) do
      yield
    end
  ensure
    @scope[:as], @scope[:path] = old_name_prefix, old_path
  end
end

def with_scope_level(kind, resource = parent_resource)
  old, @scope[:scope_level] = @scope[:scope_level], kind
  old_resource, @scope[:scope_level_resource] = @scope[:scope_level_resource], resource
  yield
ensure
  @scope[:scope_level] = old
  @scope[:scope_level_resource] = old_resource
end