matchers 0.1.0.pre.1

data/lib/matcher/testing/error_checker.rb

@@ -0,0 +1,514 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ErrorChecker
+    Result = Struct.new(:ok, :reason, :missing_phrases, :extra_phrases)
+
+    def initialize(phrasing)
+      @phrasing = phrasing
+      @label_count = 0
+
+      label_counter = proc do |h, k|
+        h[k] = (@label_count += 1)
+      end
+
+      @element_label_index = Hash.new(&label_counter)
+      @group_label_index = Hash.new(&label_counter)
+      @hierarchy_index = Hash.new(&label_counter)
+      @expression_labeler = ExpressionLabeler.new
+
+      @message_index = Hash.new(&label_counter)
+      @phrase_index = Hash.new(&label_counter)
+
+      @identities = Hash.new(&label_counter)
+      @phrasing_labels = Hash.new(&label_counter)
+    end
+
+    def check(expected, actual)
+      if expected.valid? && !actual.valid?
+        return not_ok("expected no errors")
+      elsif !expected.valid? && actual.valid?
+        return not_ok("did not expect no errors")
+      end
+
+      expected_tree, expected_leaves = analyze(expected)
+      actual_tree, actual_leaves = analyze(actual)
+
+      return not_ok("error has not the expected structure") if
+        actual_tree.label != expected_tree.label
+
+      propagate_hierarchy(expected_tree)
+      propagate_hierarchy(actual_tree)
+
+      missing_phrases, extra_phrases = check_phrases(
+        expected_leaves, actual_leaves
+      )
+
+      if !missing_phrases.empty? || !extra_phrases.empty?
+        result = not_ok("error has unexpected messages")
+        result.missing_phrases = missing_phrases
+        result.extra_phrases = extra_phrases
+        return result
+      end
+
+      return not_ok("error tree does not match expected") unless
+        check_trees(expected_tree, actual_tree)
+
+      ok
+    end
+
+    Tree = Struct.new(
+      :label,
+      :children,
+      :operator,
+      :hierarchy,
+      :identity,
+    ) do
+      def leaf?
+        false
+      end
+
+      def inspect
+        "#<Tree #{hierarchy} #{children.map(&:hierarchy).inspect}>"
+      end
+    end
+
+    Leaf = Struct.new(
+      :label,
+      :path,
+      :message,
+      :hierarchy,
+      :identity,
+      :message_label,
+      :phrase_label,
+    ) do
+      def leaf?
+        true
+      end
+
+      def inspect
+        "#<Leaf #{hierarchy} #{path} #{message.inspect}>"
+      end
+    end
+
+    private
+
+    def ok
+      Result.new(true)
+    end
+
+    def not_ok(reason)
+      Result.new(false, reason)
+    end
+
+    # assign labels and hierarchy
+
+    def analyze(error)
+      leaves = []
+      tree = analyze_helper(error, List.empty, ExpressionLabeler::ROOT, leaves)
+
+      [tree, leaves]
+    end
+
+    def analyze_helper(error, path, path_label, leaves)
+      case error
+      when EmptyError
+        Leaf.new(0)
+      when AndError, OrError
+        operator = error.is_a?(AndError) ? "and" : "or"
+
+        left_children, right_children = error.children
+          .map { analyze_helper(_1, path, path_label, leaves) }
+          .partition { _1.leaf? || _1.operator != operator }
+
+        children = left_children + right_children.flat_map(&:children)
+        group_key = [error.class, children.map(&:label).sort]
+        label = @group_label_index[group_key]
+
+        Tree.new(label, children, operator)
+      when NestedError
+        new_path_label = @expression_labeler.label(error.key, path_label)
+
+        analyze_helper(error.child, path << error.key, new_path_label, leaves)
+      when ElementError
+        leaf = Leaf.new
+        leaf.label = @element_label_index[path_label]
+        leaf.path = path
+        leaf.message = error.message
+
+        leaves << leaf
+
+        leaf
+      else
+        raise "Unexpected error: #{error.inspect}"
+      end
+    end
+
+    def propagate_hierarchy(node, parent_hierarchy = 0)
+      key = [parent_hierarchy, node.label]
+      hierarchy = @hierarchy_index[key]
+      node.hierarchy = hierarchy
+
+      return if node.leaf?
+
+      node.children.each do |child|
+        propagate_hierarchy(child, hierarchy)
+      end
+    end
+
+    # message indexing and checking
+
+    def check_phrases(expected_leaves, actual_leaves)
+      counts = Hash.new(0)
+
+      actual_leaves.each do |leaf|
+        index_message(leaf)
+        counts[[leaf.hierarchy, leaf.phrase_label]] += 1
+      end
+
+      expected_leaves.each do |leaf|
+        index_message(leaf)
+        counts[[leaf.hierarchy, leaf.phrase_label]] -= 1
+      end
+
+      inverted_phrase_index = @phrase_index.invert
+      missing_phrases = []
+      extra_phrases = []
+
+      counts.each do |key, count|
+        next if count == 0
+
+        phrase_label = key[1]
+        phrase = inverted_phrase_index[phrase_label]
+
+        if count < 0
+          missing_phrases << [phrase, -count]
+        else
+          extra_phrases << [phrase, count]
+        end
+      end
+
+      [missing_phrases, extra_phrases]
+    end
+
+    def index_message(leaf)
+      if leaf.message.is_a?(Message)
+        leaf.message_label = @message_index[leaf.message]
+        leaf.phrase_label = @phrase_index[phrase(leaf)]
+      else
+        leaf.phrase_label = @phrase_index[leaf.message]
+      end
+    end
+
+    def phrase(leaf)
+      @phrasing.call(leaf.path, leaf.message)
+    end
+
+    # tree matching - Welcome to Overengineering!
+
+    def check_trees(expected_tree, actual_tree)
+      identify_tree(actual_tree)
+
+      @actual_hierarchy_groups = group_by_hierarchy(actual_tree)
+      @actual_group_phrases_index = index_group_phrases(actual_tree)
+
+      catch(:mismatch) do
+        if expected_tree.leaf?
+          return false unless actual_tree.leaf?
+
+          result = if expected_tree.message.is_a?(String)
+            expected_tree.phrase_label == actual_tree.phrase_label
+          else
+            expected_tree.message_label == actual_tree.message_label
+          end
+
+          return result
+        elsif actual_tree.leaf?
+          return false
+        else
+          identify_candidates(expected_tree)
+
+          return true
+        end
+      end
+
+      false
+    end
+
+    def group_by_hierarchy(tree, groups = {})
+      (groups[tree.hierarchy] ||= []) << tree
+      tree.children.each { group_by_hierarchy(_1, groups) } unless tree.leaf?
+
+      groups
+    end
+
+    def index_group_phrases(tree)
+      index = {}
+
+      index_group_phrases_helper(tree, index) unless tree.leaf?
+
+      index
+    end
+
+    def index_group_phrases_helper(tree, index)
+      message_counts = Hash.new(0)
+
+      labels = tree.children.filter_map do |child|
+        unless child.leaf?
+          index_group_phrases_helper(child, index)
+          next
+        end
+
+        message_counts[child.message_label] += 1 if child.message_label
+
+        child.phrase_label
+      end
+
+      unless labels.empty?
+        key = [tree.hierarchy, labels.sort!]
+        (index[key] ||= []) << [tree.identity, message_counts]
+      end
+
+      nil
+    end
+
+    def identify_tree(tree)
+      content = if tree.leaf?
+        tree.message
+      else
+        tree.children.map { identify_tree(_1) }.sort
+      end
+
+      key = [tree.hierarchy, content]
+      identity = @identities[key]
+
+      tree.identity = identity
+    end
+
+    def identify_candidates(expected_tree)
+      expected_leaves, expected_parents =
+        expected_tree.children.partition(&:leaf?)
+
+      if expected_leaves.empty?
+        actual_group = @actual_hierarchy_groups[expected_tree.hierarchy]
+
+        throw(:mismatch) unless actual_group
+
+        identify_by_parents(expected_parents, actual_group)
+      elsif expected_parents.empty?
+        identify_by_leaves(expected_leaves, expected_tree.hierarchy)
+      else
+        leaf_identities = identify_by_leaves(
+          expected_leaves, expected_tree.hierarchy
+        )
+
+        actual_group = @actual_hierarchy_groups[expected_tree.hierarchy]
+
+        throw(:mismatch) unless actual_group
+
+        # NOTE: narrowed_group can't be empty since leaf_identities isn't empty
+        narrowed_group = actual_group.filter do |actual_tree|
+          leaf_identities.include?(actual_tree.identity)
+        end
+
+        identify_by_parents(expected_parents, narrowed_group)
+      end
+    end
+
+    def identify_by_parents(expected_parents, actual_group)
+      positions = expected_parents.map { identify_candidates(_1) }
+
+      throw(:mismatch) if positions.any?(&:empty?)
+
+      candidates = actual_group.filter_map do |actual_tree|
+        identities = actual_tree.children.filter_map do |child|
+          child.identity unless child.leaf?
+        end
+
+        actual_tree.identity if match_identities?(positions, identities)
+      end
+
+      throw(:mismatch) if candidates.empty?
+
+      candidates
+    end
+
+    def identify_by_leaves(expected_leaves, hierarchy)
+      phrase_labels = expected_leaves.map(&:phrase_label)
+      group_phrase_label = [hierarchy, phrase_labels.sort!]
+      actual_phrase_group = @actual_group_phrases_index[group_phrase_label]
+
+      throw(:mismatch) unless actual_phrase_group
+
+      expected_counts = Hash.new(0)
+      expected_leaves.each do |leaf|
+        expected_counts[leaf.message_label] += 1 if leaf.message_label
+      end
+
+      candidates = actual_phrase_group.filter_map do |actual_id, actual_counts|
+        actual_id if expected_counts.all? do |message_label, expected_count|
+          expected_count <= actual_counts[message_label]
+        end
+      end
+
+      throw(:mismatch) if candidates.empty?
+
+      candidates
+    end
+
+    def match_identities?(positions, identities)
+      # Prepare NP-hard matching.
+      # How did we even get here?! Maybe there's a shortcut!
+
+      # NOTE: candidates_list is now a new array
+      positions = positions.map do |candidates|
+        intersection = candidates & identities
+
+        # shortcut: no candidate matches any identity
+        return false if intersection.empty?
+
+        intersection
+      end
+
+      # shortcut: trivial match if candidates are unambiguous
+      return positions.map(&:first).sort == identities.sort if
+        positions.all? { _1.length == 1 }
+
+      # remap and count identities
+
+      id_map = {}
+      id_counts = Array.new(identities.length, 0)
+
+      identities.each do |id|
+        index = (id_map[id] ||= id_map.size)
+        id_counts[index] += 1
+      end
+
+      n = id_map.size
+      id_counts = id_counts.slice(0, n) if n < id_counts.length
+
+      # remap and count candidates
+
+      positions.each do |candidates|
+        candidates.map! { id_map[_1] }
+      end
+
+      candidate_counts = Array.new(n, 0)
+
+      positions.each do |candidates|
+        candidates.each { candidate_counts[_1] += 1 }
+      end
+
+      # shortcut: too few candidates for identity
+      candidate_counts.zip(id_counts) do |candidate_count, id_count|
+        return false if candidate_count < id_count
+      end
+
+      # sort candidates for early backtracking
+      positions.sort_by!(&:length)
+      positions.each do |candidates|
+        candidates.sort_by! { id_counts[_1] }
+      end
+
+      # now the fun begins
+      match_identities_helper(positions, id_counts, candidate_counts)
+    end
+
+    def match_identities_helper(positions, id_counts, candidate_counts)
+      n = positions.length
+      stack = Array.new(n)
+      j_stack = Array.new(n)
+
+      position = positions[0]
+      position.each { candidate_counts[_1] -= 1 }
+      candidates = narrow_candidates(position, id_counts, candidate_counts)
+      stack[0] = candidates
+
+      i = 0
+      j = 0
+
+      # i-loop for position
+      loop do
+        # assign position and go to next one
+        if j < candidates.length
+          j_stack[i] = j
+          i += 1
+
+          # found a match for all positions
+          return true if i == n
+
+          # assign candidate to position
+          c = candidates[j]
+          id_counts[c] -= 1
+
+          # next candidates
+          position = positions[i]
+          position.each { candidate_counts[_1] -= 1 }
+          candidates = narrow_candidates(position, id_counts, candidate_counts)
+          stack[i] = candidates
+
+          j = 0
+
+          next
+        end
+
+        # backtracking, j-loop for candidates
+        loop do
+          # no solution found (back at start)
+          return false if i == 0
+
+          stack[i] = nil
+          positions[i].each { candidate_counts[_1] += 1 }
+
+          i -= 1
+
+          # unassign previous candidate
+          candidates = stack[i]
+          j = j_stack[i]
+          c = candidates[j]
+          id_counts[c] += 1
+
+          j += 1
+
+          # continue backtracking unless untried candidates for position exist
+          break if j < candidates.length
+        end
+      end
+    end
+
+    def narrow_candidates(candidates, id_counts, candidate_counts)
+      # if there is only one candidate for current position, we can simplify
+      if candidates.length == 1
+        c = candidates[0]
+
+        # assign position if identity available, otherwise backtrack
+        id_counts[c].between?(1, candidate_counts[c] + 1) ? [c] : []
+      else
+        # do a pre-check if position can be assigned
+        #
+        # cases:
+        # - too few candidates for unassigned identities: backtrack
+        #   * diff > 1 for at least one candidate, or
+        #   * diff == 1 for more than one candidate
+        # - position can only be assigned to one identity: assign
+        #   * exactly one diff == 1, all others diff < 1
+        # - else: try all candidates for unassigned identities
+        #   * diff < 1 for all candidates c where id_counts[c] > 0
+
+        assign = nil
+
+        candidates.each do |c|
+          diff = id_counts[c] - candidate_counts[c]
+
+          if diff == 1 && !assign
+            assign = c
+          elsif diff >= 1
+            return [] # backtrack
+          end
+        end
+
+        assign ? [assign] : candidates.filter { id_counts[_1] > 0 }
+      end
+    end
+  end
+end

