exhale 0.1.0 → 0.2.0

data/lib/exhale/complexity/cognitive.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../units/ruby"
+
+module Exhale
+  module Complexity
+    # One increment of a unit's score.
+    #
+    # line      - Where the construct that earned it sits.
+    # construct - What earned it: "if", "elsif", "&&", "each block", "send".
+    # nesting   - The nesting level at the construct.
+    # increment - 1, plus the nesting level for the constructs that pay it.
+    # meta      - true for a metaprogramming point.
+    Point = Struct.new(:line, :construct, :nesting, :increment, :meta, keyword_init: true)
+
+    # G. Ann Campbell's Cognitive Complexity read off the Prism tree, with the
+    # Ruby decisions in contract/cognitive/README.md.
+    class Cognitive
+      ITERATORS = %i[
+        each map flat_map collect filter_map select filter reject find detect find_index find_all
+        any? all? none? one? count sum inject reduce group_by partition sort_by min_by max_by minmax_by
+        uniq zip take_while drop_while chunk_while slice_when times upto downto step loop cycle
+        with_index with_object map! collect! select! filter! reject! sort_by!
+      ].freeze
+
+      METAPROGRAMMING = %i[
+        eval instance_eval class_eval module_eval instance_exec class_exec module_exec
+        define_method define_singleton_method send __send__ public_send
+        instance_variable_get instance_variable_set const_get
+      ].freeze
+
+      def self.points(unit)
+        raise ArgumentError, "#{unit.identity} isn't Ruby; templates aren't scored" unless unit.language == :ruby
+
+        new(unit.node, method_name(unit)).points
+      end
+
+      # The name a recursive call would use. A DSL body has none, and neither
+      # does a define_method named only by its ordinal.
+      def self.method_name(unit)
+        return unless unit.kind == :method
+
+        name = unit.name.sub(/\[\d+\]\z/, "")
+        name unless !unit.node.is_a?(Prism::DefNode) && Units::Ruby::DEFINE_METHODS.key?(name.to_sym)
+      end
+
+      def initialize(node, name)
+        @node = node
+        @name = name&.to_sym
+      end
+
+      # Sorted by line, then in the order the walk met them.
+      def points
+        @points = []
+        @recursed = false
+        root
+        @points.each_with_index.sort_by { |point, index| [point.line, index] }.map(&:first)
+      end
+
+      private
+
+      # The unit's own def, block or lambda is its body, at nesting 0.
+      def root
+        flat("method_missing", @node.location.start_line, 0, meta: true) if @name == :method_missing
+        visit(@node.parameters, 0)
+        visit(@node.body, 0)
+      end
+
+      def visit(node, nesting)
+        return if node.nil? || node.is_a?(Prism::DefNode)
+
+        case node
+        when Prism::IfNode then if_node(node, nesting)
+        when Prism::UnlessNode then unless_node(node, nesting)
+        when Prism::WhileNode, Prism::UntilNode then loop_node(node, nesting)
+        when Prism::ForNode then for_node(node, nesting)
+        when Prism::CaseNode, Prism::CaseMatchNode then case_node(node, nesting)
+        when Prism::BeginNode then begin_node(node, nesting)
+        when Prism::RescueModifierNode then rescue_modifier(node, nesting)
+        when Prism::AndNode, Prism::OrNode then boolean(node, nesting)
+        when Prism::CallNode then call(node, nesting)
+        when Prism::BlockNode, Prism::LambdaNode then nested_body(node, nesting)
+        else children(node, nesting)
+        end
+      end
+
+      def children(node, nesting)
+        node.compact_child_nodes.each { |child| visit(child, nesting) }
+      end
+
+      def nested(construct, line, nesting)
+        @points << Point.new(line: line, construct: construct, nesting: nesting, increment: 1 + nesting, meta: false)
+      end
+
+      def flat(construct, line, nesting, meta: false)
+        @points << Point.new(line: line, construct: construct, nesting: nesting, increment: 1, meta: meta)
+      end
+
+      # A ternary has no if keyword, and its else costs nothing.
+      def if_node(node, nesting)
+        ternary = node.if_keyword_loc.nil?
+        nested(ternary ? "ternary" : "if", line(node.if_keyword_loc || node.location), nesting)
+        visit(node.predicate, nesting)
+        visit(node.statements, nesting + 1)
+        ternary ? visit(node.subsequent&.statements, nesting + 1) : branches(node.subsequent, nesting)
+      end
+
+      def branches(branch, nesting)
+        case branch
+        when Prism::IfNode
+          flat("elsif", line(branch.if_keyword_loc), nesting)
+          visit(branch.predicate, nesting)
+          visit(branch.statements, nesting + 1)
+          branches(branch.subsequent, nesting)
+        when Prism::ElseNode
+          flat("else", line(branch.else_keyword_loc), nesting)
+          visit(branch.statements, nesting + 1)
+        end
+      end
+
+      def unless_node(node, nesting)
+        nested("unless", line(node.keyword_loc), nesting)
+        visit(node.predicate, nesting)
+        visit(node.statements, nesting + 1)
+        branches(node.else_clause, nesting)
+      end
+
+      def loop_node(node, nesting)
+        nested(node.keyword_loc.slice, line(node.keyword_loc), nesting)
+        visit(node.predicate, nesting)
+        visit(node.statements, nesting + 1)
+      end
+
+      def for_node(node, nesting)
+        nested("for", line(node.for_keyword_loc), nesting)
+        visit(node.index, nesting)
+        visit(node.collection, nesting)
+        visit(node.statements, nesting + 1)
+      end
+
+      # One charge for the whole case; its branches and else sit inside it.
+      def case_node(node, nesting)
+        nested(node.is_a?(Prism::CaseMatchNode) ? "case/in" : "case", line(node.case_keyword_loc), nesting)
+        visit(node.predicate, nesting)
+        node.conditions.each { |condition| case_branch(condition, nesting + 1) }
+        visit(node.else_clause&.statements, nesting + 1)
+      end
+
+      # A guard on an `in` branch is an if or unless around the pattern in
+      # Prism, but it costs 1 flat.
+      def case_branch(condition, nesting)
+        guard = condition.pattern if condition.is_a?(Prism::InNode)
+        return visit(condition, nesting) unless guard.is_a?(Prism::IfNode) || guard.is_a?(Prism::UnlessNode)
+
+        keyword = guard.is_a?(Prism::IfNode) ? guard.if_keyword_loc : guard.keyword_loc
+        flat("#{keyword.slice} guard", line(keyword), nesting)
+        visit(guard.statements, nesting)
+        visit(guard.predicate, nesting)
+        visit(condition.statements, nesting)
+      end
+
+      # The else of a begin/rescue and its ensure cost nothing and don't nest.
+      def begin_node(node, nesting)
+        visit(node.statements, nesting)
+        clause = node.rescue_clause
+        while clause
+          nested("rescue", line(clause.keyword_loc), nesting)
+          clause.exceptions.each { |exception| visit(exception, nesting) }
+          visit(clause.reference, nesting)
+          visit(clause.statements, nesting + 1)
+          clause = clause.subsequent
+        end
+        visit(node.else_clause&.statements, nesting)
+        visit(node.ensure_clause&.statements, nesting)
+      end
+
+      def rescue_modifier(node, nesting)
+        nested("rescue", line(node.keyword_loc), nesting)
+        visit(node.expression, nesting)
+        visit(node.rescue_expression, nesting + 1)
+      end
+
+      # One point per run of like operators, in source order. `!` and
+      # parentheses are see-through, so `a && !(b && c)` is one run.
+      def boolean(node, nesting)
+        operators = []
+        operands = []
+        flatten(node, operators, operands)
+        operators.each_with_index do |(kind, at), index|
+          flat(kind, at, nesting) if index.zero? || operators[index - 1].first != kind
+        end
+        operands.each { |operand| visit(operand, nesting) }
+      end
+
+      def flatten(node, operators, operands)
+        if node.is_a?(Prism::AndNode) || node.is_a?(Prism::OrNode)
+          flatten(node.left, operators, operands)
+          operators << [node.is_a?(Prism::AndNode) ? "&&" : "||", line(node.operator_loc)]
+          flatten(node.right, operators, operands)
+        elsif (inner = see_through(node))
+          flatten(inner, operators, operands)
+        else
+          operands << node
+        end
+      end
+
+      def see_through(node)
+        case node
+        when Prism::ParenthesesNode
+          body = node.body
+          body.is_a?(Prism::StatementsNode) && body.body.size == 1 ? body.body.first : nil
+        when Prism::CallNode
+          node.receiver if node.name == :! && node.arguments.nil? && node.block.nil?
+        end
+      end
+
+      def call(node, nesting)
+        at = line(node.message_loc || node.location)
+        recursion(node, at, nesting)
+        flat(node.name.to_s, at, nesting, meta: true) if METAPROGRAMMING.include?(node.name)
+        visit(node.receiver, nesting)
+        visit(node.arguments, nesting)
+        block(node, nesting)
+      end
+
+      def recursion(node, at, nesting)
+        return if @recursed || @name.nil? || node.name != @name
+        return unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+
+        @recursed = true
+        flat("recursion", at, nesting)
+      end
+
+      # `&:sym` and `&method(:x)` aren't blocks. A define_method block inside
+      # a unit is no unit of its own (Units::Ruby stops at a unit), so it
+      # scores here like any block.
+      def block(node, nesting)
+        block = node.block
+        return visit(block, nesting) unless block.is_a?(Prism::BlockNode)
+
+        nested("#{node.name} block", line(block.opening_loc), nesting) if iterates?(node.name)
+        nested_body(block, nesting)
+      end
+
+      def nested_body(node, nesting)
+        visit(node.parameters, nesting + 1)
+        visit(node.body, nesting + 1)
+      end
+
+      def iterates?(name)
+        ITERATORS.include?(name) || name.start_with?("each_")
+      end
+
+      def line(location)
+        location.start_line
+      end
+    end
+  end
+end

