this_is_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0a2047298c7f0c4729968ed6827707200b80ad5810ccde2c5fcd6fb009d4b662
+  data.tar.gz: 541e8c560fdb8441a4aa4ec0f040827a10454feb8bd467cad44840a614a05455
+SHA512:
+  metadata.gz: f09cc8394377d79592a9e8e845a6da04c1dd4fcfa113ebebcf0460af1d8cc3b8c240f8e944048b9a471790d926e1d49123533546aaa093b111598255173de0f4
+  data.tar.gz: f4eeae23cde25381e1fd4132f6904e7c4f5a07a1980a8e7855e115d5532ad8c84fb6b25af916264b786e2ec64f2e93f1679597edddfe70c7c7251aea287f35c2

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## 0.1.0
+
+Initial release.
+
+- Recognises generated error pages, bundler and asset-pipeline output,
+  Webpacker and Vite builds, SimpleCov reports, SQL structure dumps and
+  shadcn/ui components.
+- Writes a managed block in `.gitattributes`, leaving the rest of the file
+  untouched, and stays quiet about anything already declared there.
+- `plan`, `apply` and `check` commands; `--all-frontend` opt-in.
+
+## Unreleased
+
+- Exit 1 on an unknown command or option instead of 0, so a typo in a CI step
+  fails rather than silently skipping `check`.
+- Leave a path alone when its Linguist attribute is already decided, including
+  when it was explicitly unset (`-linguist-generated`) or made unspecified
+  (`!linguist-generated`). Writing our line after such a declaration reversed
+  it, because the last match wins.
+- Rewrite the managed block where it already sits, so content below it stays
+  below it.
+- Read `git rev-parse` from stdout alone: with `GIT_TRACE` set, or on any git
+  warning, the merged stream became part of the repository root.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Evil Martians
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# this_is_ruby
+
+GitHub decides a repository's language by counting bytes. Ruby code can often be outnumbered by sheer volume of JS/TS/HTML boilerplate. So GitHub labels the repo HTML or TypeScript.
+
+This gem gives you controls.
+
+## Install
+
+```ruby
+group :development do
+  gem "this_is_ruby", require: false
+end
+```
+
+## Use
+
+```console
+$ this_is_ruby          # write the managed block into .gitattributes
+$ this_is_ruby plan     # show what that would write, change nothing
+$ this_is_ruby check    # exit 1 when .gitattributes is out of date
+```
+
+`check` belongs in CI
+
+## What it recognises
+
+| | attribute |
+|---|---|
+| error pages from `rails new`, verified by the comment naming their own path | `linguist-generated` |
+| `app/assets/builds/` from jsbundling, cssbundling, dartsass, tailwindcss-rails | `linguist-generated` |
+| `public/assets/` precompiled asset pipeline output | `linguist-generated` |
+| `public/packs/`, `public/packs-test/` from Webpacker and Shakapacker | `linguist-generated` |
+| `public/vite*/` from vite_rails | `linguist-generated` |
+| SimpleCov HTML reports, found by the report's own title | `linguist-generated` |
+| `db/structure.sql`, matching how Rails already treats `db/schema.rb` | `linguist-generated` |
+| shadcn/ui components, when `components.json` shows a generator put them there | `linguist-vendored` |
+
+
+By default the gem only points at files a tool produced. On [inertia-rails/react-starter-kit][irsk], where GitHub counts TypeScript at 60.6%, that clears the HTML but leaves TypeScript the primary language.
+
+## Make it Ruby
+
+If you think that despite a huge amount of hand-written JS/TS/HTML, the important work in your repository is Ruby, you can say so:
+
+```console
+$ this_is_ruby --all-frontend
+```
+On the same repository that marks `app/javascript/` as `linguist-vendored`, and
+GitHub then counts it as **82.6% Ruby, 1.1% TypeScript**. That is not an
+estimate: [irinanazarova/react-starter-kit-this-is-ruby][demo] is a fork of the
+kit whose only change is the sixteen lines this command wrote. Compare its
+language bar with [the upstream one][irsk].
+
+The one line that matters is which attribute it uses. [Generated files are suppressed in diffs][docs]; vendored files are not. So `--all-frontend` emits `linguist-vendored`, every source file keeps showing up in full in pull requests, and the only thing that changes is the color of the bar at the top of the page:
+
+```console
+$ git check-attr linguist-vendored linguist-generated -- app/javascript/pages/home/index.tsx
+app/javascript/pages/home/index.tsx: linguist-vendored: set
+app/javascript/pages/home/index.tsx: linguist-generated: unspecified
+```
+
+## Side effects
+
+`linguist-*` attributes are a GitHub convention, and plain git does not act on
+them. Your local `git diff`, your merges, your CI and every checkout stay
+byte-for-byte what they were. Away from GitHub's own pages, nothing changes.
+
+On GitHub itself:
+
+- **`linguist-generated` collapses the file in diffs.** Linguist's docs put it
+  plainly: these files "are suppressed in diffs". Reviewers get a "Load diff"
+  button instead of the patch. The gem uses this attribute only for tool
+  output; everything hand-written gets `linguist-vendored`, which leaves diffs
+  alone. That is why `--all-frontend` vendors your frontend rather than
+  marking it generated.
+- **Code search still indexes the files.** They stay findable, and GitHub adds
+  `is:generated` and `is:vendored` filters, so a query written as
+  `-is:vendored` will skip them.
+- **Syntax highlighting is untouched.** Highlighting follows
+  `linguist-language=`, which this gem never writes.
+
+Nothing is deleted, moved or rewritten. The files stay in the repository and
+in its history, and GitHub only reads `.gitattributes` once you commit it.
+
+## A note on patterns
+
+Directory rules emit `dir/**`, never `dir/*`. In gitignore syntax, which `.gitattributes` shares, a single star does not cross a slash, so `vendor/*` reaches `vendor/turbo.js` and never `vendor/javascript/turbo.js`. There is a spec that asks `git check-attr` rather than trusting the documentation.
+
+## License
+
+MIT.
+
+[irsk]: https://github.com/inertia-rails/react-starter-kit
+[docs]: https://github.com/github-linguist/linguist/blob/main/docs/overrides.md
+[demo]: https://github.com/irinanazarova/react-starter-kit-this-is-ruby

