scully 0.0.1 → 0.1.0

data/lib/scully/frameworks/rspec.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Scully
+  module Frameworks
+    # Turns an RSpec file into TestCases: examples inside describe/context/shared groups, with
+    # their status, the setup of every enclosing group, and the assertions in their bodies.
+    class RSpec
+      GROUPS = %i[describe context feature example_group shared_examples shared_examples_for shared_context
+                  fdescribe fcontext ffeature].freeze
+      SKIPPED_GROUPS = %i[xdescribe xcontext xfeature].freeze
+      EXAMPLES = %i[it specify example scenario fit fspecify fexample fscenario].freeze
+      SKIPPED_EXAMPLES = %i[xit xspecify xexample xscenario].freeze
+      # `pending "..." do` and `skip "..." do` at group level declare examples; inside an
+      # example, `pending` and `skip` calls mark it.
+      MARKERS = { pending: :pending, skip: :skipped }.freeze
+      HOOKS = { before: :before, prepend_before: :before, append_before: :before, around: :before,
+                after: :teardown, prepend_after: :teardown, append_after: :teardown }.freeze
+      LETS = { let: :let, let!: :let, subject: :subject, subject!: :subject }.freeze
+      SETUP = HOOKS.merge(LETS).freeze
+
+      # The names, setup, bindings and setup doubles visible inside a group, and the status a
+      # skipped or pending group gives its examples.
+      Context = Data.define(:names, :setup, :bindings, :doubles, :marked)
+      # `is_expected` and a bare `should` check the subject.
+      SUBJECT_READERS = %i[is_expected should should_not].freeze
+
+      include Syntax
+
+      def self.call(source) = new(source).test_cases
+
+      def initialize(source)
+        @source = source
+        @helpers = Helpers.new(source.result.value, assertion: ->(call) { !Expectations.fields(call).nil? })
+      end
+
+      def test_cases
+        @tests = []
+        walk(@source.result.value.statements,
+             Context.new(names: [], setup: [], bindings: {}, doubles: [], marked: nil))
+        @tests
+      end
+
+      private
+
+      def walk(node, context)
+        statements(node).each { statement(it, context) }
+      end
+
+      def statement(node, context)
+        case node
+        when Prism::ModuleNode, Prism::ClassNode then walk(node.body, context)
+        when Prism::ItLocalVariableReadNode then bare_example(node, context)
+        when Prism::CallNode then call_statement(node, context)
+        end
+      end
+
+      # Examples generated in loops (`%w[a b].each do ... it ... end`) belong to the group.
+      def call_statement(call, context)
+        if group?(call) then walk(call.block.body, group_context(call, context))
+        elsif example?(call) then example(call, context)
+        elsif call.block.is_a?(Prism::BlockNode) && !setup_call?(call) then walk(call.block.body, context)
+        end
+      end
+
+      def group?(call)
+        (call.receiver.nil? || Detector.rspec_receiver?(call.receiver)) && call.block.is_a?(Prism::BlockNode) &&
+          (GROUPS.include?(call.name) || SKIPPED_GROUPS.include?(call.name))
+      end
+
+      def example?(call)
+        return false unless call.receiver.nil?
+        return true if EXAMPLES.include?(call.name) || SKIPPED_EXAMPLES.include?(call.name)
+
+        MARKERS.key?(call.name) && !(call.block || description(call)).nil?
+      end
+
+      def setup_call?(call) = call.receiver.nil? && SETUP.key?(call.name)
+
+      def group_context(call, context)
+        own = own_setup(call.block.body)
+        context.with(names: [*context.names, *description(call)], marked: context.marked || Status.group(call),
+                     **setup_from(own, context))
+      end
+
+      def setup_from(own, context)
+        { setup: context.setup + own.map { setup_step(it) },
+          bindings: context.bindings.merge(*own.map { Scope.bindings(it) }),
+          doubles: context.doubles + own.flat_map { Scope.doubles(it, Doubles.new(@source, :setup)) } }
+      end
+
+      def own_setup(body) = statements(body).select { it.is_a?(Prism::CallNode) && setup_call?(it) }
+
+      def setup_step(call) = SetupStep.new(kind: SETUP[call.name], span: span(call.location))
+
+      def example(call, context)
+        add(context, name: name(context, description(call), call), definition: definition(call),
+                     extent: call.location, status: Status.of(call, context), **contents(call.block&.body, context))
+      end
+
+      # Bindings, assertions, helper calls and doubles of an example body.
+      def contents(body, context)
+        bindings = context.bindings.merge(assignments(body).to_h)
+        assertions, helper_calls = inventory(context).scan(body)
+        { bindings:, helper_calls:, assertions: assertions.map { Scope.read_subject(it, bindings) },
+          doubles: context.doubles + Stubs.scan(body, Doubles.new(@source, :body)) }
+      end
+
+      # A bare `it` inside a group is a pending example; Ruby reads it as the block's `it` parameter.
+      def bare_example(node, context)
+        add(context, name: name(context, nil, node), definition: node.location, extent: node.location,
+                     status: :pending, assertions: [], helper_calls: [], bindings: context.bindings,
+                     doubles: context.doubles)
+      end
+
+      def add(context, definition:, extent:, **fields)
+        @tests << TestCase.new(span: span(definition), extent: span(extent), framework: :rspec, setup: context.setup,
+                               **fields)
+      end
+
+      def name(context, description, node)
+        [*context.names, description || "example at line #{node.location.start_line}"].join(' ')
+      end
+
+      def span(location) = @source.span(location)
+
+      def inventory(context)
+        Inventory.new(source: @source, helpers: @helpers, assertion: Expectations.method(:fields),
+                      ignored: ->(name) { Expectations::VOCABULARY.include?(name) || context.bindings.include?(name) })
+      end
+
+      # Decides whether an example is active, pending or skipped.
+      module Status
+        module_function
+
+        def of(call, context)
+          return context.marked if context.marked
+          return :skipped if SKIPPED_EXAMPLES.include?(call.name)
+
+          MARKERS[call.name] || metadata(call) || (call.block ? body(call.block.body) || :active : :pending)
+        end
+
+        # A skipped or pending group marks every example inside it the same way.
+        def group(call) = SKIPPED_GROUPS.include?(call.name) ? :skipped : metadata(call)
+
+        # `:skip`, `:pending`, `skip: ...` or `pending: ...` metadata; a false or nil value does not count.
+        def metadata(call)
+          (call.arguments&.arguments || []).each do |argument|
+            status = case argument
+                     when Prism::SymbolNode then MARKERS[argument.unescaped.to_sym]
+                     when Prism::KeywordHashNode then keyword(argument)
+                     end
+            return status if status
+          end
+          nil
+        end
+
+        def keyword(hash)
+          hash.elements.each do |element|
+            next unless element.is_a?(Prism::AssocNode) && element.key.is_a?(Prism::SymbolNode)
+            next if element.value.is_a?(Prism::FalseNode) || element.value.is_a?(Prism::NilNode)
+
+            status = MARKERS[element.key.unescaped.to_sym]
+            return status if status
+          end
+          nil
+        end
+
+        # A `skip` or `pending` call anywhere in the body marks the example.
+        def body(node)
+          node&.compact_child_nodes&.each do |child|
+            next if child.is_a?(Prism::DefNode)
+
+            status = marker(child) || body(child)
+            return status if status
+          end
+          nil
+        end
+
+        def marker(node) = node.is_a?(Prism::CallNode) && node.receiver.nil? ? MARKERS[node.name] : nil
+      end
+
+      # What a group's setup gives its examples: bindings from `let`/`subject` and doubles.
+      module Scope
+        module_function
+
+        # `let(:tax) { ... }` binds `tax`; a named subject also binds `subject`.
+        def bindings(call)
+          return {} unless LETS.key?(call.name)
+
+          value = Syntax.block_value(call)
+          name = Syntax.binding_name(call)
+          call.name.start_with?('subject') ? { name => value, subject: value } : { name => value }
+        end
+
+        # Doubles from a `let`/`subject` value, and stubs in `before` hooks; teardown hooks run
+        # too late to matter.
+        def doubles(call, doubles)
+          if LETS.key?(call.name)
+            Stubs.attributes(Syntax.block_value(call), Syntax.binding_name(call), doubles) || []
+          elsif HOOKS[call.name] == :before
+            Stubs.scan(call.block&.body, doubles)
+          else
+            []
+          end
+        end
+
+        # `is_expected.to eq(x)` checks the value `subject` is bound to.
+        def read_subject(assertion, bindings)
+          reader = assertion.subject
+          return assertion unless reader.is_a?(Prism::CallNode) && reader.receiver.nil? &&
+                                  SUBJECT_READERS.include?(reader.name)
+
+          assertion.with(subject: bindings[:subject])
+        end
+      end
+
+      # Finds RSpec stubs (`allow(r).to receive(:m).and_return(v)`, `receive_messages`), message
+      # expectations that also return a value, and doubles created with preset attributes.
+      module Stubs
+        # Stub target => whether it is a stub source. `expect(...).to receive` can fail on its own.
+        TARGETS = { allow: true, allow_any_instance_of: true, expect: false, expect_any_instance_of: false }.freeze
+        DOUBLES = %i[double instance_double class_double object_double spy instance_spy class_spy object_spy].freeze
+
+        module_function
+
+        # The TestDoubles in +node+, in source order. +doubles+ is a Frameworks::Doubles.
+        def scan(node, doubles, found = [])
+          node&.compact_child_nodes&.each do |child|
+            next if child.is_a?(Prism::DefNode)
+
+            matched = stub(child, doubles) || local_double(child, doubles)
+            matched ? found.concat(matched) : scan(child, doubles, found)
+          end
+          found
+        end
+
+        # `allow(r).to receive(:m).and_return(v)`: the matcher chain is inside-out, so the
+        # innermost call names the method and an `and_return` around it gives the value.
+        def stub(node, doubles)
+          target = target(node) or return
+          receiver = Syntax.arguments(target).first or return
+
+          matcher = Syntax.chain(Syntax.arguments(node).first)
+          stubbed(matcher, node.location, doubles, receiver:, stub_source: TARGETS[target.name])
+        end
+
+        # The `allow(r)` or `expect(r)` a `.to` call is made on, or nil.
+        def target(node)
+          target = node.receiver if node.is_a?(Prism::CallNode) && node.name == :to
+          target if target.is_a?(Prism::CallNode) && target.receiver.nil? && TARGETS.key?(target.name)
+        end
+
+        def stubbed(chain, location, doubles, **fields)
+          case chain.last&.name
+          when :receive
+            name = Syntax.stubbed_name(chain.last) or return
+            [doubles.build(location, method_name: name, returns: returned(chain), **fields)]
+          when :receive_messages
+            Syntax.keyword_pairs(chain.last).map do |name, value|
+              doubles.build(location, method_name: name, returns: value, **fields)
+            end
+          end
+        end
+
+        # The single value given to `and_return`; several values are a sequence, not one value.
+        def returned(chain)
+          and_return = chain.find { it.name == :and_return } or return
+          values = Syntax.arguments(and_return)
+          values.first if values.size == 1
+        end
+
+        # `tax = double(rate: 0.2)`
+        def local_double(node, doubles)
+          attributes(node.value, node.name, doubles) if node.is_a?(Prism::LocalVariableWriteNode)
+        end
+
+        # The preset attributes of a double bound to +name+, one TestDouble each; nil when +value+
+        # does not create a double.
+        def attributes(value, name, doubles)
+          return unless value.is_a?(Prism::CallNode) && value.receiver.nil? && DOUBLES.include?(value.name)
+
+          receiver = Syntax.identifier(name)
+          Syntax.keyword_pairs(value).map do |method_name, returns|
+            doubles.build(value.location, receiver:, method_name:, returns:)
+          end
+        end
+      end
+
+      # Recognises RSpec expectations and classifies their matchers.
+      module Expectations
+        TARGETS = %i[expect is_expected are_expected expect_any_instance_of].freeze
+        RUNNERS = %i[to not_to to_not].freeze
+        SHOULD = %i[should should_not].freeze
+        COMPARISONS = { eq: :equality, eql: :equality, equal: :identity }.freeze
+        RAISE_CHECKS = %i[raise_error raise_exception].freeze
+        MESSAGE_EXPECTATIONS = %i[receive receive_messages receive_message_chain have_received].freeze
+        # Minitest assertions that rspec-rails mixes into examples, and Capybara's
+        # `page.assert_selector`-style matchers, with or without a receiver.
+        MINITEST = /\A(assert|refute)(_|\z)/
+
+        # Receiverless calls that are RSpec or Ruby vocabulary, never assertion helpers.
+        VOCABULARY = Set[
+          *GROUPS, *SKIPPED_GROUPS, *EXAMPLES, *SKIPPED_EXAMPLES, *MARKERS.keys, *SETUP.keys, *TARGETS,
+          *MESSAGE_EXPECTATIONS, :allow, :allow_any_instance_of, :double, :instance_double, :class_double,
+          :object_double, :spy, :instance_spy, :class_spy, :object_spy, :described_class, :aggregate_failures,
+          :anything, :any_args, :no_args, :hash_including, :array_including, :instance_of, :kind_of,
+          :include_examples, :include_context, :it_behaves_like, :it_should_behave_like,
+          :puts, :p, :pp, :print, :raise, :fail, :lambda, :proc, :loop, :sleep, :require, :require_relative, :format
+        ].freeze
+
+        module_function
+
+        # Assertion fields for an expectation, or nil when +call+ is not one.
+        def fields(call)
+          if runner?(call)
+            matcher(argument(call), subject(call.receiver), negated: call.name != :to)
+          elsif SHOULD.include?(call.name) then should(call)
+          elsif should_operator?(call)
+            { kind: :comparison, comparison: :equality, subject: call.receiver.receiver, expected: argument(call) }
+          elsif MINITEST.match?(call.name) then minitest(call)
+          end
+        end
+
+        # Receiverless `assert_equal expected, actual` reads as in Minitest; receiver forms
+        # (`page.assert_selector`) are matchers that check nothing comparable.
+        def minitest(call)
+          return { kind: :other, comparison: nil, subject: nil, expected: nil } if call.receiver
+
+          Frameworks::Minitest::Assertions.assertion(call)
+        end
+
+        # `x.should eq(1)`; a bare `should` stands in for the subject until the normalizer resolves it.
+        def should(call) = matcher(argument(call), call.receiver || call, negated: call.name == :should_not)
+
+        # `expect(x).to`, `is_expected.not_to`, `expect { }.to`
+        def runner?(call)
+          target = call.receiver
+          RUNNERS.include?(call.name) && target.is_a?(Prism::CallNode) && target.receiver.nil? &&
+            TARGETS.include?(target.name)
+        end
+
+        # `expect(x)` checks x. `is_expected` stands in for the subject until the normalizer
+        # resolves it; block expectations have no subject expression.
+        def subject(target)
+          case target.name
+          when :expect then argument(target)
+          when :is_expected then target
+          end
+        end
+
+        # `x.should == 1`
+        def should_operator?(call)
+          call.name == :== && call.receiver.is_a?(Prism::CallNode) && call.receiver.name == :should
+        end
+
+        def argument(call) = call.arguments&.arguments&.first
+
+        # Matchers chain inside-out (`receive(:m).with(1)`): the innermost call names the matcher.
+        def matcher(node, subject, negated:)
+          node = node.receiver while node.is_a?(Prism::CallNode) && node.receiver.is_a?(Prism::CallNode)
+          kind, comparison = classify(node.is_a?(Prism::CallNode) ? node : nil)
+          comparison = nil if negated
+          { kind:, comparison:, subject:, expected: comparison && argument(node) }
+        end
+
+        def classify(matcher)
+          name = matcher&.name
+          return [:comparison, COMPARISONS[name]] if COMPARISONS.key?(name)
+          return matcher.arguments ? %i[comparison identity] : [:predicate, nil] if name == :be
+
+          [kind(name), nil]
+        end
+
+        def kind(name)
+          if RAISE_CHECKS.include?(name) then :raise_check
+          elsif MESSAGE_EXPECTATIONS.include?(name) then :message_expectation
+          elsif name&.start_with?('be_', 'have_') then :predicate
+          else :other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scully/model.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Scully
+  # A region of a source file. Lines and columns are 1-based; columns count characters.
+  # The end column is exclusive, so a zero-length span has start_column == end_column.
+  Span = Data.define(:path, :start_line, :start_column, :end_line, :end_column) do
+    def sort_key = [path.b, start_line, start_column]
+  end
+
+  # A span with the text printed next to its marker.
+  Label = Data.define(:span, :text)
+
+  # A setup or teardown step from an enclosing group: :before, :setup, :let, :subject, :teardown.
+  SetupStep = Data.define(:kind, :span)
+
+  # An assertion found in a test body. +subject+ and +expected+ are opaque expressions.
+  Assertion = Data.define(:span, :kind, :comparison, :subject, :expected)
+
+  # A stub, double, or message expectation.
+  TestDouble = Data.define(:span, :receiver, :method_name, :returns, :origin, :scope, :stub_source)
+
+  # A call in a test body that may be an assertion helper.
+  HelperCall = Data.define(:name, :span, :resolution)
+
+  # One test, normalized so that rules never depend on the framework. +span+ is the definition
+  # (`it "..."`, `def test_x`) that findings point at; +extent+ is the whole test, through its `end`.
+  TestCase = Data.define(
+    :name, :span, :extent, :framework, :status, :setup, :assertions, :doubles, :bindings, :helper_calls
+  )
+
+  # Severities a rule may declare, in report order.
+  SEVERITIES = %i[error warning].freeze
+
+  # A problem reported by a rule.
+  Finding = Data.define(:rule_id, :severity, :primary, :secondary, :test_name, :facts, :evidence) do
+    def sort_key = [SEVERITIES.index(severity), *primary.span.sort_key, rule_id.to_s]
+  end
+
+  # A syntax error reported by the parser.
+  ParseError = Data.define(:span, :message)
+
+  # The analysis of one file: status is :complete, :incomplete or :skipped.
+  FileReport = Data.define(:path, :framework, :status, :skip_reason, :parse_errors, :test_cases)
+
+  # The result of a run. +counts+ has the keys
+  # :files, :incomplete, :skipped, :tests, :not_analyzed, :errors, :warnings.
+  RunReport = Data.define(:files, :findings, :counts, :exit_status)
+end