data/lib/exhale/complexity/ratchet.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative "cognitive"
+require_relative "../dry/normalizer"
+require_relative "../dry/fingerprints"
+require_relative "../dry/index"
+
+module Exhale
+  module Complexity
+    # A unit and the points it scored, at the head or at the base.
+    Scored = Struct.new(:unit, :points) do
+      def self.of(unit)
+        new(unit, Cognitive.points(unit))
+      end
+
+      def score
+        points.sum(&:increment)
+      end
+
+      def meta
+        points.count(&:meta)
+      end
+    end
+
+    # One unit's verdict.
+    #
+    # label      - :raised and :introduced fail. :kept rose past the floor
+    #              within a ceiling. :rose, :new, :unchanged, :contracted and
+    #              :gone pass. With no base, :warning is over the floor and
+    #              :scored isn't.
+    # head, base - Scored, or nil on the side the unit is missing from.
+    # match      - :identity or :shape when both sides are there.
+    # similarity - The shape score of a :shape match.
+    # floor      - The floor the unit was judged against.
+    # ceiling    - The Contract clause that keeps it, or nil.
+    Row = Struct.new(:label, :head, :base, :match, :similarity, :floor, :ceiling, keyword_init: true) do
+      def failing?
+        Ratchet::FAILING.include?(label)
+      end
+
+      def unit
+        (head || base).unit
+      end
+    end
+
+    # Judges each head unit against its base unit. Only a rise can fail, so
+    # code is never punished for what it already was.
+    class Ratchet
+      FAILING = %i[raised introduced].freeze
+      SIMILARITY = Rational(80, 100)
+      # A unit that rose, a new unit, and a unit with no base to compare
+      # against: its label over its limit, and at or under it.
+      OUTCOMES = { rose: %i[raised rose], new: %i[introduced new], alone: %i[warning scored] }.freeze
+
+      # head and base are Scored lists in path and line order; base is nil
+      # when there's nothing to compare against. floor_for and ceiling_for
+      # take a unit.
+      def initialize(head:, base:, floor_for:, ceiling_for:)
+        @head = head
+        @base = base
+        @floor_for = floor_for
+        @ceiling_for = ceiling_for
+      end
+
+      def rows
+        return @head.map { |scored| judge(scored) } unless @base
+
+        pairs = match
+        taken = taken(pairs)
+        @head.map { |scored| judge(scored, *pairs[scored]) } +
+          @base.reject { |base| taken[base] }.map { |base| Row.new(label: :gone, base: base) }
+      end
+
+      private
+
+      def judge(head, base = nil, match = nil, similarity = nil)
+        floor = @floor_for.call(head.unit)
+        ceiling = @ceiling_for.call(head.unit)
+        Row.new(label: label(head.score, base&.score, floor, ceiling), head: head, base: base, match: match,
+                similarity: similarity, floor: floor, ceiling: ceiling)
+      end
+
+      # A ceiling only loosens: its max stands in for the floor when higher.
+      def label(score, base_score, floor, ceiling)
+        return :contracted if base_score && score < base_score
+        return :unchanged if score == base_score
+
+        over, under = OUTCOMES.fetch(situation(base_score))
+        return over if score > (ceiling ? [ceiling.max, floor].max : floor)
+
+        ceiling && score > floor ? :kept : under
+      end
+
+      def situation(base_score)
+        return :alone unless @base
+
+        base_score ? :rose : :new
+      end
+
+      # {head => [base, how, similarity]}: identity first, then shape.
+      def match
+        pairs = identity_pairs
+        taken = taken(pairs)
+        shape_matches(@head.reject { |h| pairs.key?(h) }, @base.reject { |b| taken[b] }).each do |head, base, score|
+          pairs[head] = [base, :shape, score]
+        end
+        pairs
+      end
+
+      def taken(pairs)
+        pairs.each_value.with_object({}.compare_by_identity) { |(base, *), taken| taken[base] = true }
+      end
+
+      def identity_pairs
+        pairs = {}.compare_by_identity
+        bases = @base.group_by { |scored| scored.unit.identity }
+        @head.group_by { |scored| scored.unit.identity }.each do |identity, heads|
+          pair_up(heads, bases.fetch(identity, [])).each { |head, base| pairs[head] = [base, :identity, nil] }
+        end
+        pairs
+      end
+
+      # An identity is unique within a file, so a unit pairs with the one in
+      # its own file first; the rest pair in path and line order.
+      def pair_up(heads, bases)
+        same = heads.filter_map { |head| (base = bases.find { |b| b.unit.path == head.unit.path }) && [head, base] }
+        rest = (heads - same.map(&:first)).zip(bases - same.map(&:last))
+        same + rest.select(&:last)
+      end
+
+      # Every pair at or over the threshold, best first; ties go to the base
+      # unit first in path and line order. Each side matches at most once.
+      def shape_matches(heads, bases)
+        return [] if heads.empty? || bases.empty?
+
+        entries = entries(heads + bases)
+        index = Dry::Index.new(entries)
+        greedy(candidates(index, entries.first(heads.size), entries.drop(heads.size)), heads, bases)
+      end
+
+      def entries(scored)
+        scored.each_with_index.map do |each, id|
+          tree = Dry::Fingerprints.build(Dry::Normalizer.normalize(each.unit))
+          Dry::Entry.new(id: id, unit: each.unit, tree: tree, set: tree.digests)
+        end
+      end
+
+      # [[score, base index, head index]] for every pair at the threshold.
+      def candidates(index, heads, bases)
+        heads.each_with_index.flat_map do |h, hi|
+          bases.each_with_index.filter_map { |b, bi| (score = similarity(index, h, b)) && [score, bi, hi] }
+        end
+      end
+
+      def similarity(index, a, b)
+        return unless close?(a.total, b.total)
+
+        score = index.score(a.set, a.total, b.set, b.total)
+        score if score >= SIMILARITY
+      end
+
+      def greedy(candidates, heads, bases)
+        used_heads = {}
+        used_bases = {}
+        candidates.sort_by { |score, bi, hi| [-score, bi, hi] }.filter_map do |score, bi, hi|
+          next if used_heads[hi] || used_bases[bi]
+
+          used_heads[hi] = used_bases[bi] = true
+          [heads[hi], bases[bi], score]
+        end
+      end
+
+      # Jaccard can't reach the threshold when one side outweighs the other
+      # by more than its inverse, so those pairs aren't scored.
+      def close?(a, b)
+        small, large = [a, b].minmax
+        small * SIMILARITY.denominator >= large * SIMILARITY.numerator
+      end
+    end
+  end
+end

