minitest-subjective 0.1.0.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f5760ba45aa4159efb193a53b8c0a2da6d983881793d60d64a9c0dd25b55a40e
+  data.tar.gz: 3b0fa96c440e22577be2321a9ee6c4ec46d69de0d3bb989e3ca0e104bcfda6c8
+SHA512:
+  metadata.gz: d826c7e3dd1687ff376c8fa29c9ac00e2ede3c11aa8e364219fe79ca9bbedce0e636a53c986e502e76a6756bba4eb3c78375692fd839d0d64976c4173a325b58
+  data.tar.gz: 71a008c282cac260f3f70bf981e970040b8d6860c26a8a0f38df07be5aa90e76f52f643d3a63d1a18b2bada19da76f585fc69782fbccd04557eda02e231b5676

data/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

data/.idea/minitest-subjective.iml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="ModuleRunConfigurationManager">
+    <shared />
+  </component>
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/features" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/spec" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
+    </content>
+    <orderEntry type="jdk" jdkName="rbenv: 4.0.2" jdkType="RUBY_SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="PROVIDED" name="ast (v2.4.3, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="bundler (v4.0.9, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="date (v3.5.1, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="drb (v2.2.3, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="erb (v6.0.4, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="io-console (v0.8.2, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="irb (v1.18.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="json (v2.19.4, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="language_server-protocol (v3.17.0.5, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="lint_roller (v1.1.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="minitest (v6.0.5, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="minitest-mock (v5.27.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="parallel (v2.1.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="parser (v3.3.11.1, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="pp (v0.6.3, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="prettyprint (v0.2.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="prism (v1.9.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="psych (v5.3.1, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="racc (v1.8.1, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rainbow (v3.1.1, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rake (v13.4.2, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rdoc (v7.2.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="regexp_parser (v2.12.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="reline (v0.6.3, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rubocop (v1.86.1, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rubocop-ast (v1.49.1, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rubocop-minitest (v0.39.1, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rubocop-performance (v1.26.1, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rubocop-rake (v0.7.1, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="ruby-progressbar (v1.13.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="stringio (v3.2.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="tsort (v0.2.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="unicode-display_width (v3.2.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="unicode-emoji (v4.2.0, rbenv: 4.0.2) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="zeitwerk (v2.7.5, rbenv: 4.0.2) [gem]" level="application" />
+  </component>
+</module>

data/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="rbenv: 3.3.1" project-jdk-type="RUBY_SDK" />
+</project>

data/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/minitest-subjective.iml" filepath="$PROJECT_DIR$/.idea/minitest-subjective.iml" />
+    </modules>
+  </component>
+</project>

data/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

data/.rubocop.yml

@@ -0,0 +1,7 @@
+plugins:
+  - rubocop-performance
+  - rubocop-minitest
+  - rubocop-rake
+
+AllCops:
+  NewCops: enable

data/.ruby-version

@@ -0,0 +1 @@
+4.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Justin Malčić
+
+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,71 @@
+# Minitest Subjective
+
+Is your testing [sociable](https://martinfowler.com/bliki/UnitTest.html#SolitaryOrSociable)?
+If so, test coverage you collect when running all your tests together will be artifically inflated.
+That's because coverage only reflects the fact that _something, somewhere_ touched the covered code,
+not necessarily your well-designed test for that specific method, alas.
+What would be great is a kind of coverage sensitive to the current test _subject_ as it changes while running tests.
+
+This has been [discussed before](https://www.rubyevents.org/talks/improving-coverage-analysis) by Ryan Davis,
+author of Minitest, and you should totally watch his talk to understand why this matters, and why he created
+[`minitest-coverage`](https://github.com/minitest/minitest-coverage). That was a while ago, and Ruby now has
+more coverage modes (e.g. branch coverage, very useful). This gem takes a different approach to the problem, which also
+avoids needing any changes to the coverage API.
+
+The premise is straightforward: where $c_0$ is the coverage after first loading a file (before running any tests),
+$c_1$ is the coverage just before running tests _for that file in particular_,
+and $c_2$ is the coverage after running the last test for that file,
+coverage for that file can be expressed as:
+$$c_0 + (c_2 - c_1)$$
+This gem just implements addition and subtraction for the different kinds of coverage in coverage results,
+plus a basic formatter so you can see the results.
+It works with parallel testing, and isn't thread-safe because coverage can't be run per-thread anyway.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add minitest-subjective
+```
+
+## Usage
+
+Simply run your tests with the `--subjective` flag.
+
+```bash
+minitest --subjective
+```
+
+Works with Rails too.
+
+```bash
+rails t --subjective
+```
+
+If you can't easily pass the flag, you can set `MINITEST_SUBJECTIVE=1` instead.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`,
+which will create a git tag for the version, push git commits and the created tag,
+and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jmalcic/minitest-subjective.
+This project is intended to be a safe, welcoming space for collaboration,
+and contributors are expected to adhere to the [Ruby code of conduct](https://www.ruby-lang.org/en/conduct/).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Minitest::Subjective project's codebases, issue trackers, chat rooms and mailing lists
+is expected to follow the [code of conduct](https://www.ruby-lang.org/en/conduct/).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'minitest/test_task'
+
+Minitest::TestTask.create
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/minitest/subjective/case_inquirer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    class CaseInquirer # :nodoc:
+      attr_reader :class_name, :subject_file
+
+      def initialize(klass)
+        @class_name = klass.is_a?(String) ? klass : klass.name
+        @klass = klass.is_a?(String) ? safe_constantize(klass) : klass
+        load_subject
+        @subject_file = Object.const_source_location(subject_name)&.first
+      end
+
+      def subject_name
+        return class_name unless test?
+        return [class_name_nesting, demodulized_class_name.delete_suffix('Test')].join('::') if rails_test?
+
+        [class_name_nesting, demodulized_class_name.delete_prefix('Test')].join('::')
+      end
+
+      def test? = rails_test? || minitest_test?
+
+      def minitest_test?
+        demodulized_class_name.start_with?('Test') && klass < Minitest::Test
+      end
+
+      def rails_test?
+        demodulized_class_name.end_with?('Test') && defined?(::ActiveSupport) && klass < ActiveSupport::TestCase
+      end
+
+      def integration_test? = rails_test? && defined?(::ActionDispatch) && klass < ActionDispatch::IntegrationTest
+      def ==(other) = class_name == other.class_name && klass == other.klass && subject_file == other.subject_file
+
+      protected
+
+      attr_reader :klass
+
+      private
+
+      def load_subject = safe_constantize(subject_name)
+
+      def class_name_nesting
+        class_name.split('::')[0..-2].join('::')
+      end
+
+      def demodulized_class_name
+        class_name.split('::').last
+      end
+
+      def safe_constantize(name)
+        Object.const_get(name)
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/branch_statistics/branch_hits.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    class FileResult
+      class BranchStatistics
+        BranchHits = Struct.new(:label, :id, :range, :hits) do
+          extend Forwardable
+
+          def_delegators :range, :starts_at?, :ends_at?, :cover?
+
+          def self.from_pair(key, hits)
+            label, id, *range = key
+            new(label:, id:, range: Range.from_array(range), hits:)
+          end
+
+          def +(other)
+            return self unless matches?(other)
+
+            self.class.new(label, id, range, hits + other.hits)
+          end
+
+          def -(other)
+            return self unless matches?(other)
+
+            self.class.new(label, id, range, hits - other.hits)
+          end
+
+          def covered?
+            hits.positive?
+          end
+
+          private
+
+          def matches?(other)
+            other && other.label == label && other.id == id && other.range == range
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/branch_statistics/conditional_hits.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    class FileResult
+      class BranchStatistics
+        ConditionalHits = Struct.new(:label, :id, :range, :branches) do
+          extend Forwardable
+
+          def_delegators :range, :starts_at?, :ends_at?, :cover?
+
+          def self.from_pair(key, branches)
+            label, id, *range = key
+            new(label:, id:, range: Range.from_array(range), branches: branches.collect { BranchHits.from_pair(*_1) })
+          end
+
+          def +(other)
+            return self unless matches?(other)
+
+            self.class.new(label, id, range, branches.zip(other.branches).collect { |current, new| current + new })
+          end
+
+          def -(other)
+            return self unless matches?(other)
+
+            self.class.new(label, id, range, branches.zip(other.branches).collect { |current, new| current - new })
+          end
+
+          def covered?
+            branches.all?(&:covered?)
+          end
+
+          private
+
+          def matches?(other)
+            other && other.label == label && other.id == id && other.range == range
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/branch_statistics/formatting.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    class FileResult
+      class BranchStatistics
+        module Formatting # :nodoc:
+          def format(formatter, line, line_number)
+            return unless conditionals_for_line(line_number).any?
+
+            line.each_char
+                .flat_map
+                .with_index { |character, column| format_character(formatter, character, line_number, column) }
+                .join
+          end
+
+          private
+
+          def format_character(formatter, character, line_number, column)
+            [*format_conditionals_starting_at_position(formatter, line_number, column),
+             *format_branches_starting_at_position(formatter, line_number, column),
+             character,
+             *format_branches_ending_at_position(formatter, line_number, column),
+             *format_conditionals_ending_at_position(formatter, line_number, column)]
+          end
+
+          def format_conditionals_starting_at_position(formatter, line_number, column)
+            conditionals_starting_at_position(line_number, column).collect do |conditional|
+              [formatter.colors.format(:gray) { '[' },
+               formatter.colors.format(:gray) { conditional.label },
+               ' '].join
+            end
+          end
+
+          def format_branches_starting_at_position(formatter, line_number, column)
+            branches_starting_at_position(line_number, column).collect { formatter.colors.format(:gray) { '[' } }
+          end
+
+          def format_conditionals_ending_at_position(formatter, line_number, column)
+            conditionals_ending_at_position(line_number, column + 1).collect { formatter.colors.format(:gray) { ']' } }
+          end
+
+          def format_branches_ending_at_position(formatter, line_number, column)
+            branches_ending_at_position(line_number, column + 1).collect do |branch|
+              [' ', framed_hits(formatter, branch), formatter.colors.format(:gray) { ']' }].join
+            end
+          end
+
+          def framed_hits(formatter, branch)
+            formatter.colors.format(hits: branch.hits) do
+              formatter.colors.format(:framed) do
+                "#{branch.label} #{hit_count(branch)}"
+              end
+            end
+          end
+
+          def conditionals_for_line(line_number)
+            @branches.filter { _1.cover?(line_number) }
+          end
+
+          def conditionals_starting_at_position(line_number, column)
+            @branches.filter { _1.starts_at?(line_number, column) }
+          end
+
+          def conditionals_ending_at_position(line_number, column)
+            @branches.filter { _1.ends_at?(line_number, column) }
+          end
+
+          def branches_starting_at_position(line_number, column)
+            @branches.flat_map(&:branches).filter { _1.starts_at?(line_number, column) }
+          end
+
+          def branches_ending_at_position(line_number, column)
+            @branches.flat_map(&:branches).filter { _1.ends_at?(line_number, column) }
+          end
+
+          def hit_count(branch)
+            "(#{branch.hits} hit#{'s' unless branch.hits == 1})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/branch_statistics.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'minitest/subjective/file_result/range'
+require 'minitest/subjective/file_result/branch_statistics/formatting'
+require 'minitest/subjective/file_result/branch_statistics/branch_hits'
+require 'minitest/subjective/file_result/branch_statistics/conditional_hits'
+
+module Minitest
+  module Subjective
+    class FileResult
+      class BranchStatistics # :nodoc:
+        include Formatting
+
+        attr_accessor :branches
+
+        def self.from_hash(branches)
+          new(branches.collect { |key, value| ConditionalHits.from_pair(key, value) })
+        end
+
+        def initialize(branches)
+          @branches = branches
+        end
+
+        def +(other)
+          return self unless other
+
+          self.class.new(branches.zip(other.branches).collect { |current, new| current + new })
+        end
+
+        def -(other)
+          return self unless other
+
+          self.class.new(branches.zip(other.branches).collect { |current, new| current - new })
+        end
+
+        def [](index)
+          branches.filter { _1.cover?(index) }
+        end
+
+        def filter(&)
+          self.class.new(branches.filter(&))
+        end
+
+        def covered?
+          branches.all?(&:covered?)
+        end
+
+        def ==(other)
+          other && branches == other.branches
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/line_statistics/formatting.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    class FileResult
+      class LineStatistics
+        module Formatting # :nodoc:
+          def format(formatter, lines)
+            lines.collect.with_index do |line, line_number|
+              [line_number(formatter, line_number),
+               hit_count(formatter, line_number + 1),
+               yield(line, line_number + 1)].join(' ')
+            end
+          end
+
+          private
+
+          def line_number(formatter, line_number)
+            formatter.colors.format :gray do
+              line_number.next.to_s.rjust(count.to_s.length)
+            end
+          end
+
+          def hit_count(formatter, line_number)
+            formatter.colors.format hits: self[line_number]&.hits do
+              self[line_number]&.then { "(#{_1.hits} hit#{'s' unless _1.hits == 1})" }
+                               .to_s
+                               .rjust(max_hits.to_s.length + 7)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/line_statistics/line_hits.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    class FileResult
+      class LineStatistics
+        LineHits = Struct.new(:line, :hits, :branches) do
+          def self.from_pair(line, hits, branches: nil)
+            new(line:, hits:, branches:)
+          end
+
+          def +(other)
+            return self unless other && other.line == line
+
+            self.class.new(line, hits + other.hits, branches && (branches + other.branches))
+          end
+
+          def -(other)
+            return self unless other && other.line == line
+
+            self.class.new(line, hits - other.hits, branches && (branches - other.branches))
+          end
+
+          def covered?
+            hits.positive? && (branches.nil? || branches.covered?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/line_statistics.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'minitest/subjective/file_result/line_statistics/line_hits'
+require 'minitest/subjective/file_result/line_statistics/formatting'
+
+module Minitest
+  module Subjective
+    class FileResult
+      class LineStatistics # :nodoc:
+        include Formatting
+
+        extend Forwardable
+
+        attr_accessor :lines
+
+        def_delegators :lines, :[], :each, :count, :compact
+
+        def self.from_hash(lines, branches:)
+          new(lines.filter_map.with_index { |value, key| value && LineHits.from_pair(key + 1, value, branches:) })
+        end
+
+        def initialize(lines = [])
+          @lines = lines.to_h { [_1.line, _1] }
+        end
+
+        def +(other)
+          return self unless other
+
+          self.class.new(lines.values.zip(other.lines.values).collect { |current, new| current + new })
+        end
+
+        def -(other)
+          return self unless other
+
+          self.class.new(lines.values.zip(other.lines.values).collect { |current, new| current - new })
+        end
+
+        def max_hits
+          lines.values.collect(&:hits).max
+        end
+
+        def covered?
+          lines.values.all?(&:covered?)
+        end
+
+        def ==(other)
+          other && lines == other.lines && branches == other.branches
+        end
+
+        protected
+
+        attr_reader :branches
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/location.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    class FileResult
+      Location = Struct.new(:line, :column) do
+        def self.from_array(args)
+          new(line: args[0], column: args[1])
+        end
+
+        def to_s
+          [line, column].join(':')
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/method_statistics/formatting.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    class FileResult
+      class MethodStatistics
+        module Formatting # :nodoc:
+          def format(formatter, line, line_number, &)
+            [hit_count(formatter, line_number), branches_or_line(line, line_number, &)].join(' ')
+          end
+
+          private
+
+          def branches_or_line(line, line_number, &)
+            self[line_number]&.then { _1.branches.branches.any? ? yield(_1.branches) : line } || line
+          end
+
+          def hit_count(formatter, line_number)
+            formatter.colors.format hits: find_by_index(line_number)&.hits do
+              find_by_index(line_number)&.then { "(#{_1.hits} hit#{'s' unless _1.hits == 1})" }
+                                        .to_s
+                                        .rjust(max_hits.to_s.length + 7)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/method_statistics/method_hits.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    class FileResult
+      class MethodStatistics
+        MethodHits = Struct.new(:klass, :name, :range, :hits, :branches) do
+          extend Forwardable
+
+          def_delegators :range, :cover?, :starts_at?, :ends_at?
+
+          def self.from_pair(key, hits, branches: [])
+            klass, name, *range = key
+            range = Range.from_array(range)
+            new(klass: klass.name, name:, range:, hits:, branches: branches.filter { range.cover?(_1.range) })
+          end
+
+          def +(other)
+            return self unless other
+
+            self.class.new(klass, name, range, hits + other.hits, branches && (branches + other.branches))
+          end
+
+          def -(other)
+            return self unless other
+
+            self.class.new(klass, name, range, hits - other.hits, branches && (branches - other.branches))
+          end
+
+          def covered?
+            hits.positive? && (branches.nil? || branches.covered?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/method_statistics.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'minitest/subjective/file_result/method_statistics/method_hits'
+require 'minitest/subjective/file_result/range'
+require 'minitest/subjective/file_result/method_statistics/formatting'
+
+module Minitest
+  module Subjective
+    class FileResult
+      class MethodStatistics # :nodoc:
+        include Formatting
+
+        attr_reader :method_hits
+
+        def self.from_hash(methods, branches:)
+          new(methods.collect { |key, value| MethodHits.from_pair(key, value, branches:) })
+        end
+
+        def initialize(methods)
+          @method_hits = methods
+        end
+
+        def +(other)
+          return self unless other
+
+          self.class.new(method_hits.zip(other.method_hits).collect { |current, new| current + new })
+        end
+
+        def -(other)
+          return self unless other
+
+          self.class.new(method_hits.zip(other.method_hits).collect { |current, new| current - new })
+        end
+
+        def find_by(**options)
+          method_hits.find { |method| options.all? { |key, value| method.send(key) == value } }
+        end
+
+        def max_hits
+          method_hits.collect(&:hits).max
+        end
+
+        def [](index)
+          method_hits.find { _1.cover?(index) } if index
+        end
+
+        def find_by_index(index)
+          method_hits.find { _1.starts_at?(index) } if index
+        end
+
+        def covered?
+          method_hits.all?(&:covered?)
+        end
+
+        def ==(other)
+          other && method_hits == other.method_hits && branches == other.branches
+        end
+
+        protected
+
+        attr_reader :branches
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result/range.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'minitest/subjective/file_result/location'
+
+module Minitest
+  module Subjective
+    class FileResult
+      Range = Struct.new(:start, :end) do
+        def self.from_array(args)
+          new(start: Location.from_array(args[0..1]), end: Location.from_array(args[2..3]))
+        end
+
+        def starts_at?(line, column = nil)
+          column ? start == Location.new(line, column) : start.line == line
+        end
+
+        def ends_at?(line, column = nil)
+          column ? self.end == Location.new(line, column) : self.end.line == line
+        end
+
+        def cover?(line_or_range, column_or_start_column = nil, end_column = nil)
+          (covers_line?(line_or_range) && !column_or_start_column) || covers_column?(line_or_range,
+                                                                                     column_or_start_column, end_column)
+        end
+
+        def to_s
+          if single_line?
+            [start.line, [start.column, self.end.column].join('-')].join(':')
+          else
+            [start.to_s, self.end.to_s].join('-')
+          end
+        end
+
+        private
+
+        def covers_column?(line_or_range, column_or_start_column, _end_column = nil)
+          return single_line_covers_column?(column_or_start_column) if single_line?
+
+          multiple_lines_covers_column?(line_or_range, column_or_start_column, nil)
+        end
+
+        def single_line_covers_column?(column)
+          (start.column..self.end.column).cover?(column)
+        end
+
+        def multiple_lines_covers_column?(line_or_range, column_or_start_column, end_column = nil)
+          case line_or_range
+          when start.line then (start.column..).cover?(column_or_start_column)
+          when start.line.next...self.end.line then true
+          when self.end.line then (1..self.end.column).cover?(end_column)
+          else false
+          end
+        end
+
+        def covers_line?(line_or_range)
+          case line_or_range
+          when Range then (start.line..self.end.line).cover?(line_or_range.start.line..line_or_range.end.line)
+          else (start.line..self.end.line).cover?(line_or_range)
+          end
+        end
+
+        def single_line?
+          start.line == self.end.line
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/file_result.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'minitest/subjective/file_result/branch_statistics'
+require 'minitest/subjective/file_result/line_statistics'
+require 'minitest/subjective/file_result/method_statistics'
+require 'minitest/subjective/formatter'
+
+module Minitest
+  module Subjective
+    class FileResult # :nodoc:
+      attr_reader :path, :line_statistics, :method_statistics
+
+      def self.from_result(path, modes)
+        BranchStatistics.from_hash(modes[:branches].to_h).then do |branches|
+          new(path, line_statistics: LineStatistics.from_hash(modes[:lines].to_a, branches:),
+                    method_statistics: MethodStatistics.from_hash(modes[:methods].to_h, branches:))
+        end
+      end
+
+      def initialize(path, line_statistics:, method_statistics: nil)
+        @path = path
+        @line_statistics = line_statistics
+        @method_statistics = method_statistics
+      end
+
+      def +(other)
+        return self unless other
+
+        self.class.new(@path, line_statistics: other ? line_statistics + other.line_statistics : line_statistics,
+                              method_statistics:
+                                other ? method_statistics + other.method_statistics : method_statistics)
+      end
+
+      def -(other)
+        return self unless other
+
+        self.class.new(@path, line_statistics: other ? line_statistics - other.line_statistics : line_statistics,
+                              method_statistics:
+                                other ? method_statistics - other.method_statistics : method_statistics)
+      end
+
+      def blank?
+        line_statistics.nil?
+      end
+
+      def to_s = Formatter.new(self).render
+
+      def covered?
+        line_statistics.covered? && method_statistics.covered?
+      end
+
+      def ==(other)
+        other && line_statistics == other.line_statistics && method_statistics == other.method_statistics
+      end
+    end
+  end
+end

data/lib/minitest/subjective/formatter/colors.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    class Formatter
+      class Colors # :nodoc:
+        CSI = "\033["
+        FINAL_BYTE = 'm'
+        CODES = {
+          clear: 0,
+          gray: 90,
+          white: 37,
+          green: 32,
+          red: 31,
+          underline: 4,
+          strikethrough: 9,
+          framed: 51,
+          encircled: 52
+        }.freeze
+        SEPARATOR = ';'
+
+        def initialize
+          @stack = []
+        end
+
+        def format(color = nil, hits: false)
+          [public_send(color_for_hits(hits) || color || :transparent), yield, clear].join
+        end
+
+        def color_for_hits(count)
+          unstash
+
+          case count
+          when nil then :gray
+          when 0 then :red
+          when (1..) then :green
+          end
+        end
+
+        def gray = push :gray
+        def green = push :green
+        def red = push :red
+        def framed = push :framed
+        def encircled = push :encircled
+        def white = push :white
+        def transparent = push :clear
+
+        def clear = pop && (current || sequence(:clear))
+        def clear_all = stash && sequence(:clear)
+
+        private
+
+        def current = @stack.last
+        def push(key) = @stack.push(sequence(key)) && current
+        def pop = @stack.pop
+        def stash = @stash = @stack.dup.tap { @stack.clear }
+        def sequence(*keys) = [CSI, CODES.values_at(*keys).join(SEPARATOR), FINAL_BYTE].join
+        def unstash = @stash&.any? && @stack = @stash.dup.tap { @stash.clear }
+      end
+    end
+  end
+end

data/lib/minitest/subjective/formatter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'minitest/subjective/formatter/colors'
+
+module Minitest
+  module Subjective
+    class Formatter # :nodoc:
+      attr_reader :colors
+
+      def initialize(result)
+        @result = result
+        @colors = Colors.new
+      end
+
+      def render
+        formatted_lines.join("\n")
+      end
+
+      private
+
+      attr_reader :result
+
+      def lines = File.readlines(result.path, chomp: true)
+
+      def formatted_lines
+        result.line_statistics.format(self, lines) do |line, number|
+          result.method_statistics.format(self, line, number) do |branch_statistics|
+            branch_statistics.format(self, line, number)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/reporter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'minitest/subjective/case_inquirer'
+
+module Minitest
+  module Subjective
+    class Reporter < Minitest::Reporter # :nodoc:
+      attr_accessor :results
+
+      def initialize(io = $stdout, options = {})
+        super
+        self.results = {}
+      end
+
+      def record(result)
+        merge_result(result)
+      end
+
+      def report
+        results.each do |subject_name, result|
+          io.puts "Coverage for #{subject_name}:"
+          io.puts coverage_headline_for(result)
+          io.puts result.to_s unless result.covered?
+        end
+      end
+
+      private
+
+      def coverage_headline_for(result)
+        colors.format result.covered? ? :green : :red do
+          result.covered? ? 'All covered!' : 'Coverage missing!'
+        end
+      end
+
+      def colors
+        @colors ||= Formatter::Colors.new
+      end
+
+      def merge_result(result)
+        with_subject_name_for(result) do |subject_name|
+          results[subject_name] ||= Subjective.load_results[subject_name] || result.load_result
+          results[subject_name] = if results[subject_name]
+                                    results[subject_name] + result.coverage_result
+                                  else
+                                    result.coverage_result
+                                  end
+        end
+      end
+
+      def with_subject_name_for(result)
+        CaseInquirer.new(result.klass).tap do |inquirer|
+          next unless inquirer.subject_file
+
+          yield inquirer.subject_name
+        end
+      end
+    end
+  end
+end

data/lib/minitest/subjective/result_extensions.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    module ResultExtensions # :nodoc: all
+      module ClassMethods
+        def from(runnable)
+          super.tap do |output|
+            output.load_result = Subjective.load_result_for(runnable.class)
+            output.coverage_result = Subjective.coverage_for(runnable.class)
+          end
+        end
+      end
+
+      attr_accessor :load_result, :coverage_result
+
+      def self.prepended(other)
+        other.singleton_class.prepend ClassMethods
+      end
+
+      def self.prepend_target
+        Result.prepend self
+      end
+    end
+  end
+end

data/lib/minitest/subjective/test_extensions.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    module TestExtensions # :nodoc:
+      def self.prepend_target
+        Test.prepend self
+      end
+
+      def run(*)
+        Subjective.record_load_for(self.class)
+        Subjective.record_baseline_for(self.class)
+        super
+      end
+    end
+  end
+end

data/lib/minitest/subjective/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Subjective
+    VERSION = '0.1.0-alpha'
+  end
+end

data/lib/minitest/subjective.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'subjective/version'
+require 'coverage'
+require 'forwardable'
+require 'minitest'
+require 'minitest/subjective/file_result'
+require 'minitest/subjective_plugin'
+
+module Minitest # :nodoc:
+  # = \Subjective
+  module Subjective
+    class << self
+      private
+
+      def coverage
+        Coverage
+      end
+
+      def file_result_for(path)
+        FileResult.from_result(path, coverage.peek_result[path].to_h)
+      end
+    end
+
+    def self.cattr_accessor(name) # :nodoc:
+      (class << self; self; end).attr_accessor name
+    end
+
+    cattr_accessor :load_results
+    cattr_accessor :baselines
+    @load_results = {}
+    @baselines = {}
+
+    def self.start_coverage
+      coverage.start(:all) unless coverage.running?
+    end
+
+    def self.record_autoload_for(klass, path = nil)
+      load_results[klass] ||= file_result_for(path)
+    end
+
+    def self.record_load_for(klass, _path = nil)
+      CaseInquirer.new(klass).tap do |inquirer|
+        load_results[inquirer.subject_name] ||= file_result_for(inquirer.subject_file)
+      end
+    end
+
+    def self.record_baseline_for(klass)
+      CaseInquirer.new(klass).tap do |inquirer|
+        baselines[inquirer.subject_name] = file_result_for(inquirer.subject_file)
+      end
+    end
+
+    def self.load_result_for(klass)
+      CaseInquirer.new(klass).then do |inquirer|
+        load_results[inquirer.subject_name]
+      end
+    end
+
+    def self.coverage_for(klass)
+      CaseInquirer.new(klass).then do |inquirer|
+        next unless coverage.running?
+
+        file_result_for(inquirer.subject_file) - baselines[inquirer.subject_name]
+      end
+    end
+  end
+
+  load :subjective if respond_to?(:load)
+end

data/lib/minitest/subjective_plugin.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'minitest/subjective/reporter'
+require 'minitest/subjective/result_extensions'
+require 'minitest/subjective/test_extensions'
+
+module Minitest # :nodoc:
+  class << self
+    private
+
+    def add_zeitwerk_hooks
+      return unless defined? ::Zeitwerk
+
+      ::Zeitwerk::Registry.loaders.each do |loader|
+        loader.on_load do |cpath, _value, abspath|
+          Subjective.record_autoload_for(cpath, abspath)
+        end
+      end
+    end
+  end
+
+  def self.plugin_subjective_options(opts, options)
+    opts.on '--subjective', 'Collect focused coverage for the test subjects.' do
+      options[:subjective] ||= {}
+    end
+  end
+
+  def self.plugin_subjective_init(options)
+    return unless options[:subjective] || ENV['MINITEST_SUBJECTIVE']
+
+    add_zeitwerk_hooks
+    Subjective.start_coverage
+    Subjective::ResultExtensions.prepend_target
+    Subjective::TestExtensions.prepend_target
+    reporter << Subjective::Reporter.new
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: minitest-subjective
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.alpha
+platform: ruby
+authors:
+- Justin Malčić
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Test coverage with live awareness of what you're actually trying to test.
+email:
+- j.malcic@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".idea/.gitignore"
+- ".idea/minitest-subjective.iml"
+- ".idea/misc.xml"
+- ".idea/modules.xml"
+- ".idea/vcs.xml"
+- ".rubocop.yml"
+- ".ruby-version"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/minitest/subjective.rb
+- lib/minitest/subjective/case_inquirer.rb
+- lib/minitest/subjective/file_result.rb
+- lib/minitest/subjective/file_result/branch_statistics.rb
+- lib/minitest/subjective/file_result/branch_statistics/branch_hits.rb
+- lib/minitest/subjective/file_result/branch_statistics/conditional_hits.rb
+- lib/minitest/subjective/file_result/branch_statistics/formatting.rb
+- lib/minitest/subjective/file_result/line_statistics.rb
+- lib/minitest/subjective/file_result/line_statistics/formatting.rb
+- lib/minitest/subjective/file_result/line_statistics/line_hits.rb
+- lib/minitest/subjective/file_result/location.rb
+- lib/minitest/subjective/file_result/method_statistics.rb
+- lib/minitest/subjective/file_result/method_statistics/formatting.rb
+- lib/minitest/subjective/file_result/method_statistics/method_hits.rb
+- lib/minitest/subjective/file_result/range.rb
+- lib/minitest/subjective/formatter.rb
+- lib/minitest/subjective/formatter/colors.rb
+- lib/minitest/subjective/reporter.rb
+- lib/minitest/subjective/result_extensions.rb
+- lib/minitest/subjective/test_extensions.rb
+- lib/minitest/subjective/version.rb
+- lib/minitest/subjective_plugin.rb
+homepage: https://buildingatlas.github.io/minitest-subjective
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://buildingatlas.github.io/minitest-subjective
+  source_code_uri: https://github.com/BuildingAtlas/minitest-subjective
+  changelog_uri: https://github.com/BuildingAtlas/minitest-subjective/tree/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Test-subject focused coverage for Minitest
+test_files: []