data/lib/scully/render/report.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Scully
+  module Render
+    # Renders a RunReport as the plain-text report printed by `scully [PATH ...]`.
+    class Report
+      GROUPS = { error: 'errors', warning: 'warnings' }.freeze
+      EVIDENCE = 'evidence: static analysis only; coverage and mutation testing not run'
+      FOLLOW_UP = 'Use `scully why <location>` for more info about each finding:'
+      COMMENT_GAP = '   '
+
+      # +messages+ maps rule ids to their header messages; +sources+ maps paths to objects
+      # that respond to line(number); +terminal+ adds colour when it is on.
+      def self.render(report, messages:, sources:, terminal: Terminal::PLAIN)
+        new(report, messages, sources, terminal).render
+      end
+
+      # One `scully why <path>:<line>   # <rule_id>` line per finding, commands padded to the longest.
+      def self.commands(findings)
+        commands = findings.map do
+          span = it.primary.span
+          ["scully why #{span.path}:#{span.start_line}", it.rule_id]
+        end
+        width = commands.map { it.first.size }.max
+        commands.map { |command, rule_id| "#{command.ljust(width)}#{COMMENT_GAP}# #{rule_id}" }
+      end
+
+      # `skipped: <path>: <reason>` for a skipped FileReport, ending in a newline.
+      def self.skip_line(file) = "skipped: #{file.path}: #{file.skip_reason}\n"
+
+      def initialize(report, messages, sources, terminal)
+        @report = report
+        @terminal = terminal
+        @messages = messages
+        @sources = sources
+      end
+
+      def render
+        sections = [*finding_groups, skipped_group].compact
+        text = sections.map { "#{it}\n" }.join
+        text << summary << "\n" << EVIDENCE << "\n"
+        text << follow_up unless @report.findings.empty?
+        text
+      end
+
+      private
+
+      def finding_groups
+        GROUPS.filter_map do |severity, title|
+          findings = @report.findings.select { it.severity == severity }
+          next if findings.empty?
+
+          "#{title} (#{findings.size})\n\n#{findings.map { block(it) }.join("\n")}"
+        end
+      end
+
+      def block(finding)
+        Snippet.render(finding, message: @messages.fetch(finding.rule_id),
+                                source: @sources.fetch(finding.primary.span.path), terminal: @terminal)
+      end
+
+      def skipped_group
+        skipped = @report.files.select { it.status == :skipped }
+        return if skipped.empty?
+
+        "skipped (#{skipped.size})\n\n#{skipped.map { self.class.skip_line(it) }.join}"
+      end
+
+      def summary
+        counts = @report.counts
+        not_analyzed = counts[:not_analyzed].zero? ? '' : " (#{counts[:not_analyzed]} not analyzed)"
+        "summary: #{counts[:files]} files (#{counts[:incomplete]} incomplete, #{counts[:skipped]} skipped), " \
+          "#{counts[:tests]} tests#{not_analyzed}, #{counts[:errors]} errors, #{counts[:warnings]} warnings"
+      end
+
+      def follow_up = "\n#{FOLLOW_UP}\n\n#{self.class.commands(@report.findings).map { "#{it}\n" }.join}"
+    end
+  end
+end

