class RSpec::Core::Metadata

def all_apply?(filters)
  filters.all? {|k,v| filter_applies?(k,v)}
end

def any_apply?(filters)
  filters.any? {|k,v| filter_applies?(k,v)}
end

def configure_for_example(description, user_metadata)
  store(:description_args, [description])
  store(:caller, user_metadata.delete(:caller) || caller)
  update(user_metadata)
end

def ensure_valid_keys(user_metadata)
  RESERVED_KEYS.each do |key|
    if user_metadata.keys.include?(key)
      raise <<-EOM
50}
} is not allowed
reserves some hash keys for its own internal use,
ing :#{key}, which is used on:
ller(0)[4]}.
re all of RSpec's reserved hash keys:
SERVED_KEYS.join("\n  ")}
50}
      raise ":#{key} is not allowed"
    end
  end
end

def filter_applies?(key, value, metadata=self)
  case value
  when Hash
    if key == :locations
      file_path     = (self[:example_group] || {})[:file_path]
      expanded_path = file_path && File.expand_path( file_path )
      if expanded_path && line_numbers = value[expanded_path]
        filter_applies?(:line_numbers, line_numbers)
      else
        true
      end
    else
      value.all? { |k, v| filter_applies?(k, v, metadata[key]) }
    end
  when Regexp
    metadata[key] =~ value
  when Proc
    if value.arity == 2
      # Pass the metadata hash to allow the proc to check if it even has the key.
      # This is necessary for the implicit :if exclusion filter:
      #   {            } # => run the example
      #   { :if => nil } # => exclude the example
      # The value of metadata[:if] is the same in these two cases but
      # they need to be treated differently.
      value.call(metadata[key], metadata) rescue false
    else
      value.call(metadata[key]) rescue false
    end
  when String
    metadata[key].to_s == value.to_s
  when Enumerable
    if key == :line_numbers
      preceding_declaration_lines = value.map{|v| world.preceding_declaration_line(v)}
      !(relevant_line_numbers(metadata) & preceding_declaration_lines).empty?
    else
      metadata[key] == value
    end
  else
    metadata[key].to_s == value.to_s
  end
end

def for_example(description, user_metadata)
  dup.extend(MetadataHash).configure_for_example(description, user_metadata)
end

def initialize(parent_group_metadata=nil)
  if parent_group_metadata
    update(parent_group_metadata)
    store(:example_group, {:example_group => parent_group_metadata[:example_group]}.extend(GroupMetadataHash))
  else
    store(:example_group, {}.extend(GroupMetadataHash))
  end
  yield self if block_given?
end

def process(*args)
  user_metadata = args.last.is_a?(Hash) ? args.pop : {}
  ensure_valid_keys(user_metadata)
  self[:example_group].store(:description_args, args)
  self[:example_group].store(:caller, user_metadata.delete(:caller) || caller)
  update(user_metadata)
end

def relevant_line_numbers(metadata)
  line_numbers = [metadata[:line_number]]
  if metadata[:example_group]
    line_numbers + relevant_line_numbers(metadata[:example_group])
  else
    line_numbers
  end
end

def world
  RSpec.world
end