crap4ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 55e5f45f41b35122c6ad4b4894e3d5e496af3842c4a4f28e8172806c45d8d620
+  data.tar.gz: '0279b34834aeba13649a0f124b6064b44a92fdffa868ad5f1a893e56a9067473'
+SHA512:
+  metadata.gz: 555c402719177c91525c68611ee3e5e88ae0c674bf74a1f2b477857d4e97e017cfe50a2674d829e46a9fd7c16a252d69aaf97953ebb811d6a98a733596898157
+  data.tar.gz: 0e9ea5f5d64473c6547faaad0cc4126a0d7a1c0236c37c0a457cdb1e69ae5d828160619ddce843033df76c723c45440f64049b071a5bf74846ad11447700a1d4

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-28
+
+### Added
+
+- Static Ruby method complexity analysis with Prism.
+- SimpleCov line coverage, merged test suites, and CRAP scores.
+- Source filters, Git change selection, explicit coverage commands, and optional score thresholds.
+- Terminal reports and atomic snapshots compatible with crapper's EDN format.
+- Permanent SimpleCov collection and a default Rake check enforcing a maximum method CRAP score of 10.
+
+### Changed
+
+- Split CLI execution, AST discovery, and coverage loading into smaller methods without changing their behavior or scoring rules.
+
+[Unreleased]: https://github.com/svyatov/crap4ruby/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/svyatov/crap4ruby/releases/tag/v0.1.0

