Ugh gross. Needs some refactoring love.

runner.ex

def evaluate_filters(filters, tags) do
  results = Enum.flat_map tags, fn tag ->
    Enum.map filters, fn filter ->
      { { elem(filter, 0), elem(tag, 0) }, evaluate_filter(filter, tag) }
    end
  end

  results = Enum.reduce results, HashDict.new, fn { key, evaluation }, dict ->
    Dict.update dict, key, evaluation, &(evaluation || &1)
  end

  mismatch = Enum.find Dict.to_list(results), &match?({ _, false }, &1)

  case mismatch do
    { { _, tag }, _ } -> { :error, tag }
    _ -> :ok
  end
end

def evaluate_filter({ tag, value, :include }, { tag, value }), do: true
def evaluate_filter({ tag, value, :exclude }, { tag, value }), do: false
def evaluate_filter({ tag, _, :include }, { tag, _ }), do: false
def evaluate_filter({ tag, _, :exclude }, { tag, _ }), do: true
def evaluate_filter(_, _), do: tru

runner_test.ex

test "filters with matching tags are ored and non-matching tags are anded" do
  filters = [ { :os, :unix, :include },
              { :os, :win32, :include },
              { :type, :unit, :include } ]

  assert ExUnit.Runner.fancy_filter_match(filters, [])
  assert ExUnit.Runner.fancy_filter_match(filters, [os: :unix])
  assert ExUnit.Runner.fancy_filter_match(filters, [os: :unix, type: :unit])
  refute ExUnit.Runner.fancy_filter_match(filters, [os: :unix, type: :integration])
  assert ExUnit.Runner.fancy_filter_match(filters, [os: :win32])
  assert ExUnit.Runner.fancy_filter_match(filters, [os: :win32, type: :unit])
  refute ExUnit.Runner.fancy_filter_match(filters, [os: :win32, type: :integration])
  assert ExUnit.Runner.fancy_filter_match(filters, [os: :unix, os: :win32])
  assert ExUnit.Runner.fancy_filter_match(filters, [type: :unit, type: :integration])
end