simplecov 1.0.2 → 1.1.0

data/lib/simplecov/cli/report.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "optparse"
+require_relative "command_helpers"
 
 module SimpleCov
   module CLI
@@ -11,12 +12,15 @@ module SimpleCov
     # contexts where opening a browser isn't an option (CI logs, ssh
     # sessions, terminal-only workflows).
     module Report
+      extend CommandHelpers
+
+      TOTAL_LABEL = "All Files"
       SECTIONS = [%w[Line lines], %w[Branch branches], %w[Method methods]].freeze
 
     module_function
 
       def run(args, stdout:, stderr:)
-        opts = parse(args)
+        opts, = parse_common(args)
         return 1 unless (data = load_data(opts[:input], stderr))
 
         if opts[:json]
@@ -27,27 +31,32 @@ module SimpleCov
         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
-
+      # Valid JSON isn't enough: a wrong-typed "total" or "groups" (or a
+      # wrong-typed group entry) used to escape here and crash the
+      # emitters with a backtrace instead of the one-line error the
+      # sibling commands print.
       def load_data(input, stderr)
-        return JSON.parse(File.read(input)) if File.exist?(input)
+        data = CoverageFile.load_document(input, command: "report", stderr: stderr)
+        return unless data
+
+        none = {} #: Hash[String, untyped]
+        unless data.fetch("total", none).is_a?(Hash)
+          return CoverageFile.report_invalid(stderr, "report", input, '"total" must be an object')
+        end
 
-        stderr.puts("simplecov report: #{input} not found")
-        nil
+        groups = data.fetch("groups", none)
+        return data if groups.is_a?(Hash) && groups.each_value.all?(Hash)
+
+        CoverageFile.report_invalid(stderr, "report", input, '"groups" must be an object of objects')
       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) }
+        emit_totals(stdout, TOTAL_LABEL, data.fetch("total", none), color)
+        data.fetch("groups", none).each do |name, group|
+          label = name == TOTAL_LABEL ? "#{name} (group)" : name
+          emit_totals(stdout, label, group, color)
+        end
       end
 
       def emit_totals(stdout, label, totals, color)
@@ -59,17 +68,16 @@ module SimpleCov
       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))
+        stdout.puts(stats_row(display,
+                              SimpleCov::Color.colorize_percent(section["percent"].to_f, enabled: color),
+                              section["covered"],
+                              section["total"]))
       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) }
+        groups = data.fetch("groups", none).transform_values { |group| collect_section(group) }
+        payload = {"total" => collect_section(data.fetch("total", none)), "groups" => groups}
         stdout.puts(JSON.pretty_generate(payload))
       end
 

data/lib/simplecov/cli/serve/report_preparer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../../coverage_json"
+
+module SimpleCov
+  module CLI
+    module Serve
+      # Ensures the coverage directory has a renderable entry point before
+      # the HTTP server binds. Existing self-contained reports take priority
+      # over their optional JSON sidecar.
+      module ReportPreparer
+        def self.call(dir)
+          index_path = File.join(dir, "index.html")
+          json_path = File.join(dir, "coverage.json")
+          return "#{dir} doesn't exist; run your test suite first" unless File.directory?(dir)
+          return if File.file?(index_path)
+
+          return "#{dir} has no index.html or coverage.json; run your test suite first" unless File.file?(json_path)
+
+          require_relative "../../formatter/html_formatter"
+          SimpleCov::Formatter::HTMLFormatter.new.format_from_json(json_path, dir)
+          nil
+        rescue SimpleCov::CoverageJSON::Error, SystemCallError => e
+          "cannot build index.html from #{json_path}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/cli/serve/static_file_handler.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module CLI
+    module Serve
+      # The HTTP mechanics behind `simplecov serve`: reads one request
+      # per connection and answers it from the report directory, with
+      # traversal-safe path resolution. Kept apart from the CLI wiring
+      # (option parsing, binding, the accept loop) in serve.rb.
+      module StaticFileHandler
+        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
+
+        # Seconds a connection may sit idle mid-request before its reads
+        # raise IO::TimeoutError and the connection is dropped.
+        READ_TIMEOUT = 5
+
+      module_function
+
+        # 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. The read timeout keeps idle connections
+        # from pinning their threads forever.
+        def handle_connection(client, root)
+          # simplecov:disable branch — support for IO#timeout= is fixed by the engine
+          # JRuby and TruffleRuby don't implement IO#timeout=. Without
+          # the guard the NoMethodError lands in the wide rescue below
+          # and every connection closes with an empty response. On those
+          # engines an idle connection pins its thread instead of timing
+          # out, which only leaks a thread in an interactive dev server.
+          client.timeout = READ_TIMEOUT if client.respond_to?(:timeout=)
+          # simplecov:enable branch
+          method, path = client.readline.split
+          drain_headers(client)
+          # A request line without both tokens used to raise on
+          # `path.split` inside the wide rescue, closing the connection
+          # with an empty response instead of the 400 defined below.
+          return respond(client, 400) if path.nil?
+          return respond(client, 405) unless method == "GET"
+
+          serve_file(client, path, root)
+        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 serve_file(client, path, root)
+          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])
+        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".
+        #
+        # The request path is deliberately NOT percent-decoded: filenames
+        # needing escapes don't occur in generated reports, and keeping
+        # `%2e%2e%2f` as literal bytes is part of the traversal defense.
+        # If decoding is ever added, it must happen BEFORE the `inside?`
+        # check below.
+        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
+      end
+    end
+  end
+end

