class Rspec::Core::World

def all_apply?(group, filters)
  filters.all? do |filter_on, filter|
    Rspec::Core.world.apply_condition(filter_on, filter, group.metadata)
  end
end

def apply_condition(filter_on, filter, metadata)
  return false if metadata.nil?
  case filter
  when Hash
    filter.all? { |k, v| apply_condition(k, v, metadata[filter_on]) }
  when Regexp
    metadata[filter_on] =~ filter
  when Proc
    filter.call(metadata[filter_on]) rescue false
  else
    metadata[filter_on] == filter
  end
end

def apply_exclusion_filters(collection, conditions={})
  find(collection, :negative, conditions)
end

def apply_inclusion_filters(collection, conditions={})
  find(collection, :positive, conditions)
end

def behaviours_to_run
  return @behaviours_to_run if @behaviours_to_run
  if filter || exclusion_filter
    @behaviours_to_run = filter_behaviours
    if @behaviours_to_run.size == 0 && Rspec::Core.configuration.run_all_when_everything_filtered?
      Rspec::Core.configuration.puts "No examples were matched by #{filter.inspect}, running all"
      # reset the behaviour list to all behaviours, and add back all examples
      @behaviours_to_run = @behaviours
      @behaviours.each { |b| b.examples_to_run.replace(b.examples) }
    else
      Rspec::Core.configuration.puts "Run filtered using #{filter.inspect}"          
    end
  else
    @behaviours_to_run = @behaviours
    @behaviours.each { |b| b.examples_to_run.replace(b.examples) }
  end      
  @behaviours_to_run
end

def exclusion_filter
  Rspec::Core.configuration.exclusion_filter
end

def filter
  Rspec::Core.configuration.filter
end

def filter_behaviours
  behaviours.inject([]) do |list_of_behaviors, _behavior|
    examples = _behavior.examples
    examples = apply_exclusion_filters(examples, exclusion_filter) if exclusion_filter
    examples = apply_inclusion_filters(examples, filter) if filter
    examples.uniq!
    _behavior.examples_to_run.replace(examples)
    if examples.empty?
      list_of_behaviors << nil
    else
      list_of_behaviors << _behavior
    end
  end.compact
end

def find(collection, type_of_filter=:positive, conditions={})
  negative = type_of_filter != :positive
  collection.select do |item|
    # negative conditions.any?, positive conditions.all? ?????
    result = conditions.all? do |filter_on, filter| 
      apply_condition(filter_on, filter, item.metadata)
    end
    negative ? !result : result
  end
end

def initialize
  @behaviours = []
end

def shared_behaviours
  @shared_behaviours ||= {}
end

def total_examples_to_run
  @total_examples_to_run ||= behaviours_to_run.inject(0) { |sum, b| sum += b.examples_to_run.size }
end