data/lib/exhale/contract/markdown.rb

@@ -69,7 +69,7 @@ module Exhale
         if closes?(line, fence)
           state[:blocks] << finish(fence)
           state[:fence] = nil
-          state[:prose] = [] if %w[parallel settings covers].include?(fence[:info])
+          state[:prose] = [] if %w[parallel settings covers ceiling].include?(fence[:info])
         else
           fence[:body] << [line, no]
         end

data/lib/exhale/contract.rb

@@ -11,23 +11,38 @@ require_relative "contract/resolver"
 
 module Exhale
   # The Contract: Markdown under <root>/contract/<primitive>/ that declares which
-  # code belongs to a primitive and which units are deliberately parallel.
+  # code belongs to a primitive, which units are deliberately parallel, and
+  # which stay complex up to a ceiling. Each check reads only its own files:
+  # duplication.md for dry, complexity.md for complexity.
   class Contract
     Primitive = Struct.new(:name, :path, :covers)
-    Clause = Struct.new(:primitive, :kind, :path, :line, :heading, :reason, :references, :key)
-
-    CONTENT = %w[covers parallel settings].freeze
-    SETTING_KEYS = { "threshold" => :threshold, "min-lines" => :min_lines, "min-nodes" => :min_nodes }.freeze
+    # max is a ceiling's limit, nil for a parallel clause.
+    Clause = Struct.new(:primitive, :kind, :path, :line, :heading, :reason, :references, :key, :max)
+
+    CONTENT = %w[covers parallel settings ceiling].freeze
+    # The blocks each check's own file holds, and the settings it takes.
+    BLOCKS = { dry: %w[parallel settings], complexity: %w[ceiling settings] }.freeze
+    SETTING_KEYS = {
+      dry: { "threshold" => :threshold, "min-lines" => :min_lines, "min-nodes" => :min_nodes },
+      complexity: { "floor" => :floor }
+    }.freeze
+    HOME = { "parallel" => "duplication.md", "ceiling" => "complexity.md", "covers" => "README.md" }.freeze
+    # A floor of 0 is allowed: every rise then fails.
+    MINIMUMS = { min_lines: 1, min_nodes: 1, floor: 0 }.freeze
+    MAX = /\Amax:\s*(.*)\z/
 
     attr_reader :primitives, :clauses, :settings, :errors
 