data/exe/this_is_ruby

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "this_is_ruby"
+
+exit ThisIsRuby::CLI.call(ARGV)

data/lib/this_is_ruby/attributes_file.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ThisIsRuby
+  # Reads and rewrites .gitattributes, touching only the block it owns.
+  #
+  # Everything outside the markers is preserved: Rails writes its own lines
+  # there, and so do people. The block is rewritten where it already sits, so
+  # what someone put below it stays below it.
+  class AttributesFile
+    BEGIN_MARKER = "# --- this_is_ruby: begin ---"
+    END_MARKER = "# --- this_is_ruby: end ---"
+    BLOCK = /^#{Regexp.escape(BEGIN_MARKER)}\n.*?^#{Regexp.escape(END_MARKER)}\n?/m
+
+    PREAMBLE = [
+      "# Managed by this_is_ruby. Re-run it when your build setup changes.",
+      "# Every path below is excluded from this repository's language stats.",
+      "# Edit above or below this block, never inside it."
+    ].freeze
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = Pathname.new(path)
+    end
+
+    def current = path.file? ? path.read : ""
+
+    # Patterns already declared outside our block, as pattern => attributes.
+    #
+    # Attributes keep their `-` or `!` prefix: an owner who wrote
+    # `public/404.html -linguist-generated` has spoken about that path just as
+    # deliberately as one who set it, and Plan reads both as "leave it alone".
+    def existing_attributes
+      before, after = split
+      "#{before}#{after}".each_line.with_object({}) do |line, declared|
+        body = line.split("#", 2).first.to_s.strip
+        next if body.empty?
+
+        pattern, *attributes = body.split(/\s+/)
+        (declared[pattern] ||= []).concat(attributes)
+      end
+    end
+
+    def render(emissions)
+      before, after = split
+      join(before, emissions.empty? ? nil : block(emissions), after)
+    end
+
+    def stale?(emissions) = render(emissions) != current
+
+    # Writes the file when the rendering differs, and says whether it did.
+    def write(emissions)
+      contents = render(emissions)
+      return false if contents == current
+
+      path.write(contents)
+      true
+    end
+
+    private
+
+    # The file around our block. With no block, all of it is "before".
+    def split
+      match = BLOCK.match(current)
+      match ? [match.pre_match, match.post_match] : [current, ""]
+    end
+
+    def block(emissions)
+      body = "#{BEGIN_MARKER}\n"
+      PREAMBLE.each { |line| body << line << "\n" }
+      emissions.chunk_while { |a, b| a.rule == b.rule }.each do |group|
+        body << "\n# #{group.first.rule.summary}\n"
+        group.each { |emission| body << emission.line << "\n" }
+      end
+      body << END_MARKER << "\n"
+    end
+
+    def join(*sections)
+      sections.compact.map { |section| tidy(section) }.reject(&:empty?).join("\n")
+    end
+
+    # One trailing newline and no leading blank lines, so the sections join
+    # with exactly one blank line between them however the file arrived.
+    def tidy(text)
+      trimmed = text.sub(/\A\n+/, "").sub(/\n*\z/, "")
+      trimmed.empty? ? "" : "#{trimmed}\n"
+    end
+  end
+end