data/CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Contributing
+
+Use Ruby 3.3 or newer. Install dependencies and run the suite:
+
+```sh
+bundle install
+bundle exec rake
+```
+
+The default check runs tests with fresh SimpleCov coverage and requires every library method's CRAP score to be at most 10.
+Use `bundle exec rake test` for tests alone. Open `coverage/index.html` to inspect line coverage.
+
+Add a regression test for a behavior change. Use temporary projects for filesystem, Git, coverage, and CLI tests.
+Keep analyzed code out of the tool's process. Preserve the previous snapshot when analysis fails.
+
+For defect reports, include the Ruby version, command, expected result, actual result, and a minimal source example.
+Coverage defects also need a matching excerpt from `.resultset.json`. Remove application secrets before sharing examples.
+
+Changes use Conventional Commits. Keep code, tests, and documentation for one behavior in a focused commit.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leonid Svyatov
+
+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,191 @@
+# crap4ruby
+
+crap4ruby identifies complex, under-tested Ruby methods using the Change Risk Anti-Pattern (CRAP) metric.
+
+- Analyzes Ruby 3.3+ source with Prism without loading application code.
+- Reads SimpleCov reports, including legacy formats and multiple test suites.
+- Prints method scores and writes the snapshot format used by [crapper](https://github.com/unclebob/crapper).
+
+## Install
+
+Ruby 3.3 or newer is required.
+
+```sh
+gem install crap4ruby
+```
+
+In the project you want to measure:
+
+```sh
+crap4ruby --no-coverage
+crap4ruby
+crap4ruby --threshold 30
+crap4ruby app/models lib/billing
+```
+
+The first command reports complexity alone. The other commands require `coverage/.resultset.json` from your project's test run.
+
+To use Bundler, add `gem "crap4ruby", require: false` to your project's `Gemfile` and run `bundle install`.
+Run the tool with `bundle exec crap4ruby`.
+
+## Install from source
+
+Run these commands from this checkout with Ruby 3.3 or newer:
+
+```sh
+bundle install
+gem build crap4ruby.gemspec
+gem install ./crap4ruby-0.1.0.gem
+```
+
+To use Bundler in the measured project, add this checkout to that project's `Gemfile`:
+
+```ruby
+gem "crap4ruby", path: "/absolute/path/to/crap4ruby", require: false
+```
+
+Then run `bundle install` and `bundle exec crap4ruby` in that project.
+
+## Set up coverage
+
+[SimpleCov](https://github.com/simplecov-ruby/simplecov) must start before the application loads. Add it to the measured project's test dependencies:
+
+```ruby
+gem "simplecov", require: false, group: :test
+```
+
+Place this at the top of `test/test_helper.rb` or `spec/spec_helper.rb`, before requiring application code:
+
+```ruby
+require "simplecov"
+SimpleCov.start
+```
+
+Run your tests, then run `crap4ruby`. RSpec and Minitest work through the same SimpleCov report format.
+
+You can also supply an explicit command:
+
+```sh
+crap4ruby --coverage-command 'bundle exec rspec'
+crap4ruby --coverage custom/.resultset.json
+```
+
+The command runs through `sh` at the project root with the caller's environment. Its output goes to stderr.
+It must exit successfully and create or refresh the selected report. A failed command never replaces the CRAP snapshot.
+crap4ruby does not configure SimpleCov, delete reports, install dependencies, or select a test runner.
+
+## Commands
+
+| Option | Behavior |
+| --- | --- |
+| `--root PATH` | Set the project root; default is the current directory. |
+| `--source-root PATH` | Search this directory; repeat for multiple roots. |
+| `--changed` | Limit analysis to staged, unstaged, and untracked Git changes. |
+| `--coverage PATH` | Read this SimpleCov resultset; default is `coverage/.resultset.json`. |
+| `--use-existing-coverage` | Explicitly select the default: read reports without running tests. |
+| `--coverage-command COMMAND` | Run a shell command that refreshes the selected report. |
+| `--no-coverage` | Report complexity with unknown coverage and CRAP. |
+| `--threshold NUMBER` | Exit 2 when any unrounded score exceeds this finite, nonnegative value. |
+| `-h`, `--help` | Print usage. |
+| `-v`, `--version` | Print the gem version. |
+
+Paths are relative to `--root`. Positional arguments select files or directories.
+An argument that is not a path filters source paths by substring. Multiple filters use OR.
+Explicit paths and source roots are combined; filters and `--changed` narrow that selection.
+
+Discovery includes `.rb` files. It skips hidden directories, test/spec files, and these directories:
+`test`, `tests`, `spec`, `features`, `vendor`, `node_modules`, `target`, `coverage`, `tmp`, `log`, `pkg`, `build`, and `dist`.
+Test filenames are `test_*.rb`, `spec_*.rb`, `*_test.rb`, and `*_spec.rb`.
+An explicitly named file overrides these exclusions. Directory traversal does not follow symbolic links.
+
+Exit 0 means analysis succeeded. Exit 1 means invalid usage, unreadable or invalid input, a Git failure, or a coverage command failure.
+Exit 2 means analysis succeeded but exceeded the threshold. No threshold applies unless you set one.
+Every successful analysis replaces the snapshot, including filtered analyses and empty selections.
+
+## Complexity and coverage
+
+The formula uses a coverage fraction between 0 and 1:
+
+```text
+CRAP = CC^2 * (1 - coverage)^3 + CC
+```
+
+Cyclomatic complexity (CC) starts at 1. Each of these adds 1:
+
+- `if`, `elsif`, `unless`, and ternary conditions, including modifier forms.
+- `while`, `until`, and `for` loops.
+- Each `when` or pattern-matching `in` clause, including a separate increment for a guard condition.
+- Each rescue clause and rescue modifier.
+- Each `&&`, `||`, `and`, `or`, `&&=`, `||=`, and safe-navigation operation.
+
+A `when` clause adds 1 regardless of its number of alternatives. `else` and `ensure` add nothing.
+Decisions inside ordinary blocks and lambdas belong to their enclosing method.
+Decisions in parameter defaults also count; coverage still measures only the body.
+Nested methods are separate entries. Their bodies and nested class/module bodies do not increase the enclosing method's score.
+Calling `each`, `map`, or another iterator does not itself add complexity.
+
+Coverage is the fraction of executable method-body lines with positive hit counts.
+Separate `def` headers are excluded: loading a definition does not prove that tests called its method.
+Null lines do not enter the denominator. Multiple suites are merged by covered-line union, without applying an age cutoff.
+Coverage paths must match absolute source paths or paths relative to the project root; unrelated checkout prefixes are not guessed.
+
+A method absent from a valid report receives 0% coverage. A body with no measurable lines receives N/A.
+Missing or malformed reports stop analysis unless `--no-coverage` is explicit.
+Reports are accepted as supplied; generate fresh coverage after changing source files.
+
+## Snapshot
+
+The table lists the highest scores first, followed by entries with unknown scores.
+The atomically replaced `.metrics/crap.edn` contains the same sorted entries, with coverage expressed as a percentage:
+
+```clojure
+{:entries [
+  {:name "charge", :namespace "Billing::Invoice", :complexity 4, :coverage 50.0, :crap 6.0}
+]}
+```
+
+Namespaces use Ruby's `::` separator. Top-level methods use `Object`.
+Instance method names are `charge`; singleton method names are `self.charge`.
+`--no-coverage` writes `nil` for both `:coverage` and `:crap`.
+
+The shape matches crapper's snapshot. This gem does not add Ruby support to crapper or its consumers.
+A filtered run writes only its selected methods. Reopened classes and repeated definitions can produce repeated namespace/name pairs.
+
+## Limits
+
+Analysis covers explicit method definitions, including private and endless methods.
+It does not execute Ruby or resolve runtime metaprogramming, `define_method`, aliases, generated accessors, or dynamic singleton receivers.
+Namespaces derived from expressions, such as `factory::Thing`, are skipped with their contents.
+Line coverage cannot distinguish expressions or methods sharing a source line, or separate evaluation of default parameters.
+Branch coverage is not used. Static namespace names do not reflect runtime constant reassignment.
+
+## Development
+
+```sh
+bundle install
+bundle exec rake
+bundle exec ruby -Ilib exe/crap4ruby --help
+```
+
+The default task runs the tests with SimpleCov, then fails if any library method's CRAP score exceeds 10.
+`bundle exec rake crap` runs the same check. `bundle exec rake test` runs only the tests and coverage collection.
+Each Rake test run discards the previous resultset so stale coverage cannot improve the score.
+Reports are written to `coverage/index.html`, `coverage/.resultset.json`, and `.metrics/crap.edn`.
+
+The suite exercises real SimpleCov output and subprocess CLI behavior, in addition to parser and scoring fixtures.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development guidance and [CHANGELOG.md](CHANGELOG.md) for changes.
+The implementation is tested on CRuby 3.3, 3.4, and 4.0. Other Ruby implementations are unverified.
+
+## Releases
+
+Signed `v*` tags trigger the release workflow. The tag must match `Crap4Ruby::VERSION`.
+Tests and the CRAP limit run before the gem is built. Publication requires approval in GitHub's `release` environment.
+RubyGems trusted publishing authenticates the workflow. Sigstore signs the built gem, and RubyGems stores its attestation.
+
+Report defects or ask questions through [GitHub issues](https://github.com/svyatov/crap4ruby/issues).
+
+## License
+
+[MIT](LICENSE), copyright Leonid Svyatov.
+
+Inspired by [crap4clj](https://github.com/unclebob/crap4clj), [crap4java](https://github.com/unclebob/crap4java), and [crap4go](https://github.com/unclebob/crap4go).

data/exe/crap4ruby

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "crap4ruby"
+
+exit Crap4Ruby::CLI.new.run(ARGV)

data/lib/crap4ruby/analyzer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Crap4Ruby
+  class Analyzer
+    def call(source, path:)
+      result = Prism.parse(source)
+      unless result.success?
+        error = result.errors.first
+        raise Error, "#{path}:#{error.location.start_line}: #{error.message}"
+      end
+      discover(result.value, [], false, path)
+    end
+
+    private
+
+    def discover(node, scope, singleton, path)
+      return [] unless node
+
+      case node
+      when Prism::ClassNode, Prism::ModuleNode
+        owner = qualify(node.constant_path, scope, declaration: true)
+        owner ? discover(node.body, owner, false, path) : []
+      when Prism::SingletonClassNode
+        owner = node.expression.is_a?(Prism::SelfNode) ? scope : qualify(node.expression, scope)
+        owner ? discover(node.body, owner, true, path) : []
+      when Prism::DefNode
+        discover_method(node, scope, singleton, path)
+      else
+        node.compact_child_nodes.flat_map { |child| discover(child, scope, singleton, path) }
+      end
+    end
+
+    def discover_method(node, scope, singleton, path)
+      owner = node.receiver && !node.receiver.is_a?(Prism::SelfNode) ? qualify(node.receiver, scope) : scope
+      return [] unless owner
+
+      name = "#{'self.' if singleton || node.receiver}#{node.name}"
+      lines = body_lines(node.body)
+      complexity = 1 + decisions(node.parameters) + decisions(node.body)
+      [MethodInfo.new(name, owner.empty? ? "Object" : owner.join("::"), complexity, lines, path)] +
+        discover(node.body, scope, singleton, path)
+    end
+
+    def qualify(node, scope, declaration: false)
+      case node
+      when Prism::ParenthesesNode
+        qualify(node.body, scope)
+      when Prism::ConstantReadNode
+        name = node.name.to_s
+        ancestor = scope.rindex(name) unless declaration
+        ancestor ? scope.take(ancestor + 1) : scope + [name]
+      when Prism::ConstantPathNode
+        (node.parent ? qualify(node.parent, scope) : [])&.+([node.name.to_s])
+      end
+    end
+
+    def decisions(node)
+      return 0 unless node
+      return 0 if boundary?(node)
+
+      decision = [:if_node, :unless_node, :while_node, :until_node, :for_node,
+        :when_node, :in_node, :rescue_node, :rescue_modifier_node, :and_node, :or_node].include?(node.type) ||
+        node.type.to_s.match?(/_(?:and|or)_write_node\z/)
+      count = decision ? 1 : 0
+      count += 1 if node.respond_to?(:safe_navigation?) && node.safe_navigation?
+      count + node.compact_child_nodes.sum { |child| decisions(child) }
+    end
+
+    def boundary?(node)
+      [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].any? { |type| node.is_a?(type) }
+    end
+
+    def body_lines(node)
+      return [] unless node
+
+      lines = (node.location.start_line..node.location.end_line).to_a
+      excluded = []
+      collect_boundaries(node, excluded)
+      lines - excluded
+    end
+
+    def collect_boundaries(node, excluded)
+      if boundary?(node)
+        excluded.concat((node.location.start_line..node.location.end_line).to_a)
+      else
+        node.compact_child_nodes.each { |child| collect_boundaries(child, excluded) }
+      end
+    end
+  end
+end

data/lib/crap4ruby/cli.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Crap4Ruby
+  class CLI
+    def initialize(stdout: $stdout, stderr: $stderr)
+      @stdout = stdout
+      @stderr = stderr
+    end
+
+    def run(arguments)
+      options, parser, paths = parse_options(arguments)
+      return @stdout.puts(parser) || 0 if options[:help]
+      return @stdout.puts(VERSION) || 0 if options[:version]
+
+      validate_options(options)
+      root = File.realpath(options[:root])
+      raise Error, "#{root}: project root must be a directory" unless File.directory?(root)
+
+      files = Discovery.call(root: root, source_roots: options[:source_roots], paths: paths, changed: options[:changed])
+      coverage = load_coverage(options, root) unless options[:no_coverage] || files.empty?
+      entries = files.flat_map do |path|
+        Analyzer.new.call(File.binread(path), path: path).map { |method| Score.call(method, coverage) }
+      end
+      entries = Report.sorted(entries)
+      path = Report.write(entries, root: root)
+      @stdout.write(Report.table(entries))
+      @stderr.puts("Wrote #{path}")
+      threshold_status(entries, options[:threshold])
+    rescue Error, OptionParser::ParseError, SystemCallError => error
+      @stderr.puts("crap4ruby: #{error.message}")
+      1
+    end
+
+    private
+
+    def parse_options(arguments)
+      options = {root: Dir.pwd, source_roots: [], changed: false, coverage: "coverage/.resultset.json"}
+      parser = OptionParser.new do |cli|
+        cli.banner = "Usage: crap4ruby [options] [file-or-directory-or-filter ...]"
+        cli.on("--root PATH", "Project root (default: current directory)") { |path| options[:root] = path }
+        cli.on("--source-root PATH", "Analyze this directory; repeat for multiple roots") { |path| options[:source_roots] << path }
+        cli.on("--changed", "Analyze Git additions and edits, including untracked files") { options[:changed] = true }
+        cli.on("--coverage PATH", "SimpleCov resultset (default: coverage/.resultset.json)") { |path| options[:coverage] = path }
+        cli.on("--no-coverage", "Complexity only; coverage and CRAP are N/A") { options[:no_coverage] = true }
+        cli.on("--use-existing-coverage", "Read reports without running tests (the default)") { options[:existing] = true }
+        cli.on("--coverage-command COMMAND", "Run a shell command that refreshes the resultset") { |command| options[:command] = command }
+        cli.on("--threshold NUMBER", "Exit 2 when CRAP exceeds this value") do |value|
+          number = Float(value)
+          raise OptionParser::InvalidArgument, "threshold must be finite and nonnegative" unless number.finite? && number >= 0
+
+          options[:threshold] = number
+        rescue ArgumentError
+          raise OptionParser::InvalidArgument, "threshold must be finite and nonnegative"
+        end
+        cli.on("-h", "--help", "Show help") { options[:help] = true }
+        cli.on("-v", "--version", "Show version") { options[:version] = true }
+      end
+      [options, parser, parser.parse(arguments)]
+    end
+
+    def validate_options(options)
+      if options[:command] && (options[:no_coverage] || options[:existing])
+        raise Error, "--coverage-command cannot be combined with --no-coverage or --use-existing-coverage"
+      end
+    end
+
+    def threshold_status(entries, threshold)
+      if threshold && entries.any? { |entry| entry.crap && entry.crap > threshold }
+        @stderr.puts("CRAP threshold exceeded: #{threshold}")
+        2
+      else
+        0
+      end
+    end
+
+    def load_coverage(options, root)
+      report = File.expand_path(options[:coverage], root)
+      run_coverage(options[:command], root, report) if options[:command]
+      Coverage.load(report, root: root)
+    end
+
+    def run_coverage(command, root, report)
+      raise Error, "--coverage-command must not be empty" if command.strip.empty?
+
+      before = report_stamp(report)
+      status = Open3.popen2e("sh", "-c", command, chdir: root) do |input, output, process|
+        input.close
+        output.each_line { |line| @stderr.write(line) }
+        process.value
+      end
+      raise Error, "coverage command failed (exit #{status.exitstatus || "signal #{status.termsig}"})" unless status.success?
+      raise Error, "coverage command did not refresh #{report}" if report_stamp(report) == before
+    end
+
+    def report_stamp(path)
+      stat = File.stat(path)
+      [stat.ino, stat.mtime, stat.ctime, stat.size]
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+end

data/lib/crap4ruby/coverage.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Crap4Ruby
+  class Coverage
+    def self.load(path, root:)
+      new(JSON.parse(File.read(path)), root: root)
+    rescue SystemCallError => error
+      raise Error, "#{path}: cannot read coverage report; generate SimpleCov coverage or use --no-coverage (#{error.message})"
+    rescue JSON::ParserError, Error => error
+      raise Error, "#{path}: invalid SimpleCov report (#{error.message})"
+    end
+
+    def initialize(suites, root:)
+      raise Error, "expected named test suites" unless suites.is_a?(Hash) && !suites.empty?
+
+      @files = {}
+      suites.each_value { |suite| add_suite(suite, root) }
+    end
+
+    def fraction(method)
+      path = File.expand_path(method.path)
+      path = File.realpath(path) if File.exist?(path)
+      lines = @files[path]
+      return 0.0 unless lines
+
+      hits = method.lines.filter_map { |line| lines[line - 1] }
+      return nil if hits.empty?
+
+      hits.count(&:positive?).fdiv(hits.size)
+    end
+
+    private
+
+    def add_suite(suite, root)
+      unless suite.is_a?(Hash) && suite["coverage"].is_a?(Hash)
+        raise Error, "expected a coverage object for each suite"
+      end
+      suite["coverage"].each { |path, data| add_file(path, data, root) }
+    end
+
+    def add_file(path, data, root)
+      key = File.expand_path(path, root)
+      key = File.realpath(key) if File.exist?(key)
+      lines = data.is_a?(Hash) ? data["lines"] : data
+      unless lines.is_a?(Array) && lines.all? { |hit| hit.nil? || (hit.is_a?(Integer) && hit >= 0) }
+        raise Error, "#{path}: expected nonnegative line counts or null"
+      end
+      previous = @files[key] || []
+      @files[key] = Array.new([previous.size, lines.size].max) do |index|
+        [previous[index], lines[index]].compact.max
+      end
+    end
+  end
+end

data/lib/crap4ruby/discovery.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "find"
+require "open3"
+
+module Crap4Ruby
+  module Discovery
+    EXCLUDED = %w[test tests spec features vendor node_modules target coverage tmp log pkg build dist].freeze
+
+    def self.call(root:, source_roots:, paths:, changed:)
+      existing, filters = paths.partition { |path| File.exist?(File.expand_path(path, root)) }
+      roots = source_roots.map do |path|
+        directory = File.expand_path(path, root)
+        raise Error, "#{path}: source root must be a directory" unless File.directory?(directory)
+
+        directory
+      end
+      roots.concat(existing.map { |path| File.expand_path(path, root) })
+      roots << root if roots.empty?
+      files = roots.flat_map { |path| File.file?(path) ? [path] : walk(path) }
+      files = files.select { |path| File.extname(path) == ".rb" }.map { |path| File.realpath(path) }.uniq.sort
+      files.select! { |path| filters.any? { |filter| path.delete_prefix("#{root}/").include?(filter) } } unless filters.empty?
+      files &= changed_files(root) if changed
+      files
+    end
+
+    def self.walk(root)
+      paths = []
+      Find.find(root) do |path|
+        name = File.basename(path)
+        if File.directory?(path)
+          Find.prune if path != root && (name.start_with?(".") || EXCLUDED.include?(name) || File.symlink?(path))
+        elsif !File.symlink?(path) && !name.start_with?(".") && !name.match?(/\A(?:test|spec)_|_(?:test|spec)\.rb\z/)
+          paths << path
+        end
+      end
+      paths
+    end
+
+    def self.git(root, *arguments)
+      output, error, status = Open3.capture3("git", "-C", root, *arguments)
+      raise Error, "git: #{error.strip}" unless status.success?
+
+      output
+    end
+
+    def self.changed_files(root)
+      top = git(root, "rev-parse", "--show-toplevel").chomp
+      git(root, "status", "--porcelain=v1", "-z", "--no-renames", "--untracked-files=all", "--", ".")
+        .split("\0").filter_map do |entry|
+          path = File.join(top, entry[3..])
+          File.realpath(path) if File.file?(path)
+        end
+    end
+  end
+end

data/lib/crap4ruby/report.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tempfile"
+
+module Crap4Ruby
+  module Report
+    def self.sorted(entries)
+      entries.sort_by { |entry| [entry.crap ? 0 : 1, -(entry.crap || 0), entry.namespace, entry.name, entry.path] }
+    end
+
+    def self.table(entries)
+      rows = [["Function", "Namespace", "CC", "Cov%", "CRAP"]] + entries.map do |entry|
+        [entry.name, entry.namespace, entry.complexity.to_s,
+          entry.coverage ? format("%.1f%%", entry.coverage) : "N/A",
+          entry.crap ? format("%.1f", entry.crap) : "N/A"]
+      end
+      widths = rows.transpose.map { |column| column.map(&:length).max }
+      lines = rows.map do |row|
+        row.each_with_index.map { |value, index| index < 2 ? value.ljust(widths[index]) : value.rjust(widths[index]) }.join("  ")
+      end
+      lines.insert(1, "-" * lines.first.length)
+      (["CRAP Report", "==========="] + lines).join("\n") + "\n"
+    end
+
+    def self.edn(entries)
+      rows = entries.map do |entry|
+        "  {:name #{JSON.generate(entry.name)}, :namespace #{JSON.generate(entry.namespace)}, " \
+          ":complexity #{entry.complexity}, :coverage #{number(entry.coverage)}, :crap #{number(entry.crap)}}"
+      end
+      rows.empty? ? "{:entries []}\n" : "{:entries [\n#{rows.join("\n")}\n]}\n"
+    end
+
+    def self.number(value)
+      return "nil" if value.nil?
+
+      text = format("%.4f", value).sub(/0+\z/, "")
+      text.end_with?(".") ? "#{text}0" : text
+    end
+
+    def self.write(entries, root:)
+      directory = File.join(root, ".metrics")
+      FileUtils.mkdir_p(directory)
+      path = File.join(directory, "crap.edn")
+      Tempfile.create(["crap", ".edn"], directory) do |file|
+        file.write(edn(entries))
+        file.close
+        File.rename(file.path, path)
+      end
+      path
+    end
+  end
+end

data/lib/crap4ruby/score.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crap4Ruby
+  module Score
+    def self.call(method, coverage)
+      fraction = coverage&.fraction(method)
+      crap = method.complexity**2 * (1 - fraction)**3 + method.complexity if fraction
+      Entry.new(method.name, method.namespace, method.complexity, fraction && fraction * 100, crap, method.path)
+    end
+  end
+end

data/lib/crap4ruby/version.rb

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

data/lib/crap4ruby.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "crap4ruby/version"
+
+module Crap4Ruby
+  Error = Class.new(StandardError)
+  MethodInfo = Data.define(:name, :namespace, :complexity, :lines, :path)
+  Entry = Data.define(:name, :namespace, :complexity, :coverage, :crap, :path)
+end
+
+require_relative "crap4ruby/analyzer"
+require_relative "crap4ruby/coverage"
+require_relative "crap4ruby/score"
+require_relative "crap4ruby/report"
+require_relative "crap4ruby/discovery"
+require_relative "crap4ruby/cli"

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: crap4ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Leonid Svyatov
+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: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Static Ruby method complexity and test coverage combined into CRAP scores
+  and crapper-compatible snapshots.
+executables:
+- crap4ruby
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
+- README.md
+- exe/crap4ruby
+- lib/crap4ruby.rb
+- lib/crap4ruby/analyzer.rb
+- lib/crap4ruby/cli.rb
+- lib/crap4ruby/coverage.rb
+- lib/crap4ruby/discovery.rb
+- lib/crap4ruby/report.rb
+- lib/crap4ruby/score.rb
+- lib/crap4ruby/version.rb
+homepage: https://github.com/svyatov/crap4ruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/svyatov/crap4ruby
+  bug_tracker_uri: https://github.com/svyatov/crap4ruby/issues
+  changelog_uri: https://github.com/svyatov/crap4ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: CRAP scores for Ruby methods using Prism and SimpleCov reports
+test_files: []