-    def self.load(root, dir: "contract")
-      new(root, dir).tap(&:parse)
+    def self.load(root, dir: "contract", check: :dry)
+      new(root, dir, check).tap(&:parse)
     end
 
-    def initialize(root, dir)
+    def initialize(root, dir, check = :dry)
+      raise ArgumentError, "unknown check #{check.inspect}" unless BLOCKS.key?(check)
+
       @root = Pathname.new(root.to_s)
       @dir = dir
+      @check = check
       @primitives = []
       @clauses = []
       @settings = {}
@@ -75,16 +90,27 @@ module Exhale
       readme = dir.join("README.md")
       each_block(readme) { |block, path| readme_block(covers, block, path) } if real_file?(readme)
       @primitives << Primitive.new(name, rel(dir), covers)
-      duplication_files(dir).each do |file|
-        each_block(file) { |block, path| duplication_block(name, block, path) }
+      check_files(dir).each do |file|
+        each_block(file) { |block, path| check_block(name, block, path) }
       end
       stray_files(dir).each do |file|
-        each_block(file) { |block, path| misplaced(block, path, "found in a stray file; use README.md or duplication.md") if CONTENT.include?(block.info) }
+        each_block(file) do |block, path|
+          next unless CONTENT.include?(block.info)
+
+          misplaced(block, path, "found in a stray file; use README.md, duplication.md or complexity.md")
+        end
       end
     end
 