data/lib/this_is_ruby/cli.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module ThisIsRuby
+  # Three verbs: write the file, show what would be written, or fail when it
+  # has drifted. `check` is the one CI cares about.
+  class CLI
+    COMMANDS = %w[apply plan check].freeze
+
+    USAGE = <<~TEXT
+      Usage: this_is_ruby [command] [options]
+
+      Commands:
+        apply     write the managed block into .gitattributes (default)
+        plan      show what apply would write, change nothing
+        check     exit 1 when .gitattributes is out of date (for CI)
+
+      Options:
+    TEXT
+
+    def self.call(argv, out: $stdout, err: $stderr)
+      new(argv, out:, err:).call
+    end
+
+    def initialize(argv, out: $stdout, err: $stderr)
+      @argv = argv
+      @out = out
+      @err = err
+      @options = {path: ".", all_frontend: false, color: out.tty?}
+    end
+
+    def call
+      command = parse
+      # --help and --version leave nothing to run; bad input leaves nothing to
+      # run either, but must not look like success to a CI step.
+      return command if command.is_a?(Integer)
+
+      repo = Repo.at(@options[:path])
+      attributes = AttributesFile.new(repo.root.join(".gitattributes"))
+      plan = Plan.build(repo, attributes:, all_frontend: @options[:all_frontend])
+      report = Report.new(plan, out: @out, color: @options[:color])
+
+      send(command, plan, attributes, report)
+    rescue Repo::NotAGitRepo => error
+      @err.puts "this_is_ruby: #{error.message}"
+      1
+    end
+
+    private
+
+    def apply(plan, attributes, report)
+      report.call
+      report.wrote(display(attributes.path)) if attributes.write(plan.emissions)
+      0
+    end
+
+    def plan(plan, attributes, report)
+      report.call
+      0
+    end
+
+    def check(plan, attributes, report)
+      return 0 unless attributes.stale?(plan.emissions)
+
+      report.call
+      report.drift(display(attributes.path))
+      1
+    end
+
+    def display(path)
+      path.relative_path_from(Pathname.pwd).to_s
+    rescue ArgumentError
+      path.to_s
+    end
+
+    def parse
+      parser = OptionParser.new do |opts|
+        opts.banner = USAGE
+        opts.on("--path DIR", "repository to inspect (default: .)") { |dir| @options[:path] = dir }
+        opts.on("--all-frontend", "also mark hand-written frontend sources as vendored") { @options[:all_frontend] = true }
+        opts.on("--[no-]color", "colourise output") { |on| @options[:color] = on }
+        opts.on("-v", "--version", "print the version") do
+          @out.puts VERSION
+          return 0
+        end
+        opts.on("-h", "--help", "print this message") do
+          @out.puts opts
+          return 0
+        end
+      end
+      rest = parser.parse(@argv)
+      return refuse(parser, "one command at a time, got #{rest.join(" ")}") if rest.size > 1
+
+      command = rest.first || "apply"
+      return refuse(parser, "unknown command #{command.inspect}") unless COMMANDS.include?(command)
+
+      command
+    rescue OptionParser::ParseError => error
+      refuse(parser, error.message)
+    end
+
+    # Returns the exit status, so a typo in a CI step fails instead of passing.
+    def refuse(parser, message)
+      @err.puts "this_is_ruby: #{message}"
+      @err.puts parser
+      1
+    end
+  end
+end