data/lib/matcher/testing/error_testing.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Matcher
+  module ErrorTesting
+    def empty
+      EmptyError.instance
+    end
+
+    def element(message)
+      ElementError.new(message)
+    end
+
+    def nested(key, error)
+      NestedError.new(key, error)
+    end
+
+    def nested_from(key, error)
+      NestedError.from(key, error)
+    end
+
+    def _and(*errors)
+      AndError.new(errors)
+    end
+
+    def _or(*errors)
+      OrError.new(errors)
+    end
+
+    def msg(actual)
+      StandardMessageBuilder.new(false, actual)
+    end
+
+    def assert_phrase(expected, message)
+      assert_equal expected, ExpectedPhrasing.new(nil, message).apply
+    end
+  end
+end

data/lib/matcher/testing/pattern_testing.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Matcher
+  module PatternTesting
+    def with_pattern(pattern, &)
+      pattern = Pattern.build(&pattern)
+
+      PatternTestingScope.new(pattern, self).instance_exec(&)
+    end
+  end
+end

data/lib/matcher/testing/pattern_testing_scope.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Matcher
+  class PatternTestingScope
+    include PatternBuilding
+
+    def initialize(pattern, test)
+      @pattern = pattern
+      @test = test
+    end
+
+    def assert_pattern_match(test_expression, **expected)
+      expected = expected.transform_values do |v|
+        Expression.of(v)
+      end
+
+      test_expression = Expression.of(test_expression)
+
+      result = @pattern.match(test_expression)
+
+      flunk "#{test_expression} did not match #{@pattern}" unless result
+
+      expected.each_pair do |key, value|
+        @test.assert_equal value, result[key]&.expression, "for #{key.inspect}"
+      end
+    end
+
+    def assert_no_pattern_match(test_expression)
+      test_expression = Expression.of(test_expression)
+
+      @test.assert_nil(@pattern.match(test_expression))
+    end
+  end
+end