+    def check_files(dir)
+      return duplication_files(dir) if @check == :dry
+
+      file = dir.join("complexity.md")
+      real_file?(file) ? [file] : []
+    end
+
     def stray_files(dir)
-      known = [dir.join("README.md"), dir.join("duplication.md")].map(&:to_s)
+      known = %w[README.md duplication.md complexity.md].map { |name| dir.join(name).to_s }
       markdown_files(dir).reject { |f| known.include?(f.to_s) || f.to_s.start_with?(dir.join("duplication/").to_s) }
     end
 
@@ -95,7 +121,8 @@ module Exhale
     def readme_block(covers, block, path)
       case block.info
       when "covers" then covers.concat(references(block, path))
-      when "parallel", "settings" then misplaced(block, path, "belongs in duplication.md")
+      when "parallel", "ceiling" then misplaced(block, path, "belongs in #{HOME[block.info]}")
+      when "settings" then misplaced(block, path, "belongs in duplication.md or complexity.md")
       end
     end
 
@@ -128,11 +155,16 @@ module Exhale
       Markdown.blocks(text).each { |block| yield block, path }
     end
 
-    def duplication_block(primitive, block, path)
+    # A block type that belongs to the other check, or to README.md, is an
+    # error where it sits.
+    def check_block(primitive, block, path)
+      return unless CONTENT.include?(block.info)
+      return misplaced(block, path, "belongs in #{HOME[block.info]}") unless BLOCKS[@check].include?(block.info)
+
       case block.info
       when "parallel" then add_clause(primitive, block, path)
-      when "settings" then add_settings(primitive, block, path)
-      when "covers" then misplaced(block, path, "belongs in README.md")
+      when "ceiling" then add_ceiling(primitive, block, path)
+      else add_settings(primitive, block, path)
       end
     end
 