data/lib/this_is_ruby/emission.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ThisIsRuby
+  # One line destined for .gitattributes, plus the tracked paths that earned
+  # it. The paths are what the report shows and what the language estimate
+  # subtracts; the pattern is all that reaches the file.
+  Emission = Data.define(:pattern, :attribute, :paths, :rule) do
+    def line
+      "#{pattern} #{attribute}"
+    end
+
+    def bytes(repo)
+      paths.sum { |path| repo.size(path) }
+    end
+  end
+end

data/lib/this_is_ruby/language_estimate.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ThisIsRuby
+  # A rough stand-in for GitHub's language bar.
+  #
+  # Linguist is far more careful than this: it sniffs content, resolves
+  # ambiguous extensions and applies heuristics we do not reimplement. The
+  # point here is only to show which way the bar moves, so the numbers are
+  # always presented as an estimate and GitHub stays the authority.
+  module LanguageEstimate
+    # Only types Linguist counts: programming and markup. Anything absent
+    # here (JSON, YAML, Markdown, lockfiles) is data or prose and scores
+    # nothing, which is why package-lock.json never mattered.
+    EXTENSIONS = {
+      ".rb" => "Ruby", ".rake" => "Ruby", ".gemspec" => "Ruby", ".ru" => "Ruby",
+      ".erb" => "HTML", ".html" => "HTML", ".htm" => "HTML",
+      ".haml" => "Haml", ".slim" => "Slim",
+      ".ts" => "TypeScript", ".tsx" => "TypeScript", ".mts" => "TypeScript",
+      ".js" => "JavaScript", ".jsx" => "JavaScript", ".mjs" => "JavaScript",
+      ".css" => "CSS", ".scss" => "SCSS", ".sass" => "SCSS", ".less" => "Less",
+      ".vue" => "Vue", ".svelte" => "Svelte",
+      ".py" => "Python", ".go" => "Go", ".rs" => "Rust", ".java" => "Java",
+      ".sh" => "Shell", ".bash" => "Shell", ".sql" => "SQL", ".ejs" => "EJS"
+    }.freeze
+
+    FILENAMES = {
+      "Gemfile" => "Ruby", "Rakefile" => "Ruby", "Guardfile" => "Ruby",
+      "Capfile" => "Ruby", "Dockerfile" => "Dockerfile"
+    }.freeze
+
+    # The parts of Linguist's own vendor list a Ruby project actually hits.
+    # Mirrored here so the estimate does not count bytes GitHub never counts.
+    VENDORED = Regexp.union(
+      %r{(\A|/)node_modules/},
+      %r{(\A|/)bower_components/},
+      %r{(\A|/)\.yarn/(releases|plugins|sdks|versions|unplugged)/},
+      %r{(\A|/)vendors?/},
+      /\.min\.(js|css)\z/
+    )
+
+    module_function
+
+    # Returns [[language, bytes], ...], largest first.
+    def of(repo, excluding: Set.new)
+      totals = Hash.new(0)
+      repo.tracked.each do |path|
+        next if excluding.include?(path) || VENDORED.match?(path)
+
+        language = language_for(path)
+        totals[language] += repo.size(path) if language
+      end
+      totals.sort_by { |language, bytes| [-bytes, language] }
+    end
+
+    def language_for(path)
+      name = File.basename(path)
+      return FILENAMES[name] if FILENAMES.key?(name)
+
+      # `index.html.erb` is ERB templating HTML; GitHub reports it as HTML.
+      EXTENSIONS[File.extname(name).downcase]
+    end
+  end
+end

