simplecov 0.22.0 → 1.0.2

data/lib/simplecov/cli/report.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+
+module SimpleCov
+  module CLI
+    # `simplecov report [--input PATH]` — pretty-print the overall
+    # totals row plus per-group totals from a JSONFormatter
+    # coverage.json. Same numbers as the HTML report's totals row, for
+    # contexts where opening a browser isn't an option (CI logs, ssh
+    # sessions, terminal-only workflows).
+    module Report
+      SECTIONS = [%w[Line lines], %w[Branch branches], %w[Method methods]].freeze
+
+    module_function
+
+      def run(args, stdout:, stderr:)
+        opts = parse(args)
+        return 1 unless (data = load_data(opts[:input], stderr))
+
+        if opts[:json]
+          emit_json(stdout, data)
+        else
+          emit_text(stdout, data, SimpleCov::CLI.color_enabled?(opts, stdout))
+        end
+        0
+      end
+
+      def parse(args)
+        opts = {input: SimpleCov::CLI.default_input, json: false, no_color: false}
+        OptionParser.new do |o|
+          o.on("--input PATH") { |v| opts[:input] = v }
+          o.on("--json")       { opts[:json] = true }
+          o.on("--no-color")   { opts[:no_color] = true }
+        end.parse(args)
+        opts
+      end
+
+      def load_data(input, stderr)
+        return JSON.parse(File.read(input)) if File.exist?(input)
+
+        stderr.puts("simplecov report: #{input} not found")
+        nil
+      end
+
+      def emit_text(stdout, data, color)
+        none = {} #: Hash[String, untyped]
+        emit_totals(stdout, "All Files", data.fetch("total", none), color)
+        data.fetch("groups", none).each { |name, group| emit_totals(stdout, name, group, color) }
+      end
+
+      def emit_totals(stdout, label, totals, color)
+        stdout.puts(label)
+        SECTIONS.each { |display, key| emit_section(stdout, display, totals[key], color) }
+        stdout.puts
+      end
+
+      def emit_section(stdout, display, section, color)
+        return unless section.is_a?(Hash) && section["total"].to_i.positive?
+
+        stdout.puts(format("  %<label>-7s %<pct>s (%<covered>d / %<total>d)",
+                           label: "#{display}:",
+                           pct: SimpleCov::Color.colorize_percent(section["percent"].to_f, enabled: color),
+                           covered: section["covered"] || 0,
+                           total: section["total"] || 0))
+      end
+
+      def emit_json(stdout, data)
+        none = {} #: Hash[String, untyped]
+        payload = {"All Files" => collect_section(data.fetch("total", none))}
+        data.fetch("groups", none).each { |name, group| payload[name] = collect_section(group) }
+        stdout.puts(JSON.pretty_generate(payload))
+      end
+
+      def collect_section(totals)
+        sections = {} #: Hash[String, untyped]
+        SECTIONS.each_with_object(sections) do |(_, key), out|
+          section = totals[key]
+          next unless section.is_a?(Hash) && section["total"].to_i.positive?
+
+          out[key.to_s] = {
+            "percent" => section["percent"], "covered" => section["covered"], "total" => section["total"]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/cli/run.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module CLI
+    # `simplecov run <command...>` — exec the given command with
+    # simplecov auto-loaded so a coverage report drops into the
+    # project's coverage/ directory at the end. Useful for projects
+    # without a test_helper that already calls SimpleCov.start (e.g.
+    # plain `bundle exec rake test` on an unconfigured library).
+    module Run
+      AUTOSTART = File.expand_path("../autostart", __dir__.to_s)
+
+    module_function
+
+      def run(args, stderr:, **)
+        cmd = args.first == "--" ? args.drop(1) : args
+        if cmd.empty?
+          stderr.puts("simplecov run: missing command")
+          return 1
+        end
+
+        Kernel.exec(rubyopt_env, *cmd)
+      rescue Errno::ENOENT => e
+        stderr.puts("simplecov run: #{e.message}")
+        127
+      end
+
+      def rubyopt_env
+        existing = ENV["RUBYOPT"].to_s.strip
+        injection = "-r#{AUTOSTART}"
+        merged = existing.empty? ? injection : "#{existing} #{injection}"
+        ENV.to_hash.merge("RUBYOPT" => merged)
+      end
+    end
+  end
+end

data/lib/simplecov/cli/serve.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module SimpleCov
+  module CLI
+    # `simplecov serve [--port N] [--host HOST]` — serve the coverage
+    # report over HTTP. A 30-line static file server backed by stdlib
+    # `socket`, so there's no extra dependency just for "view a local
+    # report on a CI box where `file://` doesn't work."
+    module Serve
+      MIME = {
+        ".html" => "text/html; charset=utf-8",
+        ".htm" => "text/html; charset=utf-8",
+        ".css" => "text/css",
+        ".js" => "application/javascript",
+        ".json" => "application/json",
+        ".svg" => "image/svg+xml",
+        ".png" => "image/png",
+        ".gif" => "image/gif",
+        ".jpg" => "image/jpeg",
+        ".jpeg" => "image/jpeg",
+        ".ico" => "image/x-icon",
+        ".txt" => "text/plain; charset=utf-8"
+      }.freeze
+      STATUS_TEXT = {
+        200 => "OK", 400 => "Bad Request", 403 => "Forbidden",
+        404 => "Not Found", 405 => "Method Not Allowed"
+      }.freeze
+
+    module_function
+
+      def run(args, stdout:, stderr:, **)
+        opts = parse(args)
+        dir = SimpleCov::CLI.coverage_dir
+        return error(stderr, "#{dir} doesn't exist; run your test suite first") unless File.directory?(dir)
+
+        require "socket"
+        with_server(opts) do |server|
+          announce(stdout, server, dir)
+          serve_loop(server, dir, stdout)
+          0
+        end
+      end
+
+      def with_server(opts)
+        # The receiver cast works around an rbs stdlib gap: TCPSocket's
+        # explicit `self.new` shadows TCPServer#initialize's (host, port) form.
+        server = (_ = TCPServer).new(opts[:host], opts[:port]) #: TCPServer
+        begin
+          yield server
+        ensure
+          server.close
+        end
+      end
+
+      def parse(args)
+        opts = {port: 0, host: "127.0.0.1"} #: Hash[Symbol, untyped]
+        OptionParser.new do |o|
+          o.on("--port N", Integer) { |v| opts[:port] = v }
+          o.on("--host HOST")       { |v| opts[:host] = v }
+        end.parse(args)
+        opts
+      end
+
+      def announce(stdout, server, dir)
+        port = server.addr[1]
+        host = server.addr[3]
+        stdout.puts("simplecov serve: serving #{dir} at http://#{host}:#{port}/")
+        stdout.puts("Press Ctrl-C to stop.")
+      end
+
+      def serve_loop(server, dir, stdout)
+        loop { handle_connection(server.accept, dir) }
+      rescue Interrupt
+        stdout.puts("\nsimplecov serve: stopping")
+      end
+
+      # Reads one HTTP request line, drains headers, serves the file or
+      # writes a status response. Wide rescue so a misbehaving client
+      # can't crash the server.
+      def handle_connection(client, root)
+        method, path = client.readline.split
+        drain_headers(client)
+        return respond(client, 405) unless method == "GET"
+
+        file = resolve(path, root)
+        return respond(client, file == :forbidden ? 403 : 404) unless file.is_a?(String)
+
+        respond(client, 200, File.binread(file), MIME[File.extname(file).downcase])
+      rescue StandardError
+        # Misbehaving clients (truncated requests, connection resets,
+        # invalid encoding) shouldn't take the whole server down.
+        nil
+      ensure
+        # simplecov:disable — `client` is the parameter, never nil here;
+        # the `&.` is purely defensive in case of future refactors
+        client&.close
+        # simplecov:enable
+      end
+
+      def drain_headers(client)
+        loop { break if client.readline.strip.empty? }
+      end
+
+      # Returns the absolute path of the file to serve, :forbidden for
+      # a traversal attempt (including symlinks that escape root), or
+      # nil for "not found".
+      def resolve(request_path, root)
+        path = request_path.split("?", 2).first.to_s.sub(%r{^/}, "")
+        absolute_root = File.realpath(root)
+        candidate = File.expand_path(path.empty? ? "index.html" : path, absolute_root)
+        # Reject `..` traversal and absolute-path attempts before
+        # touching disk so they're 403, not 404.
+        return :forbidden unless inside?(candidate, absolute_root)
+
+        candidate = File.join(candidate, "index.html") if File.directory?(candidate)
+        return nil unless File.file?(candidate)
+
+        # Resolve symlinks last and re-check: a file inside root could
+        # be a symlink pointing outside (e.g. /etc/passwd).
+        real = File.realpath(candidate)
+        inside?(real, absolute_root) ? real : :forbidden
+      rescue Errno::ENOENT
+        # simplecov:disable — TOCTOU: candidate vanished between
+        # File.file? and File.realpath. Treat as "not found".
+        nil
+        # simplecov:enable
+      end
+
+      def inside?(path, root)
+        path == root || path.start_with?(root + File::SEPARATOR)
+      end
+
+      def respond(client, status, body = "", content_type = "text/plain")
+        client.write("HTTP/1.1 #{status} #{STATUS_TEXT[status] || 'Error'}\r\n",
+                     "Content-Type: #{content_type || 'application/octet-stream'}\r\n",
+                     "Content-Length: #{body.bytesize}\r\n",
+                     "Connection: close\r\n\r\n")
+        client.write(body)
+      end
+
+      def error(stderr, message)
+        stderr.puts("simplecov serve: #{message}")
+        1
+      end
+    end
+  end
+end

data/lib/simplecov/cli/uncovered.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require_relative "report"
+
+module SimpleCov
+  module CLI
+    # `simplecov uncovered [--threshold N] [--top N] [--criterion C]` — list
+    # the lowest-coverage files (by the chosen criterion, ascending), so a
+    # developer can answer "where should I add tests next?" without
+    # opening a browser. Reads coverage.json directly.
+    module Uncovered
+      DEFAULT_TOP = 10
+
+      # The coverage.json fields backing each criterion.
+      CRITERION_KEYS = {
+        line: {percent: "lines_covered_percent", covered: "covered_lines", total: "total_lines"},
+        branch: {percent: "branches_covered_percent", covered: "covered_branches", total: "total_branches"},
+        method: {percent: "methods_covered_percent", covered: "covered_methods", total: "total_methods"}
+      }.freeze
+
+    module_function
+
+      def run(args, stdout:, stderr:, **)
+        opts = parse(args)
+        keys = CRITERION_KEYS[opts[:criterion]]
+        return unknown_criterion(opts[:criterion], stderr) unless keys
+
+        report(opts, keys, stdout, stderr)
+      end
+
+      def report(opts, keys, stdout, stderr)
+        return 1 unless (data = Report.load_data(opts[:input], stderr))
+
+        none = {} #: Hash[String, untyped]
+        files = rank(data.fetch("coverage", none), opts[:threshold], keys).first(opts[:top])
+        return stdout.puts(empty_message(opts[:json])) || 0 if files.empty?
+
+        emit(stdout, files, opts)
+        0
+      end
+
+      def unknown_criterion(criterion, stderr)
+        stderr.puts("simplecov uncovered: unknown --criterion #{criterion.inspect} (expected line, branch, or method)")
+        1
+      end
+
+      def emit(stdout, files, opts)
+        opts[:json] ? emit_json(stdout, files) : emit_text(stdout, files, SimpleCov::CLI.color_enabled?(opts, stdout))
+      end
+
+      def parse(args)
+        opts = {input: SimpleCov::CLI.default_input, threshold: 100.0, top: DEFAULT_TOP, criterion: :line, no_color: false}
+        build_parser(opts).parse(args)
+        opts
+      end
+
+      # Option parsing with per-flag coercions is inherently ABC-heavy; the
+      # metric is noise here.
+      def build_parser(opts) # rubocop:disable Metrics/AbcSize
+        OptionParser.new do |o|
+          o.on("--input PATH")         { |v| opts[:input] = v }
+          o.on("--threshold N", Float) { |v| opts[:threshold] = v }
+          o.on("--top N", Integer)     { |v| opts[:top] = v }
+          o.on("--criterion C")        { |v| opts[:criterion] = v.to_sym }
+          o.on("--json")               { opts[:json] = true }
+          o.on("--no-color")           { opts[:no_color] = true }
+        end
+      end
+
+      def emit_text(stdout, files, color)
+        files.each { |fname, pct, covered, total| stdout.puts(format_row(fname, pct, covered, total, color)) }
+      end
+
+      def emit_json(stdout, files)
+        rows = files.map do |fname, pct, covered, total|
+          {"file" => fname, "percent" => pct, "covered" => covered, "total" => total}
+        end
+        stdout.puts(JSON.pretty_generate(rows))
+      end
+
+      def empty_message(json)
+        json ? "[]" : "simplecov uncovered: nothing to report"
+      end
+
+      def rank(coverage_hash, threshold, keys)
+        rows = coverage_hash.filter_map { |fname, payload| row_for(fname, payload, threshold, keys) }
+        rows.sort_by { |_fname, pct, _c, _t| pct }
+      end
+
+      def row_for(fname, payload, threshold, keys)
+        return unless payload.is_a?(Hash) && payload[keys[:total]].to_i.positive?
+
+        pct = payload[keys[:percent]].to_f
+        return if pct >= threshold
+
+        [fname, pct, payload[keys[:covered]].to_i, payload[keys[:total]].to_i]
+      end
+
+      def format_row(fname, pct, covered, total, color)
+        format("%<pct>s  %<covered>d/%<total>d  %<fname>s",
+               pct: SimpleCov::Color.colorize_percent(pct, format("%6.2f%%", pct), enabled: color),
+               covered: covered, total: total, fname: fname)
+      end
+    end
+  end
+end

data/lib/simplecov/cli.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative "color"
+require_relative "cli/dotfile"
+require_relative "cli/clean"
+require_relative "cli/coverage"
+require_relative "cli/diff"
+require_relative "cli/merge"
+require_relative "cli/open"
+require_relative "cli/report"
+require_relative "cli/run"
+require_relative "cli/serve"
+require_relative "cli/uncovered"
+
+module SimpleCov
+  # Lightweight command-line front-end. `run` dispatches a subcommand
+  # (`coverage`, `report`, `uncovered`, `merge`, `diff`, `open`, etc.) —
+  # see the `usage` text below for the full list, or run `simplecov help`.
+  #
+  # Read-only subcommands consume JSONFormatter output (`coverage.json`),
+  # which the bundled HTMLFormatter already drops alongside the HTML, so
+  # no runtime hooking is needed for those. Default paths follow the
+  # project's `.simplecov` `SimpleCov.coverage_dir` setting when one is
+  # present, so a project that writes its report somewhere other than
+  # `coverage/` doesn't have to pass `--input` / `--report` every
+  # invocation.
+  module CLI
+    COMMANDS = {
+      "coverage" => Coverage,
+      "run" => Run,
+      "open" => Open,
+      "report" => Report,
+      "uncovered" => Uncovered,
+      "merge" => Merge,
+      "diff" => Diff,
+      "serve" => Serve,
+      "clean" => Clean
+    }.freeze
+
+  module_function
+
+    # Resolved once per process. Walks up from cwd looking for a
+    # `.simplecov`; if present, the file is loaded with
+    # `SimpleCov.start` neutered so it can't trigger coverage tracking
+    # or an at_exit hook just because we asked it for a config value.
+    def coverage_dir
+      @coverage_dir ||= Dotfile.coverage_dir
+    end
+
+    def default_input
+      File.join(coverage_dir, "coverage.json")
+    end
+
+    # Resolve "should this subcommand colorize?" once per invocation.
+    # `--no-color` (opts[:no_color]) is the per-invocation kill-switch;
+    # otherwise we defer to `SimpleCov::Color.enabled?`, which honors
+    # `NO_COLOR` / `FORCE_COLOR` and falls back to `stream.tty?`.
+    def color_enabled?(opts, stream)
+      return false if opts[:no_color]
+
+      SimpleCov::Color.enabled?(stream)
+    end
+
+    def default_report
+      File.join(coverage_dir, "index.html")
+    end
+
+    def default_resultset
+      File.join(coverage_dir, ".resultset.json")
+    end
+
+    # Returns a process exit status (0 on success, non-zero on error).
+    def run(argv, stdout: $stdout, stderr: $stderr)
+      command, *rest = argv
+      handler = COMMANDS[command]
+      return handler.run(rest, stdout: stdout, stderr: stderr) if handler
+      return stdout.puts(usage) || 0 if [nil, "help", "--help", "-h"].include?(command)
+
+      stderr.puts("simplecov: unknown command #{command.inspect}", usage)
+      1
+    end
+
+    def usage
+      <<~USAGE
+        Usage: simplecov <command> [options]
+
+        Commands:
+          run <command...>          Execute <command> with simplecov pre-loaded
+                                    (so a coverage report is generated even
+                                    when the project has no test_helper hook)
+          coverage <path>           Print coverage stats for the given file
+          report                    Print the overall summary and group totals
+          uncovered                 List the lowest-coverage files
+          merge <files...>          Merge multiple .resultset.json files
+          diff <baseline>           Show per-file coverage delta vs baseline
+          open                      Open the HTML report in the default browser
+          serve                     Serve the coverage report over HTTP
+          clean                     Remove the coverage report directory
+          help                      Show this message
+
+        Default paths follow SimpleCov.coverage_dir from a project's
+        `.simplecov` when one is present (#{coverage_dir} for this run).
+
+        coverage / report / uncovered / diff options:
+          --input PATH              Read from PATH instead of #{default_input}
+          --no-color                Disable colorized percentages
+                                    (also honors NO_COLOR / FORCE_COLOR env)
+
+        coverage options:
+          --json                    Print the file's JSON entry verbatim
+
+        report options:
+          --json                    Emit totals and group sections as JSON
+
+        uncovered options:
+          --threshold N             Only show files below N% coverage
+          --top N                   Show at most N files (default: 10)
+          --criterion C             line, branch, or method (default: line)
+          --json                    Emit results as a JSON array (for CI)
+
+        merge options:
+          --output PATH             Write merged resultset to PATH
+                                    (default: #{default_resultset})
+          --honor-timeout           Drop entries older than merge_timeout
+          --dry-run                 Print what would be written without
+                                    actually writing
+          -q, --quiet               Suppress the success status line
+
+        diff options:
+          --fail-on-drop            Exit non-zero when any file's coverage
+                                    dropped vs the baseline
+          --json                    Emit results as a JSON array (for CI)
+          --threshold N             Only show files whose absolute delta
+                                    in any criterion is at least N%
+
+        open options:
+          --report PATH             Open PATH instead of #{default_report}
+
+        serve options:
+          --port N                  Bind to port N (default: random open port)
+          --host HOST               Bind to HOST (default: 127.0.0.1)
+
+        clean options:
+          --dry-run                 Print what would be removed without
+                                    deleting anything
+          -q, --quiet               Suppress status lines
+      USAGE
+    end
+  end
+end

data/lib/simplecov/color.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # ANSI colorization for stderr diagnostics. Thresholds mirror the
+  # HTML formatter (>= 90 green, >= 75 yellow, otherwise red) so a
+  # team's mental model of "what's the cutoff" is the same whether
+  # they're reading the terminal output or the HTML report.
+  #
+  # Color precedence, highest first:
+  #
+  # - `SimpleCov.color = true` / `false` (programmatic override, wins
+  #   over everything; default is `:auto` which falls through)
+  # - `NO_COLOR` env var (any non-empty value) → off (see no-color.org)
+  # - `FORCE_COLOR` env var (any non-empty value) → on
+  # - `stream.tty?` fallback
+  #
+  # `NO_COLOR` wins over `FORCE_COLOR` if both env vars are set.
+  module Color
+    GREEN_THRESHOLD  = 90
+    YELLOW_THRESHOLD = 75
+
+    ANSI = {
+      red: "\e[31m",
+      yellow: "\e[33m",
+      green: "\e[32m",
+      reset: "\e[0m"
+    }.freeze
+
+  module_function
+
+    # `stream` is the IO that the colorized text is destined for. The
+    # formatter writes to stderr, so that's the default. CLI subcommands
+    # that print to stdout should pass `$stdout` so a redirected pipe
+    # doesn't get ANSI sequences. See the module-level comment for
+    # precedence.
+    def enabled?(stream = $stderr)
+      # `SimpleCov.color` only exists once the full library is loaded.
+      # The standalone CLI (`exe/simplecov`) loads `simplecov/color`
+      # without `simplecov` itself to stay lightweight, so treat a
+      # missing config the same as its `:auto` default: fall through to
+      # the env vars and tty check below.
+      config = SimpleCov.color if SimpleCov.respond_to?(:color)
+      return config if [true, false].include?(config)
+      return false if env_set?("NO_COLOR")
+      return true  if env_set?("FORCE_COLOR")
+
+      stream.tty?
+    end
+
+    def for_percent(percent)
+      return :green  if percent >= GREEN_THRESHOLD
+      return :yellow if percent >= YELLOW_THRESHOLD
+
+      :red
+    end
+
+    # Wrap `text` in the ANSI sequence for `color` (a key of ANSI).
+    # Returns the bare text if color is disabled. The `enabled:`
+    # keyword lets callers (e.g., CLI subcommands honoring `--no-color`)
+    # override the auto-detection without touching env vars.
+    def colorize(text, color, enabled: enabled?)
+      return text unless enabled
+
+      "#{ANSI.fetch(color)}#{text}#{ANSI.fetch(:reset)}"
+    end
+
+    # Render `percent` as a fixed "NN.NN%" string colored by which
+    # threshold band it falls into. Callers that want a different
+    # rendering of the number can pass the pre-rendered `text`.
+    def colorize_percent(percent, text = nil, enabled: enabled?)
+      colorize(text || format("%.2f%%", percent), for_percent(percent), enabled: enabled)
+    end
+
+    def env_set?(name)
+      value = ENV.fetch(name, nil)
+      value && !value.empty?
+    end
+  end
+end

data/lib/simplecov/combine/branches_combiner.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../source_file/ruby_data_parser"
+
 module SimpleCov
   module Combine
     #
@@ -10,22 +12,43 @@ module SimpleCov
     module_function
 
       #
-      # Return merged branches or the existed brach if other is missing.
+      # Return merged branches or the existed branch if other is missing.
       #
       # Branches inside files are always same if they exist, the difference only in coverage count.
       # Branch coverage report for any conditional case is built from hash, it's key is a condition and
       # it's body is a hash << keys from condition and value is coverage rate >>.
-      # ex: branches =>{ [:if, 3, 8, 6, 8, 36] => {[:then, 4, 8, 6, 8, 12] => 1, [:else, 5, 8, 6, 8, 36]=>2}, other conditions...}
+      # ex: branches => { [:if, 3, 8, 6, 8, 36] =>
+      #                     {[:then, 4, 8, 6, 8, 12] => 1, [:else, 5, 8, 6, 8, 36] => 2}, ... }
       # We create copy of result and update it values depending on the combined branches coverage values.
       #
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
-        coverage_a.merge(coverage_b) do |_condition, branches_inside_a, branches_inside_b|
-          branches_inside_a.merge(branches_inside_b) do |_branch, a_count, b_count|
-            a_count + b_count
+        merged = {} #: Hash[untyped, [untyped, Hash[untyped, untyped]]]
+        combined = [coverage_a, coverage_b].each_with_object(merged) do |coverage, memo|
+          coverage.each do |condition, branches_inside|
+            condition_key = tuple_identity(condition)
+            condition_tuple, merged_branches = memo[condition_key] ||= [condition, {}]
+            merge_branches(merged_branches, branches_inside)
+            memo[condition_key] = [condition_tuple, merged_branches]
           end
         end
+
+        combined.values.to_h { |condition, branches| [condition, branches.values.to_h] }
+      end
+
+      def merge_branches(target, source)
+        source.each do |branch, count|
+          branch_key = tuple_identity(branch)
+          branch_tuple, existing_count = target[branch_key]
+          target[branch_key] = [branch_tuple || branch, existing_count ? existing_count + count : count]
+        end
+      end
+
+      def tuple_identity(tuple)
+        tuple = SourceFile::RubyDataParser.call(tuple)
+        type, _id, start_line, start_column, end_line, end_column = tuple
+        [type, start_line, start_column, end_line, end_column]
       end
     end
   end