@@ -151,6 +183,35 @@ module Exhale
       @clauses << Clause.new(primitive, :parallel, path, block.line, block.heading, block.reason, refs, key)
     end
 
+    # A ceiling names units and gives one `max: N` they may reach.
+    def add_ceiling(primitive, block, path)
+      lines = block.body.map { |text, no| [Markdown.strip_comment(text), no] }.reject { |line, _| line.empty? }
+      maxes, names = lines.partition { |line, _| MAX.match?(line) }
+      return @errors << ContractError.new(path, block.line, "ceiling block names no unit") if names.empty?
+      return unless (max = ceiling_max(maxes, block, path))
+
+      refs = names.map { |line, no| Reference.new(line, path, no) }
+      key = Digest::SHA256.hexdigest("#{primitive}|ceiling|#{max}|#{refs.map(&:text).sort.join("\n")}")
+      @clauses << Clause.new(primitive, :ceiling, path, block.line, block.heading, block.reason, refs, key, max)
+    end
+
+    # The one max a ceiling gives, or nil once the reason it has none is
+    # recorded.
+    def ceiling_max(maxes, block, path)
+      return ceiling_error(path, block.line, "ceiling block needs max: N") if maxes.empty?
+      return ceiling_error(path, maxes[1].last, "repeated max in a ceiling block") if maxes.size > 1
+
+      text, no = maxes.first
+      value = MAX.match(text)[1]
+      max = Integer(value, 10, exception: false)
+      max && max >= 0 ? max : ceiling_error(path, no, "bad value for max: #{value.inspect}")
+    end
+
+    def ceiling_error(path, line, message)
+      @errors << ContractError.new(path, line, message)
+      nil
+    end
+
     def add_settings(primitive, block, path)
       if @settings.key?(primitive)
         return @errors << ContractError.new(path, block.line, "second settings block for #{primitive}")
@@ -166,7 +227,7 @@ module Exhale
 
     def parse_setting(line, path, no, acc)
       key, value = line.split(":", 2).map(&:strip)
-      sym = SETTING_KEYS[key]
+      sym = SETTING_KEYS[@check][key]
       return @errors << ContractError.new(path, no, "unknown setting: #{key}") unless sym
 
       parsed = setting_value(sym, value)
@@ -183,7 +244,7 @@ module Exhale
         f if f && f > 0 && f <= 1
       else
         i = Integer(value.to_s, 10, exception: false)
-        i if i && i >= 1
+        i if i && i >= MINIMUMS.fetch(sym)
       end
     end
 

data/lib/exhale/dry/check.rb

@@ -11,8 +11,7 @@ require_relative "../version"
 require_relative "../errors"
 require_relative "../git"
 require_relative "../source_files"
-require_relative "../units/ruby"
-require_relative "../units/erb"
+require_relative "../units"
 require_relative "../contract"
 require_relative "normalizer"
 require_relative "fingerprints"
@@ -38,8 +37,7 @@ module Exhale
       end
 
       def run
-        @parse_errors = []
-        @units = read_units
+        @units, @parse_errors = Units.read(@root, files: @files, include_tests: @include_tests)
         @contract = Contract.load(@root, dir: @contract_dir)
         @resolver = Contract::Resolver.new(@contract, @units)
         @index = Index.new(entries)
@@ -55,28 +53,6 @@ module Exhale
 
       private
 
-      # A file that can't be read, or isn't UTF-8, is a parse error like any
-      # other: the gate never passes code it didn't read.
-      def read_units
-        SourceFiles.list(@root, files: @files, include_tests: @include_tests).flat_map do |path, language|
-          source = read_source(path)
-          language == :ruby ? Units::Ruby.extract(source, path) : Units::Erb.extract(source, path)
-        rescue ParseError => e
-          @parse_errors << e
-          []
-        end
-      end
-
-      def read_source(path)
-        source = File.read(File.join(@root, path), encoding: "UTF-8")
-        return source if source.valid_encoding?
-
-        line = source.each_line.find_index { |text| !text.valid_encoding? }.to_i + 1
-        raise ParseError.new(path, line, "isn't valid UTF-8")
-      rescue SystemCallError, IOError => e
-        raise ParseError.new(path, 1, "can't be read: #{e.message}")
-      end
-
       def entries
         @units.each_with_index.map do |unit, id|
           tree = Fingerprints.build(Normalizer.normalize(unit))