data/lib/this_is_ruby/plan.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ThisIsRuby
+  # What we intend to write, and what we deliberately left alone.
+  class Plan
+    LINGUIST_ATTRIBUTES = %w[linguist-generated linguist-vendored linguist-documentation].freeze
+
+    attr_reader :repo, :emissions, :declared
+
+    def self.build(repo, attributes:, all_frontend: false)
+      spoken_for = spoken_for(attributes.existing_attributes)
+      found = Rules.for_level(all_frontend:).flat_map { |rule| rule.apply(repo) }
+      declared, emissions = found.partition do |emission|
+        spoken_for.any? { |pattern| covers?(pattern, emission.pattern) }
+      end
+      new(repo:, emissions: prune(emissions), declared:)
+    end
+
+    # Patterns whose Linguist attributes the owner has already decided, set or
+    # unset. `-linguist-generated` is a decision too, and writing our own line
+    # after it would quietly reverse it, since the last match wins.
+    def self.spoken_for(existing)
+      existing.filter_map do |pattern, attributes|
+        names = attributes.map { |attribute| attribute.delete_prefix("-").delete_prefix("!").split("=").first }
+        pattern if (names & LINGUIST_ATTRIBUTES).any?
+      end
+    end
+
+    # Does a declared pattern speak for the one we were about to write?
+    #
+    # Only the two shapes we emit are resolved: `dir/**` reaches everything
+    # below it, and anything else matches the way a single star does in
+    # gitignore syntax. A declared pattern covering only some of an emission's
+    # paths is not detected.
+    def self.covers?(declared, pattern)
+      return true if declared == pattern
+      return pattern.start_with?(declared.delete_suffix("**")) if declared.end_with?("**")
+
+      File.fnmatch?(declared, pattern, File::FNM_PATHNAME)
+    end
+
+    # Drops a pattern when a broader one already carries the same attribute:
+    # once `app/javascript/**` is vendored, saying so again about
+    # `app/javascript/components/ui/**` only makes the file longer.
+    def self.prune(emissions)
+      emissions.reject do |emission|
+        emissions.any? do |other|
+          next false unless other.pattern.end_with?("**")
+          next false if other.pattern == emission.pattern || other.attribute != emission.attribute
+
+          emission.pattern.start_with?(other.pattern.delete_suffix("**"))
+        end
+      end
+    end
+
+    def initialize(repo:, emissions:, declared:)
+      @repo = repo
+      @emissions = emissions.freeze
+      @declared = declared.freeze
+    end
+
+    def empty? = emissions.empty?
+
+    def claimed_paths
+      @claimed_paths ||= emissions.flat_map(&:paths).to_set
+    end
+
+    def before = @before ||= LanguageEstimate.of(repo)
+
+    def after = @after ||= LanguageEstimate.of(repo, excluding: claimed_paths)
+  end
+end

data/lib/this_is_ruby/repo.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+
+module ThisIsRuby
+  # The git working tree under inspection.
+  #
+  # Only tracked files are considered. Linguist reads the repository, so a
+  # path git ignores is already invisible to it and needs no attribute.
+  # That is why a project that gitignores `coverage/`, as most do, gets
+  # nothing written about it.
+  class Repo
+    class NotAGitRepo < Error; end
+
+    # Reading a whole blob to look for a marker comment is wasteful, and the
+    # markers we check for all sit in the first few lines.
+    PEEK_BYTES = 4096
+
+    attr_reader :root
+
+    def self.at(path)
+      # capture3, not capture2e: git writes warnings and GIT_TRACE output to
+      # stderr while still succeeding, and merging them corrupts the path.
+      out, _err, status = Open3.capture3("git", "-C", path.to_s, "rev-parse", "--show-toplevel")
+      raise NotAGitRepo, "not a git repository: #{path}" unless status.success?
+
+      new(out.strip)
+    end
+
+    def initialize(root)
+      @root = Pathname.new(root).expand_path
+    end
+
+    # Returns an Array of repo-relative paths, as git reports them.
+    def tracked
+      @tracked ||= begin
+        out, _err, status = Open3.capture3("git", "-C", root.to_s, "ls-files", "-z")
+        raise NotAGitRepo, "cannot list files in #{root}" unless status.success?
+
+        out.split("\0").reject(&:empty?).freeze
+      end
+    end
+
+    def tracked?(path)
+      tracked_set.include?(path)
+    end
+
+    # Returns the first PEEK_BYTES of a tracked file, or nil when it is
+    # missing from the working tree (a sparse checkout, say).
+    def peek(path)
+      full = root.join(path)
+      return unless full.file?
+
+      full.open("rb") { |io| io.read(PEEK_BYTES) }
+    end
+
+    def size(path)
+      full = root.join(path)
+      full.file? ? full.size : 0
+    end
+
+    private
+
+    def tracked_set
+      @tracked_set ||= tracked.to_set
+    end
+  end
+end