data/lib/matcher/testing.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Matcher
+  module Testing
+    def expression(&)
+      Expression.build(&)
+    end
+
+    def build_errors(&)
+      ErrorBuilder.build(&)
+    end
+
+    def assert_errors(actual, *base, **nested, &block)
+      assert_errors_helper(actual, base, nested, block)
+    end
+
+    def assert_or_errors(actual, *base, **nested, &block)
+      assert_errors_helper(actual, base, nested, block, use_or: true)
+    end
+
+    def assert_no_errors(actual)
+      assert(false, <<~TEXT.chomp) unless actual.valid?
+        The following conditions were not satisfied:
+
+        #{Reporter.report(actual)}
+      TEXT
+    end
+
+    def msg(actual)
+      StandardMessageBuilder.new(false, actual)
+    end
+
+    private
+
+    def assert_errors_helper(
+      actual, base, nested, block,
+      phrasing: ExpectedPhrasing.phrasing, use_or: false
+    )
+      raise "cannot pass expected errors directly if block given" if
+        (!base.empty? || !nested.empty?) && block
+
+      expected_nodes = if block
+        ErrorBuilder.build_errors(&block)
+      else
+        base.map { ElementError.new(_1) } + nested_from_hash(nested, use_or:)
+      end
+
+      error_klass = use_or ? OrError : AndError
+      expected = error_klass.from(expected_nodes)
+
+      assert false, "expected an error but no error present" if
+        expected.valid? && actual.valid?
+
+      checker = ErrorChecker.new(phrasing)
+      result = checker.check(expected, actual)
+
+      return if result.ok
+
+      reporter = Reporter.new
+
+      io = StringIO.new
+
+      io.puts <<~TEXT
+        #{result.reason}
+
+        expected:
+
+        #{reporter.report(expected).chomp}
+
+        but got:
+
+        #{reporter.report(actual).chomp}
+      TEXT
+
+      missing_phrases = result.missing_phrases
+      if missing_phrases && !missing_phrases.empty?
+        io.puts "\nmissing:"
+        missing_phrases.each do |phrase, count|
+          io.puts "- #{phrase}#{"(#{count}x)" if count > 1}"
+        end
+      end
+
+      extra_phrases = result.extra_phrases
+      if extra_phrases && !extra_phrases.empty?
+        io.puts "\nextra:"
+        extra_phrases.each do |phrase, count|
+          io.puts "- #{phrase}#{"(#{count}x)" if count > 1}"
+        end
+      end
+
+      assert false, io.string
+    end
+
+    def nested_from_hash(hash, use_or: false)
+      hash.map do |key, value|
+        node = if value.is_a?(Hash)
+          klass = use_or ? OrError : AndError
+          klass.from(nested_from_hash(value, use_or:))
+        else
+          ElementError.new(value)
+        end
+
+        NestedError.from(key, node)
+      end
+    end
+  end
+end

data/lib/matcher/undefined.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Undefined
+    include Singleton
+    include NoMatcher
+    include NoExpression
+    include NoKey
+  end
+end