linecounter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0516098ec3bef60429834f965c4bbbd69a1a7f2200ea5b28a0fab21efe102b11'
+  data.tar.gz: f7c0de1fb06f0e9801bf7e2b77e0b626274fa99165675d87d5f89da3bc7a5df0
+SHA512:
+  metadata.gz: 74d6fbfa03a53a8a5828c795d17d062c96b61acc05f893523872099a55e70dcb236878c27b102282894cc338074058308ce250dfc465a3a772743af8e82e3ee4
+  data.tar.gz: '058634de3a663e430475736115c16251f09edc135eafc9d358acfe27cbea9c42dcc10e10f9b8fa85965120df4ae4b4a128e6910b498dda833b085c12e2d941f8'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert Hopman
+
+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,99 @@
+# linecounter
+
+`linecounter` lists Ruby files with lines of code, churn, branching, and avg loc per item.
+
+## Installation
+
+Install the gem:
+
+```bash
+gem install linecounter
+```
+
+Or add it to a Gemfile:
+
+```ruby
+gem "linecounter"
+```
+
+From a checkout you can run it without installing:
+
+```bash
+ruby -Ilib exe/linecounter --repo /path/to/repo
+```
+
+## Usage
+
+```bash
+linecounter [options]
+```
+
+## Options
+
+- `--top N` Show top N rows (default: 20).
+- `--since STR` Limit churn to commits since date. Supports git-parseable dates in `YYYY-MM-DD` (e.g., `2025-01-01`), other git-parseable strings (e.g., `last friday`), and relative forms: `N.days.ago`, `N.weeks.ago`, `N.hours.ago`, `N.months.ago`, `N.years.ago`, plus `today`/`yesterday`.
+- `--min-loc N` Exclude files below N non-empty lines (default: 20).
+- `--repo PATH` Path to a git repo to scan (default: current directory).
+- `--json` Output JSON instead of text.
+- `--show-branch-count` Show per-branch keyword breakdown under each file.
+- `--show-structure-overview` Show a summary of class structure counts across all files, including `avg_loc_per_item` (avg statement lines per item).
+- `--show-interaction-overview` Alias for `--show-structure-overview`.
+- `--detailed-structure` Show overall structure averages (avg lines per item) for each regex item across all files.
+- `-h`, `--help` Show help.
+
+## Examples
+
+`--repo` defaults to the current directory, so running `linecounter` with no
+arguments scans the repo you're in. If the directory isn't a git repository it
+exits with an error.
+
+```bash
+linecounter
+linecounter --repo /path/to/repo
+linecounter --repo /path/to/repo --top 50
+linecounter --repo /path/to/repo --since 2025-01-01
+linecounter --repo /path/to/repo --since 2.weeks.ago
+linecounter --repo /path/to/repo --min-loc 50
+linecounter --repo /path/to/repo --show-branch-count
+linecounter --repo /path/to/repo --show-structure-overview
+linecounter --repo /path/to/repo --detailed-structure
+linecounter --repo /path/to/repo --json
+linecounter --repo /path/to/repo --top 30 --since 3.months.ago --show-structure-overview
+```
+
+## Example Output
+
+Signals are computed from the parsed AST (via [Prism](https://github.com/ruby/prism)),
+so keywords in strings or comments are never miscounted and `avg_loc_per_item`
+reflects real definition length. Churn varies with git history, so your numbers
+will differ:
+
+```bash
+$ linecounter --repo . --min-loc 80 --detailed-structure
+Ruby Quality Signals
+Files scanned: 4
+
+Column descriptions:
+  Churn    = total git commits touching the file (optionally since --since).
+  Branches = count of control-flow tokens (sum of per-keyword counts).
+  LOC      = non-empty lines of code in the file.
+  File     = repository-relative path.
+
+Churn  Branches LOC    File
+3      34       189    lib/linecounter/structure_analyzer.rb
+3      0        161    test/unit/structure_analyzer_test.rb
+2      13       99     lib/linecounter/report.rb
+1      3        99     lib/linecounter/branch_analyzer.rb
+
+Detailed structure (all scanned files):
+constants
+  CONSTANT =                 count=11   avg_loc_per_item=8.27
+public_attribute_macros
+  public attr_reader         count=2    avg_loc_per_item=1.00
+initializer
+  initialize                 count=2    avg_loc_per_item=7.00
+public_methods
+  public def                 count=38   avg_loc_per_item=8.53
+private_methods
+  private def                count=8    avg_loc_per_item=9.75
+```

data/exe/linecounter

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# linecounter
+# Lists Ruby files with lines of code, churn, branching, and avg loc per item.
+
+require "linecounter"
+
+Linecounter::CLI.run(ARGV)

data/lib/linecounter/analyzer.rb

@@ -0,0 +1,59 @@
+require_relative "scanner"
+require_relative "git"
+require_relative "branch_analyzer"
+require_relative "structure_analyzer"
+
+module Linecounter
+  Result = Struct.new(
+    :rows,
+    :structure_overview,
+    :structure_item_loc_overview,
+    :structure_item_counts_overview,
+    keyword_init: true
+  )
+
+  module Analyzer
+    module_function
+
+    def run(repo_path:, min_loc:, since:)
+      rows = []
+      structure_overview = Hash.new(0)
+      structure_item_loc_overview = Hash.new(0)
+      structure_item_counts_overview = Hash.new(0)
+
+      Scanner.ruby_files(repo_path).each do |file|
+        content = File.read(File.join(repo_path, file)) rescue next
+        size = Scanner.loc(content)
+        next if size < min_loc
+
+        breakdown = BranchAnalyzer.breakdown(content)
+        b = breakdown.values.sum
+        c = Git.churn(repo_path, file, since)
+        structures, structure_item_counts, structure_item_loc = StructureAnalyzer.counts(content)
+        structures.each { |k, v| structure_overview[k] += v }
+        structure_item_loc.each { |k, v| structure_item_loc_overview[k] += v }
+        structure_item_counts.each { |k, v| structure_item_counts_overview[k] += v }
+
+        rows << {
+          file: file,
+          loc: size,
+          branches: b,
+          branch_breakdown: breakdown,
+          structures: structures,
+          structure_item_counts: structure_item_counts,
+          structure_item_loc: structure_item_loc,
+          churn: c
+        }
+      end
+
+      rows.sort_by! { |r| [-r[:churn], -r[:branches], -r[:loc]] }
+
+      Result.new(
+        rows: rows,
+        structure_overview: structure_overview,
+        structure_item_loc_overview: structure_item_loc_overview,
+        structure_item_counts_overview: structure_item_counts_overview
+      )
+    end
+  end
+end

data/lib/linecounter/branch_analyzer.rb

@@ -0,0 +1,118 @@
+require "prism"
+
+module Linecounter
+  module BranchAnalyzer
+    # Buckets of control-flow constructs, in display order. Counted from the
+    # parsed AST, so keywords inside strings and comments are never counted.
+    BRANCH_TOKENS = [
+      [:if, "if condition"],
+      [:elsif, "elsif branch"],
+      [:unless, "unless condition"],
+      [:case, "case expression"],
+      [:when, "when branch"],
+      [:while, "while loop"],
+      [:until, "until loop"],
+      [:rescue, "rescue handler"],
+      [:ensure, "ensure block"],
+      [:begin, "begin block"],
+      [:and, "logical AND (&& / and)"],
+      [:or, "logical OR (|| / or)"],
+      [:ternary, "ternary operator (?:)"],
+      [:return, "return statement"]
+    ].freeze
+
+    class CountingVisitor < Prism::Visitor
+      attr_reader :counts
+
+      def initialize
+        super
+        @counts = Hash.new(0)
+      end
+
+      def visit_if_node(node)
+        key =
+          if node.if_keyword_loc.nil? then :ternary
+          elsif node.if_keyword_loc.slice == "elsif" then :elsif
+          else :if
+          end
+        @counts[key] += 1
+        super
+      end
+
+      def visit_unless_node(node)
+        @counts[:unless] += 1
+        super
+      end
+
+      def visit_case_node(node)
+        @counts[:case] += 1
+        super
+      end
+
+      def visit_case_match_node(node)
+        @counts[:case] += 1
+        super
+      end
+
+      def visit_when_node(node)
+        @counts[:when] += 1
+        super
+      end
+
+      def visit_in_node(node)
+        @counts[:when] += 1
+        super
+      end
+
+      def visit_while_node(node)
+        @counts[:while] += 1
+        super
+      end
+
+      def visit_until_node(node)
+        @counts[:until] += 1
+        super
+      end
+
+      def visit_rescue_node(node)
+        @counts[:rescue] += 1
+        super
+      end
+
+      def visit_ensure_node(node)
+        @counts[:ensure] += 1
+        super
+      end
+
+      def visit_begin_node(node)
+        # Only explicit `begin ... end`; method/block-level rescue produces an
+        # implicit BeginNode (no begin keyword) that we don't count.
+        @counts[:begin] += 1 if node.begin_keyword_loc
+        super
+      end
+
+      def visit_and_node(node)
+        @counts[:and] += 1
+        super
+      end
+
+      def visit_or_node(node)
+        @counts[:or] += 1
+        super
+      end
+
+      def visit_return_node(node)
+        @counts[:return] += 1
+        super
+      end
+    end
+
+    module_function
+
+    def breakdown(content)
+      visitor = CountingVisitor.new
+      Prism.parse(content).value.accept(visitor)
+      BRANCH_TOKENS.each_with_object({}) { |(name, _label), acc| acc[name] = visitor.counts[name] }
+    end
+  end
+end

data/lib/linecounter/cli.rb

@@ -0,0 +1,66 @@
+require "optparse"
+require_relative "git"
+require_relative "analyzer"
+require_relative "report"
+
+module Linecounter
+  module CLI
+    DEFAULTS = {
+      top: 20,
+      since: nil,
+      json: false,
+      min_loc: 20,
+      show_branch_count: false,
+      show_structure_overview: false,
+      show_detailed_structure: false,
+      repo: nil
+    }.freeze
+
+    module_function
+
+    def run(argv)
+      options = DEFAULTS.dup
+      build_parser(options).parse!(argv)
+
+      options[:repo] ||= "."
+      options[:since] = Git.parse_since(options[:since])
+
+      repo_path = File.expand_path(options[:repo])
+      abort "Not inside a git repository: #{repo_path}" unless Git.repo?(repo_path)
+
+      result = Analyzer.run(repo_path: repo_path, min_loc: options[:min_loc], since: options[:since])
+      Report.render(result, options)
+    end
+
+    def build_parser(options)
+      OptionParser.new do |o|
+        o.banner = "Usage: linecounter [options]"
+        o.separator ""
+        o.separator "Options:"
+        o.on("--top N", Integer, "Show top N rows (default: 20).") { |v| options[:top] = v }
+        o.on("--since STR", String, "Limit churn to commits since date. Supports git-parseable dates in YYYY-MM-DD (e.g., '2025-01-01'), other git-parseable strings (e.g., 'last friday'), and relative forms: 'N.days.ago', 'N.weeks.ago', 'N.hours.ago', 'N.months.ago', 'N.years.ago', plus 'today'/'yesterday'.") { |v| options[:since] = v }
+        o.on("--min-loc N", Integer, "Exclude files below N non-empty lines (default: 20).") { |v| options[:min_loc] = v }
+        o.on("--repo PATH", String, "Path to a git repo to scan (default: current directory).") { |v| options[:repo] = v }
+        o.on("--json", "Output JSON instead of text.") { options[:json] = true }
+        o.on("--show-branch-count", "Show per-branch keyword breakdown under each file.") { options[:show_branch_count] = true }
+        o.on("--show-structure-overview", "Show a summary of class structure counts across all files, including avg_loc_per_item (avg statement lines per item).") { options[:show_structure_overview] = true }
+        o.on("--show-interaction-overview", "Alias for --show-structure-overview.") { options[:show_structure_overview] = true }
+        o.on("--detailed-structure", "Show overall structure averages (avg lines per item) for each regex item across all files.") { options[:show_detailed_structure] = true }
+        o.on("-h", "--help", "Show this help.") { puts o; exit }
+        o.separator ""
+        o.separator "Examples:"
+        o.separator "  linecounter"
+        o.separator "  linecounter --repo /path/to/repo"
+        o.separator "  linecounter --repo /path/to/repo --top 50"
+        o.separator "  linecounter --repo /path/to/repo --since 2025-01-01"
+        o.separator "  linecounter --repo /path/to/repo --since 2.weeks.ago"
+        o.separator "  linecounter --repo /path/to/repo --min-loc 50"
+        o.separator "  linecounter --repo /path/to/repo --show-branch-count"
+        o.separator "  linecounter --repo /path/to/repo --show-structure-overview"
+        o.separator "  linecounter --repo /path/to/repo --detailed-structure"
+        o.separator "  linecounter --repo /path/to/repo --json"
+        o.separator "  linecounter --repo /path/to/repo --top 30 --since 3.months.ago"
+      end
+    end
+  end
+end

data/lib/linecounter/git.rb

@@ -0,0 +1,51 @@
+require "open3"
+require "time"
+
+module Linecounter
+  module Git
+    module_function
+
+    def run(*cmd)
+      stdout, _, ok = Open3.capture3(*cmd)
+      ok ? stdout : ""
+    end
+
+    def repo?(repo_path)
+      system("git", "-C", repo_path, "rev-parse", "--is-inside-work-tree", out: File::NULL, err: File::NULL)
+    end
+
+    def churn(repo_path, file, since)
+      cmd = ["git", "-C", repo_path, "log", "--follow", "--pretty=oneline"]
+      cmd += ["--since", since] if since
+      cmd += ["--", file]
+      run(*cmd).lines.count
+    end
+
+    def parse_since(str)
+      return nil if str.nil?
+      return str if str.strip.empty?
+
+      normalized = str.strip.downcase
+      if (m = normalized.match(/\A(\d+)\.(days?|weeks?|months?|years?|hours?)\.ago\z/))
+        count = m[1].to_i
+        unit = m[2]
+        seconds =
+          case unit
+          when "day", "days" then 86_400
+          when "week", "weeks" then 7 * 86_400
+          when "hour", "hours" then 3_600
+          when "month", "months" then 30 * 86_400
+          when "year", "years" then 365 * 86_400
+          else 0
+          end
+        return (Time.now - (count * seconds)).utc.iso8601
+      end
+
+      case normalized
+      when "today" then Time.now.utc.iso8601
+      when "yesterday" then (Time.now - 86_400).utc.iso8601
+      else str
+      end
+    end
+  end
+end

data/lib/linecounter/report.rb

@@ -0,0 +1,108 @@
+require "json"
+require "time"
+require_relative "branch_analyzer"
+require_relative "structure_analyzer"
+
+module Linecounter
+  module Report
+    module_function
+
+    def render(result, options)
+      if options[:json]
+        json(result, options)
+      else
+        text(result, options)
+      end
+    end
+
+    def json(result, options)
+      rows = result.rows
+      payload = {
+        generated_at: Time.now.utc.iso8601,
+        files_scanned: rows.size,
+        top: rows.first(options[:top])
+      }
+      unless options[:show_branch_count]
+        payload[:top] = payload[:top].map { |r| r.reject { |k, _| k == :branch_breakdown } }
+      end
+      if options[:show_structure_overview]
+        payload[:structure_overview] = result.structure_overview
+        payload[:structure_loc_overview] = type_loc_overview(result)
+      end
+      if options[:show_detailed_structure]
+        payload[:structure_item_counts_overview] = result.structure_item_counts_overview
+        payload[:structure_item_loc_overview] = result.structure_item_loc_overview
+      end
+      unless options[:show_detailed_structure]
+        payload[:top] = payload[:top].map { |r| r.reject { |k, _| k == :structure_item_loc || k == :structure_item_counts } }
+      end
+      puts JSON.pretty_generate(payload)
+    end
+
+    def text(result, options)
+      rows = result.rows
+      puts "Ruby Quality Signals"
+      puts "Files scanned: #{rows.size}"
+      puts
+      puts "Column descriptions:"
+      puts "  Churn    = total git commits touching the file (optionally since --since)."
+      puts "  Branches = count of control-flow tokens (sum of per-keyword counts)."
+      puts "  LOC      = non-empty lines of code in the file."
+      puts "  File     = repository-relative path."
+      puts
+      puts "%-6s %-8s %-6s %s" % ["Churn", "Branches", "LOC", "File"]
+
+      rows.first(options[:top]).each do |r|
+        puts "%-6d %-8d %-6d %s" % [r[:churn], r[:branches], r[:loc], r[:file]]
+        if options[:show_branch_count]
+          breakdown = r[:branch_breakdown]
+          detail = BranchAnalyzer::BRANCH_TOKENS.map { |name, label, _| "#{label}=#{breakdown[name]}" }.join(" | ")
+          puts "  #{detail}"
+        end
+      end
+
+      if options[:show_structure_overview]
+        puts
+        puts "Structure overview (all scanned files):"
+        StructureAnalyzer::STRUCTURE_ORDER.each do |key|
+          count = result.structure_overview[key]
+          avg_loc_per_item = count.zero? ? 0.0 : (type_loc_sum(result, key).to_f / count)
+          puts "%-26s count=%-4d avg_loc_per_item=%0.2f" % [key, count, avg_loc_per_item]
+        end
+      end
+
+      if options[:show_detailed_structure]
+        puts
+        puts "Detailed structure (all scanned files):"
+        StructureAnalyzer::STRUCTURE_ORDER.each do |type|
+          items = StructureAnalyzer::STRUCTURE_ITEMS.select { |item| item[:type] == type }
+          next if items.empty?
+          lines = items.map do |item|
+            count = result.structure_item_counts_overview[item[:key]]
+            next if count.zero?
+            avg = result.structure_item_loc_overview[item[:key]].to_f / count
+            "  %-26s count=%-4d avg_loc_per_item=%0.2f" % [item[:label], count, avg]
+          end.compact
+          next if lines.empty?
+          puts type
+          lines.each { |line| puts line }
+        end
+      end
+    end
+
+    # Total statement LOC for a structure type, summed from its items. The
+    # per-item LOC is item-keyed, so it must be rolled up by type here rather
+    # than indexed directly by the type symbol.
+    def type_loc_sum(result, type)
+      StructureAnalyzer::STRUCTURE_ITEMS
+        .select { |item| item[:type] == type }
+        .sum { |item| result.structure_item_loc_overview[item[:key]] }
+    end
+
+    def type_loc_overview(result)
+      result.structure_overview.keys.each_with_object({}) do |type, acc|
+        acc[type] = type_loc_sum(result, type)
+      end
+    end
+  end
+end

data/lib/linecounter/scanner.rb

@@ -0,0 +1,21 @@
+require_relative "git"
+
+module Linecounter
+  module Scanner
+    EXTS = %w[rb].freeze
+
+    module_function
+
+    def loc(content)
+      content.each_line.count { |l| !l.strip.empty? }
+    end
+
+    def ruby_files(repo_path)
+      Git.run("git", "-C", repo_path, "ls-files")
+        .lines
+        .map(&:strip)
+        .select { |f| EXTS.include?(File.extname(f).delete(".")) }
+        .reject { |f| File.basename(f) == "schema.rb" }
+    end
+  end
+end

data/lib/linecounter/structure_analyzer.rb

@@ -0,0 +1,223 @@
+require "prism"
+
+module Linecounter
+  module StructureAnalyzer
+    STRUCTURE_ORDER = [
+      :module_inclusion,
+      :constants,
+      :association,
+      :public_attribute_macros,
+      :public_delegate,
+      :macros,
+      :public_class_methods,
+      :initializer,
+      :public_methods,
+      :protected_attribute_macros,
+      :protected_methods,
+      :private_attribute_macros,
+      :private_delegate,
+      :private_methods
+    ].freeze
+
+    # Item metadata: key -> (type, human label). Counts are keyed by item; each
+    # item rolls up into exactly one type.
+    STRUCTURE_ITEMS = [
+      { key: :include, type: :module_inclusion, label: "include" },
+      { key: :extend, type: :module_inclusion, label: "extend" },
+      { key: :prepend, type: :module_inclusion, label: "prepend" },
+      { key: :constant_assignment, type: :constants, label: "CONSTANT =" },
+
+      { key: :has_many, type: :association, label: "has_many" },
+      { key: :has_one, type: :association, label: "has_one" },
+      { key: :belongs_to, type: :association, label: "belongs_to" },
+      { key: :habtm, type: :association, label: "has_and_belongs_to_many" },
+      { key: :has_one_attached, type: :association, label: "has_one_attached" },
+      { key: :has_many_attached, type: :association, label: "has_many_attached" },
+
+      { key: :scope, type: :macros, label: "scope" },
+      { key: :validates, type: :macros, label: "validates" },
+      { key: :validate, type: :macros, label: "validate" },
+      { key: :before_callback, type: :macros, label: "before_*" },
+      { key: :after_callback, type: :macros, label: "after_*" },
+      { key: :around_callback, type: :macros, label: "around_*" },
+      { key: :enum, type: :macros, label: "enum" },
+      { key: :serialize, type: :macros, label: "serialize" },
+      { key: :store, type: :macros, label: "store" },
+      { key: :store_accessor, type: :macros, label: "store_accessor" },
+
+      { key: :public_attr_reader, type: :public_attribute_macros, label: "public attr_reader" },
+      { key: :public_attr_writer, type: :public_attribute_macros, label: "public attr_writer" },
+      { key: :public_attr_accessor, type: :public_attribute_macros, label: "public attr_accessor" },
+      { key: :protected_attr_reader, type: :protected_attribute_macros, label: "protected attr_reader" },
+      { key: :protected_attr_writer, type: :protected_attribute_macros, label: "protected attr_writer" },
+      { key: :protected_attr_accessor, type: :protected_attribute_macros, label: "protected attr_accessor" },
+      { key: :private_attr_reader, type: :private_attribute_macros, label: "private attr_reader" },
+      { key: :private_attr_writer, type: :private_attribute_macros, label: "private attr_writer" },
+      { key: :private_attr_accessor, type: :private_attribute_macros, label: "private attr_accessor" },
+
+      { key: :public_delegate, type: :public_delegate, label: "public delegate" },
+      { key: :private_delegate, type: :private_delegate, label: "private delegate" },
+
+      { key: :public_class_method_def, type: :public_class_methods, label: "public class def" },
+      { key: :public_instance_method_def, type: :public_methods, label: "public def" },
+      { key: :protected_instance_method_def, type: :protected_methods, label: "protected def" },
+      { key: :private_instance_method_def, type: :private_methods, label: "private def" },
+      { key: :initializer_def, type: :initializer, label: "initialize" }
+    ].freeze
+
+    KEY_TO_TYPE = STRUCTURE_ITEMS.each_with_object({}) { |item, h| h[item[:key]] = item[:type] }.freeze
+
+    ASSOCIATION_KEYS = {
+      has_many: :has_many, has_one: :has_one, belongs_to: :belongs_to,
+      has_and_belongs_to_many: :habtm, has_one_attached: :has_one_attached,
+      has_many_attached: :has_many_attached
+    }.freeze
+
+    PLAIN_MACROS = %i[scope validates validate enum serialize store store_accessor].freeze
+    MODULE_INCLUSION = %i[include extend prepend].freeze
+    ATTRIBUTE_MACROS = %i[attr_reader attr_writer attr_accessor].freeze
+    VISIBILITY_NAMES = %i[public protected private].freeze
+
+    # Walks the AST tracking visibility per class/module scope, so each method,
+    # macro, and constant is attributed accurately at the structure level only
+    # (declarations inside method bodies are not miscounted).
+    class StructureVisitor < Prism::Visitor
+      attr_reader :type_counts, :item_counts, :item_loc_sums
+
+      def initialize
+        super
+        @type_counts = Hash.new(0)
+        @item_counts = Hash.new(0)
+        @item_loc_sums = Hash.new(0)
+        @visibility = [:public]
+        @method_depth = 0
+        @singleton_depth = 0
+        @forced_visibility = nil
+      end
+
+      def visit_class_node(node)
+        with_scope { super }
+      end
+
+      def visit_module_node(node)
+        with_scope { super }
+      end
+
+      def visit_singleton_class_node(node)
+        @singleton_depth += 1
+        with_scope { super }
+        @singleton_depth -= 1
+      end
+
+      def visit_def_node(node)
+        classify_def(node) if @method_depth.zero?
+        @method_depth += 1
+        super
+        @method_depth -= 1
+      end
+
+      def visit_constant_write_node(node)
+        record(:constant_assignment, node) if @method_depth.zero?
+        super
+      end
+
+      def visit_constant_path_write_node(node)
+        record(:constant_assignment, node) if @method_depth.zero?
+        super
+      end
+
+      def visit_call_node(node)
+        return super unless node.receiver.nil?
+
+        name = node.name
+        if VISIBILITY_NAMES.include?(name)
+          handle_visibility(node, name)
+        else
+          record(macro_key(name), node) if @method_depth.zero?
+          super
+        end
+      end
+
+      private
+
+      def current_visibility
+        @forced_visibility || @visibility.last
+      end
+
+      def with_scope
+        @visibility.push(:public)
+        saved_depth = @method_depth
+        @method_depth = 0
+        yield
+        @method_depth = saved_depth
+        @visibility.pop
+      end
+
+      def handle_visibility(node, name)
+        args = node.arguments&.arguments || []
+        if args.empty?
+          @visibility[-1] = name if @method_depth.zero?
+          # No meaningful children to record.
+        else
+          previous = @forced_visibility
+          @forced_visibility = name
+          super_visit(node)
+          @forced_visibility = previous
+        end
+      end
+
+      # Visit children of a node without re-dispatching the node itself.
+      def super_visit(node)
+        node.compact_child_nodes.each { |child| child.accept(self) }
+      end
+
+      def classify_def(node)
+        if node.receiver.is_a?(Prism::SelfNode) || @singleton_depth.positive?
+          record(:public_class_method_def, node)
+        elsif node.name == :initialize
+          record(:initializer_def, node)
+        else
+          record(VISIBILITY_DEF_KEYS.fetch(current_visibility), node)
+        end
+      end
+
+      VISIBILITY_DEF_KEYS = {
+        public: :public_instance_method_def,
+        protected: :protected_instance_method_def,
+        private: :private_instance_method_def
+      }.freeze
+
+      def macro_key(name)
+        return name if MODULE_INCLUSION.include?(name)
+        return ASSOCIATION_KEYS[name] if ASSOCIATION_KEYS.key?(name)
+        return name if PLAIN_MACROS.include?(name)
+        return :"#{current_visibility}_attr_#{name.to_s.delete_prefix("attr_")}" if ATTRIBUTE_MACROS.include?(name)
+        return current_visibility == :private ? :private_delegate : :public_delegate if name == :delegate
+
+        s = name.to_s
+        return :before_callback if s.start_with?("before_")
+        return :after_callback if s.start_with?("after_")
+        return :around_callback if s.start_with?("around_")
+
+        nil
+      end
+
+      def record(key, node)
+        type = key && KEY_TO_TYPE[key]
+        return unless type
+
+        @item_counts[key] += 1
+        @item_loc_sums[key] += node.location.end_line - node.location.start_line + 1
+        @type_counts[type] += 1
+      end
+    end
+
+    module_function
+
+    def counts(content)
+      visitor = StructureVisitor.new
+      Prism.parse(content).value.accept(visitor)
+      [visitor.type_counts, visitor.item_counts, visitor.item_loc_sums]
+    end
+  end
+end

data/lib/linecounter/version.rb

@@ -0,0 +1,3 @@
+module Linecounter
+  VERSION = "0.1.0"
+end

data/lib/linecounter.rb

@@ -0,0 +1,8 @@
+require_relative "linecounter/version"
+require_relative "linecounter/branch_analyzer"
+require_relative "linecounter/structure_analyzer"
+require_relative "linecounter/git"
+require_relative "linecounter/scanner"
+require_relative "linecounter/analyzer"
+require_relative "linecounter/report"
+require_relative "linecounter/cli"

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: linecounter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Hopman
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: linecounter scans a git repository and reports per-file quality signals
+  — non-empty lines of code, git churn, control-flow branching, and class-structure
+  counts with average statement lines per item. Output as text or JSON.
+email:
+- hopman.r@gmail.com
+executables:
+- linecounter
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/linecounter
+- lib/linecounter.rb
+- lib/linecounter/analyzer.rb
+- lib/linecounter/branch_analyzer.rb
+- lib/linecounter/cli.rb
+- lib/linecounter/git.rb
+- lib/linecounter/report.rb
+- lib/linecounter/scanner.rb
+- lib/linecounter/structure_analyzer.rb
+- lib/linecounter/version.rb
+homepage: https://github.com/roberthopman/linecounter
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/roberthopman/linecounter
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'Per-file Ruby quality signals: lines of code, churn, branching, and structure.'
+test_files: []