data/lib/this_is_ruby/report.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ThisIsRuby
+  # Prints what the plan found. Everything here is presentation; decisions
+  # were made in Plan.
+  class Report
+    TOP = 5
+
+    def initialize(plan, out: $stdout, color: out.tty?)
+      @plan = plan
+      @out = out
+      @color = color
+    end
+
+    def call
+      if @plan.empty? && @plan.declared.empty?
+        say "Nothing to do. Linguist already counts this repository fairly."
+        return
+      end
+
+      findings
+      declared
+      language_bar
+    end
+
+    def wrote(path)
+      say "", "#{green("Wrote")} #{path}. Commit it: Linguist only reads what is in the repository."
+    end
+
+    def drift(path)
+      say "", "#{path} is out of date. Run #{bold("this_is_ruby")} and commit the result."
+    end
+
+    private
+
+    def findings
+      return if @plan.empty?
+
+      count = @plan.emissions.sum { |e| e.paths.size }
+      say "#{bold(count)} files will stop counting toward this repository's language bar:", ""
+      @plan.emissions.chunk_while { |a, b| a.rule == b.rule }.each do |group|
+        header = group.first.rule.summary
+        say "  #{bold(header)}  #{dim("#{human(group.sum { |e| e.bytes(@plan.repo) })}, #{group.sum { |e| e.paths.size }} files")}"
+        group.each { |emission| say "    #{emission.line}" }
+        say ""
+      end
+    end
+
+    def declared
+      return if @plan.declared.empty?
+
+      say dim("Already decided in .gitattributes, left alone:")
+      @plan.declared.each { |emission| say dim("  #{emission.pattern}") }
+      say ""
+    end
+
+    def language_bar
+      before = @plan.before
+      after = @plan.after
+      return if before.empty?
+
+      say "Estimated language bar #{dim("(GitHub is the authority; this is a guide)")}", ""
+      rows = (before.first(TOP).map(&:first) | after.first(TOP).map(&:first))
+      width = rows.map(&:length).max
+      say "  #{"".ljust(width)}   #{"now".rjust(7)}   #{"after".rjust(7)}"
+      rows.each do |language|
+        say "  #{language.ljust(width)}   #{share(before, language).rjust(7)}   #{share(after, language).rjust(7)}"
+      end
+      say ""
+      winner = after.first&.first
+      say "  Primary language: #{bold(before.first.first)} #{dim("->")} #{green(winner)}" if winner && winner != before.first.first
+    end
+
+    def share(totals, language)
+      total = totals.sum(&:last)
+      return "--" if total.zero?
+
+      bytes = totals.assoc(language)&.last.to_i
+      bytes.zero? ? "--" : format("%.1f%%", 100.0 * bytes / total)
+    end
+
+    def human(bytes)
+      units = ["B", "KB", "MB", "GB"]
+      unit = units.shift
+      value = bytes.to_f
+      while value >= 1024 && units.any?
+        value /= 1024
+        unit = units.shift
+      end
+      (unit == "B") ? "#{bytes} B" : format("%.1f %s", value, unit)
+    end
+
+    def say(*lines) = lines.each { |line| @out.puts(line) }
+
+    def bold(text) = @color ? "\e[1m#{text}\e[0m" : text
+
+    def dim(text) = @color ? "\e[2m#{text}\e[0m" : text
+
+    def green(text) = @color ? "\e[32m#{text}\e[0m" : text
+  end
+end