data/lib/scully/render/snippet.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Scully
+  module Render
+    # Renders a finding as a block: header, location, and the source lines its labels point at.
+    #
+    #   error[tautology]: assertion checks a value the test stubbed
+    #    --> spec/tautology_spec.rb:7:5
+    #     |
+    #   2 |   let(:tax) { double(rate: 0.2) }
+    #     |               ----------------- stubbed in setup to return `0.2`
+    #   ...
+    #   7 |     expect(tax.rate).to eq(0.2)
+    #     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ compares the stub with its own return value
+    class Snippet
+      TAB = '    '
+      PRIMARY = '^'
+      SECONDARY = '-'
+      INCONCLUSIVE = ' (incomplete file: inconclusive)'
+
+      # +source+ responds to line(number) and returns the line's text without its terminator.
+      # +terminal+ colours the severity word and markers when colour is on.
+      # Returns the block as a String ending in a newline.
+      def self.render(finding, message:, source:, terminal: Terminal::PLAIN)
+        new(finding, source, terminal).render(message)
+      end
+
+      def initialize(finding, source, terminal)
+        @finding = finding
+        @terminal = terminal
+        @source = source
+        @labels = [[finding.primary, PRIMARY, finding.severity], *finding.secondary.map { [it, SECONDARY, :secondary] }]
+        @numbers = @labels.map { it.first.span.start_line }.uniq.sort
+        @gutter = ' ' * @numbers.max.to_s.size
+      end
+
+      def render(message)
+        lines = [header(message), location, "#{@gutter} |", *body]
+        "#{lines.map(&:rstrip).join("\n")}\n"
+      end
+
+      private
+
+      def header(message) = "#{@terminal.paint(@finding.severity, @finding.severity)}[#{@finding.rule_id}]: #{message}"
+
+      def location
+        span = @finding.primary.span
+        suffix = INCONCLUSIVE if @finding.evidence == :inconclusive
+        "#{@gutter}--> #{span.path}:#{span.start_line}:#{span.start_column}#{suffix}"
+      end
+
+      def body
+        @numbers.each_with_index.flat_map do |number, index|
+          [*(index.positive? ? gap(@numbers[index - 1], number) : []), numbered(number), *markers(number)]
+        end
+      end
+
+      # One skipped line is shown as source; more than one collapses to `...`.
+      def gap(previous, number)
+        case number - previous - 1
+        when 0 then []
+        when 1 then [numbered(previous + 1)]
+        else ['...']
+        end
+      end
+
+      def numbered(number) = "#{number.to_s.rjust(@gutter.size)} | #{expand(@source.line(number))}"
+
+      def markers(number)
+        @labels.select { it.first.span.start_line == number }
+               .sort_by { |label, *| label.span.start_column }
+               .map { |label, marker, style| marker_line(label, marker, style) }
+      end
+
+      def marker_line(label, marker, style)
+        start, width = columns(label.span)
+        "#{@gutter} | #{" " * start}#{@terminal.paint(marker * width, style)} #{label.text}"
+      end
+
+      # Display start and marker width. Multi-line spans run to the end of their first line;
+      # zero-length spans get one marker.
+      def columns(span)
+        text = @source.line(span.start_line)
+        start = expand(text[0, span.start_column - 1]).size
+        finish = expand(span.end_line > span.start_line ? text : text[0, span.end_column - 1]).size
+        [start, [finish - start, 1].max]
+      end
+
+      def expand(text) = text.to_s.gsub("\t", TAB)
+    end
+  end
+end