module YARD::Handlers::Ruby::DecoratorHandlerMethods

def process_decorator(*nodes, &block)
  opts = nodes.last.is_a?(Hash) ? nodes.pop : {}
  all_nodes = statement.parameters.select do |p|
    p.is_a? YARD::Parser::Ruby::AstNode
  end
  # Parse decorator parameters (decorator chain).
  all_nodes.each do |param|
    parse_block param if param.call? || param.def?
  end
  selected_nodes =
    if nodes.empty?
      all_nodes
    elsif nodes.count == 1 && nodes.first.nil?
      []
    else
      nodes
    end
  decorated_methods = selected_nodes.map do |param|
    process_decorator_parameter param, opts, &block
  end.flatten
  # Store method nodes in decorator node.
  statement.define_singleton_method :decorators do
    decorated_methods.map {|h| h[:node] }
  end
  decorated_methods
end

def process_decorator_parameter(node, opts = {}, &block)
  scope              = opts.fetch :scope, :instance
  transfer_docstring = opts.fetch :transfer_docstring, true
  transfer_source    = opts.fetch :transfer_source, true
  name = nil
  if node.call?
    if node.respond_to? :decorators
      return node.decorators.map do |n|
        process_decorator_parameter n, opts, &block
      end
    end
  elsif node.def?
    name = node.jump(:def).method_name.source
  else
    name = node.jump(:ident, :string_content, :const).source
  end
  if name.nil?
    raise YARD::Parser::UndocumentableError, 'statement, cannot determine method name'
  end
  method = YARD::CodeObjects::Proxy.new(
    namespace,
    (scope == :instance ? '#' : '.') + name.to_s,
    :method
  )
  # Transfer source to methods passed to the helper as parameters.
  method.source = statement.source if transfer_source && node.def?
  # Transfer decorator docstring to methods passed to the helper as parameters.
  if transfer_docstring && node.def? &&
     statement.docstring && method.docstring.empty?
    tags = method.tags if method.respond_to? :tags
    tags ||= []
    method.docstring = statement.docstring
    tags.each {|t| method.add_tag t }
  end
  yield method, node, name.to_sym if block_given?
  [{:method => method, :node => node, :name => name.to_sym}]
end