data/lib/simplecov/cli/serve.rb

@@ -1,52 +1,46 @@
 # frozen_string_literal: true
 
 require "optparse"
+require_relative "command_helpers"
+require_relative "serve/report_preparer"
+require_relative "serve/static_file_handler"
 
 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
+    # report over HTTP. A small 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."
+    # report on a CI box where `file://` doesn't work." This module is
+    # the CLI wiring (options, binding, the accept loop); the HTTP
+    # mechanics live in StaticFileHandler.
     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
+      extend CommandHelpers
 
     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)
+        message = ReportPreparer.call(dir)
+        return error(stderr, message) if message
 
         require "socket"
-        with_server(opts) do |server|
+        with_server(opts, stderr) do |server|
           announce(stdout, server, dir)
           serve_loop(server, dir, stdout)
           0
         end
       end
 
-      def with_server(opts)
+      # Returns the block's exit status, or 1 when the socket can't be
+      # bound (port already taken, privileged port, unresolvable host).
+      def with_server(opts, stderr)
         # 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
+      rescue SystemCallError, SocketError => e
+        error(stderr, "cannot bind to #{opts[:host]}:#{opts[:port]} (#{e.message})")
+      else
         begin
           yield server
         ensure
@@ -65,85 +59,27 @@ module SimpleCov
 
       def announce(stdout, server, dir)
         port = server.addr[1]
-        host = server.addr[3]
+        host = url_host(server.addr[3])
         stdout.puts("simplecov serve: serving #{dir} at http://#{host}:#{port}/")
         stdout.puts("Press Ctrl-C to stop.")
       end
 
+      # IPv6 literals need brackets in a URL (--host ::1 must announce
+      # http://[::1]:PORT/, not the invalid http://::1:PORT/).
+      def url_host(host)
+        host.include?(":") ? "[#{host}]" : host
+      end
+
+      # One thread per connection: browsers open speculative sockets
+      # that send no bytes, and a serial loop would stall every real
+      # request (the report's assets included) behind them.
       def serve_loop(server, dir, stdout)
-        loop { handle_connection(server.accept, dir) }
+        loop do
+          Thread.new(server.accept) { |client| StaticFileHandler.handle_connection(client, dir) }
+        end
       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

@@ -2,7 +2,7 @@
 
 require "json"
 require "optparse"
-require_relative "report"
+require_relative "command_helpers"
 
 module SimpleCov
   module CLI
@@ -11,30 +11,25 @@ module SimpleCov
     # developer can answer "where should I add tests next?" without
     # opening a browser. Reads coverage.json directly.
     module Uncovered
-      DEFAULT_TOP = 10
+      extend CommandHelpers
 
-      # 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
+      DEFAULT_TOP = 10
 
     module_function
 
       def run(args, stdout:, stderr:, **)
         opts = parse(args)
-        keys = CRITERION_KEYS[opts[:criterion]]
+        keys = CoverageFile::CRITERIA[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))
+        coverage = CoverageFile.load_coverage(opts[:input], command: "uncovered", stderr: stderr)
+        return 1 unless coverage
 
-        none = {} #: Hash[String, untyped]
-        files = rank(data.fetch("coverage", none), opts[:threshold], keys).first(opts[:top])
+        files = rank(coverage, opts[:threshold], keys).first(opts[:top])
         return stdout.puts(empty_message(opts[:json])) || 0 if files.empty?
 
         emit(stdout, files, opts)
@@ -51,22 +46,22 @@ module SimpleCov
       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, = parse_common(args, threshold: 100.0, top: DEFAULT_TOP, criterion: :line) do |o, options|