data/lib/this_is_ruby/rule.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ThisIsRuby
+  # One family of files that Linguist counts but nobody in the project wrote.
+  #
+  # A rule is handed the repo and returns a Hash of pattern => tracked paths.
+  # Rules never guess: when the evidence is not on disk they return nothing,
+  # so a project that has no coverage report gets no line about one.
+  #
+  # :safe rules find files a tool produced, and always run. :frontend rules
+  # find hand-written sources, and run only with --all-frontend, because
+  # excluding those is the owner's call about what their repository is rather
+  # than a fact about who typed the file.
+  class Rule
+    LEVELS = %i[safe frontend].freeze
+
+    attr_reader :key, :attribute, :summary, :level
+
+    def initialize(key:, attribute:, summary:, level: :safe, &finder)
+      raise ArgumentError, "unknown level #{level.inspect}" unless LEVELS.include?(level)
+      raise ArgumentError, "rule #{key} needs a finder" unless finder
+
+      @key = key
+      @attribute = attribute
+      @summary = summary
+      @level = level
+      @finder = finder
+    end
+
+    def safe? = level == :safe
+
+    # Returns an Array of Emission, empty when this repo has nothing to claim.
+    def apply(repo)
+      found = @finder.call(repo) || {}
+      found.filter_map do |pattern, paths|
+        next if paths.nil? || paths.empty?
+
+        Emission.new(pattern:, attribute:, paths: paths.sort.freeze, rule: self)
+      end
+    end
+  end
+end

data/lib/this_is_ruby/rules.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module ThisIsRuby
+  # What this gem knows how to recognise.
+  #
+  # Nothing here duplicates Linguist's own defaults: `node_modules/`,
+  # `vendor/`, `.yarn/`, minified JavaScript and lockfiles are already
+  # excluded upstream, and repeating them would only make the file longer.
+  module Rules
+    # Written by `rails new` since Rails 3.0, each naming its own path in a
+    # comment. Rails 8.1 ships these lines itself; earlier versions, and any
+    # app generated with --skip-git, do not.
+    RAILS_ERROR_PAGES = %w[400 404 406-unsupported-browser 422 500].freeze
+
+    # SimpleCov's HTML formatter has opened its report with this title since
+    # 0.x. The directory is configurable, so we find it by the marker rather
+    # than by assuming `coverage/`.
+    SIMPLECOV_MARKER = "<title>Code coverage for"
+
+    # Where a Rails project keeps hand-written frontend sources, in the order
+    # the generators have used over the years.
+    FRONTEND_ROOTS = %w[app/javascript app/frontend app/webpack frontend].freeze
+
+    module_function
+
+    # Returns the tracked paths under `dir`, or an empty Array.
+    def under(repo, dir)
+      prefix = "#{dir}/"
+      repo.tracked.select { |path| path.start_with?(prefix) }
+    end
+
+    # A recursive pattern. `dir/*` would only reach the directory's immediate
+    # children. In gitignore syntax, which .gitattributes shares, a single
+    # star does not cross a slash.
+    def glob(dir) = "#{dir}/**"
+
+    def claim(repo, *dirs)
+      dirs.to_h { |dir| [glob(dir), under(repo, dir)] }
+    end
+
+    ALL = [
+      Rule.new(
+        key: :rails_error_pages,
+        attribute: "linguist-generated",
+        summary: "error pages written by `rails new`"
+      ) do |repo|
+        RAILS_ERROR_PAGES.filter_map { |page|
+          path = "public/#{page}.html"
+          next unless repo.tracked?(path)
+          # Only the generated page says where it lives. A hand-written 404
+          # is the author's own work and stays counted.
+          next unless repo.peek(path)&.include?("<!-- This file lives in #{path} -->")
+
+          [path, [path]]
+        }.to_h
+      end,
+
+      Rule.new(
+        key: :bundled_assets,
+        attribute: "linguist-generated",
+        summary: "bundler output (jsbundling, cssbundling, dartsass, tailwind)"
+      ) { |repo| claim(repo, "app/assets/builds") },
+
+      Rule.new(
+        key: :precompiled_assets,
+        attribute: "linguist-generated",
+        summary: "precompiled asset pipeline output"
+      ) { |repo| claim(repo, "public/assets") },
+
+      Rule.new(
+        key: :webpacker_packs,
+        attribute: "linguist-generated",
+        summary: "Webpacker/Shakapacker output"
+      ) { |repo| claim(repo, "public/packs", "public/packs-test") },
+
+      Rule.new(
+        key: :vite_build,
+        attribute: "linguist-generated",
+        summary: "vite_rails build output"
+      ) { |repo| claim(repo, "public/vite", "public/vite-dev", "public/vite-test") },
+
+      Rule.new(
+        key: :coverage_report,
+        attribute: "linguist-generated",
+        summary: "SimpleCov HTML report"
+      ) do |repo|
+        dirs = repo.tracked.filter_map { |path|
+          next unless path.end_with?("/index.html")
+          next unless repo.peek(path)&.include?(SIMPLECOV_MARKER)
+
+          File.dirname(path)
+        }.uniq
+        claim(repo, *dirs)
+      end,
+
+      Rule.new(
+        key: :sql_schema,
+        attribute: "linguist-generated",
+        summary: "SQL structure dump (Rails already marks db/schema.rb)"
+      ) do |repo|
+        path = "db/structure.sql"
+        repo.tracked?(path) ? {path => [path]} : {}
+      end,
+
+      Rule.new(
+        key: :shadcn_components,
+        attribute: "linguist-vendored",
+        summary: "shadcn/ui components, copied in by its generator"
+      ) do |repo|
+        # `components.json` is the generator's config; without it these are
+        # just ordinary components someone wrote.
+        next({}) unless repo.tracked?("components.json")
+
+        dirs = repo.tracked.filter_map { |path|
+          dir = File.dirname(path)
+          dir if dir.end_with?("components/ui") && path.match?(/\.(tsx|jsx|ts|js|vue|svelte)\z/)
+        }.uniq
+        claim(repo, *dirs)
+      end,
+
+      Rule.new(
+        key: :frontend_sources,
+        attribute: "linguist-vendored",
+        summary: "frontend sources, excluded at your request (--all-frontend)",
+        level: :frontend
+      ) do |repo|
+        present = FRONTEND_ROOTS.select { |dir| under(repo, dir).any? }
+        claim(repo, *present)
+      end
+    ].freeze
+
+    def for_level(all_frontend:)
+      all_frontend ? ALL : ALL.select(&:safe?)
+    end
+  end
+end

data/lib/this_is_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ThisIsRuby
+  VERSION = "0.1.0"
+end

data/lib/this_is_ruby.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "this_is_ruby/version"
+
+# Tells GitHub Linguist which files in a Ruby project nobody actually wrote.
+#
+# GitHub picks a repository's language by counting bytes, and a Rails app
+# carries a lot of bytes it never authored: generated error pages, compiled
+# assets, coverage reports, components copied in by a frontend generator.
+# Counted together they routinely outweigh the app's own Ruby, and the repo
+# is labelled HTML or TypeScript.
+#
+# Linguist already has the fix, `.gitattributes` overrides, but nobody
+# maintains that file by hand. This gem writes it from what is actually on
+# disk.
+module ThisIsRuby
+  class Error < StandardError; end
+end
+
+require_relative "this_is_ruby/repo"
+require_relative "this_is_ruby/emission"
+require_relative "this_is_ruby/rule"
+require_relative "this_is_ruby/rules"
+require_relative "this_is_ruby/plan"
+require_relative "this_is_ruby/attributes_file"
+require_relative "this_is_ruby/language_estimate"
+require_relative "this_is_ruby/report"
+require_relative "this_is_ruby/cli"

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: this_is_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Irina Nazarova
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  GitHub picks a repository's language by counting bytes, and a Rails app
+  carries plenty it never authored: generated error pages, compiled assets,
+  coverage reports, components copied in by a frontend generator. Together
+  they routinely outweigh the app's own Ruby. this_is_ruby finds them and
+  writes the .gitattributes overrides Linguist already understands.
+email:
+- inazarova@evilmartians.com
+executables:
+- this_is_ruby
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/this_is_ruby
+- lib/this_is_ruby.rb
+- lib/this_is_ruby/attributes_file.rb
+- lib/this_is_ruby/cli.rb
+- lib/this_is_ruby/emission.rb
+- lib/this_is_ruby/language_estimate.rb
+- lib/this_is_ruby/plan.rb
+- lib/this_is_ruby/repo.rb
+- lib/this_is_ruby/report.rb
+- lib/this_is_ruby/rule.rb
+- lib/this_is_ruby/rules.rb
+- lib/this_is_ruby/version.rb
+homepage: https://github.com/evilmartians/this_is_ruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/evilmartians/this_is_ruby
+  changelog_uri: https://github.com/evilmartians/this_is_ruby/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/evilmartians/this_is_ruby/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Tell GitHub which files in your Ruby project nobody wrote
+test_files: []