+          o.on("--threshold N", Float) { |v| options[:threshold] = v }
+          o.on("--top N", Integer)     { |v| options[:top] = validate_top(v) }
+          o.on("--criterion C")        { |v| options[:criterion] = v.to_sym }
+        end
         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
+      # A negative count would raise from `Array#first`; report it as
+      # the parse error it is (`--top 0` is allowed and shows nothing).
+      # OptionParser prepends the offending option's name, so the raise
+      # carries only the reason.
+      def validate_top(value)
+        raise OptionParser::InvalidArgument, "must not be negative" if value.negative?
+
+        value
       end
 
       def emit_text(stdout, files, color)

data/lib/simplecov/cli.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "optparse"
 require_relative "color"
 require_relative "cli/dotfile"
 require_relative "cli/clean"
+require_relative "cli/coverage_file"
 require_relative "cli/coverage"
 require_relative "cli/diff"
 require_relative "cli/merge"
@@ -73,13 +75,23 @@ module SimpleCov
     def run(argv, stdout: $stdout, stderr: $stderr)
       command, *rest = argv
       handler = COMMANDS[command]
-      return handler.run(rest, stdout: stdout, stderr: stderr) if handler
+      return dispatch(handler, command, 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
 
+    # One rescue covers every subcommand's OptionParser, so a typo'd
+    # flag or a malformed typed argument becomes a one-line error and
+    # exit status 1 instead of an unhandled-exception backtrace.
+    def dispatch(handler, command, rest, stdout:, stderr:)
+      handler.run(rest, stdout: stdout, stderr: stderr)
+    rescue OptionParser::ParseError => e
+      stderr.puts("simplecov #{command}: #{e.message} (run `simplecov help` for usage)")
+      1
+    end
+
     def usage
       <<~USAGE
         Usage: simplecov <command> [options]
@@ -128,7 +140,8 @@ module SimpleCov
 
         diff options:
           --fail-on-drop            Exit non-zero when any file's coverage
-                                    dropped vs the baseline
+                                    dropped vs the baseline (deleted
+                                    files don't count as drops)
           --json                    Emit results as a JSON array (for CI)
           --threshold N             Only show files whose absolute delta
                                     in any criterion is at least N%

data/lib/simplecov/combine/branches_combiner.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 require_relative "../source_file/ruby_data_parser"
+require_relative "identity_interner"
+require_relative "interned_counts"
 
 module SimpleCov
   module Combine
     #
     # Combine different branch coverage results on single file.
     #
-    # Should be called through `SimpleCov.combine`.
+    # Should be called through `CoverageAccumulator`.
     module BranchesCombiner
     module_function
 
@@ -24,31 +26,53 @@ module SimpleCov
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
-        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
+        merged = absorb({}, coverage_a) #: Hash[untyped, [untyped, Hash[untyped, untyped]]]
+        materialize(absorb(merged, coverage_b))
+      end
+
+      # Folds `coverage` into `target`, an interned table keyed by condition
+      # identity. Kept interned (rather than turned back into tuple keys per
+      # merge) so a fold over N resultsets interns each condition once
+      # instead of re-interning the whole accumulated table N times.
+      #
+      # @return [Hash] `target`
+      def absorb(target, coverage)
+        return target unless coverage
+
+        coverage.each do |condition, branches_inside|
+          entry = target[identities[condition]] ||= new_condition(condition)
+          InternedCounts.absorb_counts(entry[1], branches_inside, identities)
         end
 
-        combined.values.to_h { |condition, branches| [condition, branches.values.to_h] }
+        target
       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
+      # Split out so the empty arm table has somewhere to carry its type
+      # annotation. Only allocated the first time a condition is seen.
+      def new_condition(condition)
+        arms = {} #: Hash[untyped, untyped]
+        [condition, arms]
+      end
+
+      # Turns an interned table back into the tuple-keyed hash the rest of
+      # SimpleCov reads. Done once, at the end of a fold.
+      #
+      # @return [Hash]
+      def materialize(target)
+        target.values.to_h { |condition, branches| [condition, branches.values.to_h] }
+      end
+
+      # Bounded by the project's branch count, like `RubyDataParser`'s parse
+      # cache.
+      def identities
+        @identities ||= IdentityInterner.build { |tuple| tuple_identity(tuple) }
       end
 
+      # Branches match on source span, whatever ids the recording processes
+      # handed them (issue #1233).
       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]
+        type, _id, start_line, start_column, end_line, end_column = SourceFile::RubyDataParser.call(tuple)
+        [type, start_line, start_column, end_line, end_column].freeze
       end
     end
   end