minitest-cc 0.1.0.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9b4e3b7affdd0bac184df62e862738f07e4fd11b5d688a73fa6215dd9d7ec287
+  data.tar.gz: 99fd07e500ec5fb9ad6e3b7887c1189046ff83bbcb4785af1630d7952bc48c9c
+SHA512:
+  metadata.gz: aec3e0e03446768f11a22f0abebf255d1e05d2a134e8e2a627d2afae726852a2eb0fa74715ab6a5457c6b9e555d9a98b08777e783bee92a1874517f1a67dd4fd
+  data.tar.gz: 695f37256eef625dddf8a97d51aa32294c4c7352a07ef2c1855aee4a07409f024dfa380ecad493e81688bbbde2071ea76962f1edf9300e20dd325833996be1f6

data/lib/minitest/cc/file_array.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Cc
+    # model for a file
+    class FileArray < Array
+      ##
+      # Calculate the lines average of the self array
+      # @return [Integer] percent of lines executed
+      def lines_average
+        lines = reduce(0) { |sum, v| sum + v.lines.to_i }
+        lines_executed = reduce(0) { |sum, v| sum + v.lines_executed.to_i }
+        lines_executed * 100 / lines
+      rescue ZeroDivisionError
+        0
+      end
+
+      ##
+      # Calculate the branches average of the self array
+      # @return [Integer] percent of branches executed
+      def branches_average
+        branches = reduce(0) { |sum, v| sum + v.branches.to_i }
+        branches_executed = reduce(0) { |sum, v| sum + v.branches_executed.to_i }
+        branches_executed * 100 / branches
+      rescue ZeroDivisionError
+        0
+      end
+
+      ##
+      # Calculate the methods average of the self array
+      # @return [Integer] percent of methods executed
+      def methods_average
+        methods = reduce(0) { |sum, v| sum + v.methods.to_i }
+        methods_executed = reduce(0) { |sum, v| sum + v.methods_executed.to_i }
+        methods_executed * 100 / methods
+      rescue ZeroDivisionError
+        0
+      end
+    end
+  end
+end

data/lib/minitest/cc/file_coverage.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Cc
+    # model for a file
+    class FileCoverage
+      # @return [String] the name of the file with extension
+      attr_accessor :name
+      # @return [String] the absolute path to the file
+      attr_accessor :path
+      # @return [String] the relative path to the file
+      attr_accessor :relative_path
+      # @return [Boolean] if this was tested or not.
+      #  this indicate if the file was tracked by coverage or not
+      attr_accessor :tested
+      # @return [Integer] total lines of the file
+      attr_accessor :lines
+      # @return [Integer] total lines executed of the file
+      attr_accessor :lines_executed
+      # @return [Integer] total branches of the file
+      attr_accessor :branches
+      # @return [Integer] total branches executed of the file
+      attr_accessor :branches_executed
+      # @return [Integer] total methods of the file
+      attr_accessor :methods
+      # @return [Integer] total methods executed of the file
+      attr_accessor :methods_executed
+
+      ##
+      # Initialize an instance of FileCoverage
+      # @param path [String] full path to the file
+      # @param relative_path [String] relative path to the file
+      # @param result [Hash] object with the result of the coverage for the file
+      def initialize(path, relative_path, result = nil)
+        @path = path
+        @relative_path = relative_path
+        @name = File.basename(path)
+        @tested = !result.nil?
+        from_result(result) unless result.nil?
+      end
+
+      ##
+      # Set the results of the coverage into the object variables
+      # @param result [Hash] object with the result of the coverage
+      def from_result(result)
+        @lines, @lines_executed = count_lines(result) unless result[:lines].nil?
+        @branches, @branches_executed = count_branches(result) unless result[:branches].nil?
+        @methods, @methods_executed = count_methods(result) unless result[:methods].nil?
+      end
+
+      ##
+      # count total lines and executed lines
+      # @param result [Hash] object with the result of the coverage
+      # @return [Array] Array with two values: First: the total lines. Second: the lines executed
+      def count_lines(result)
+        [result[:lines].count { |n| n.is_a? Integer }, result[:lines].count { |n| n.is_a?(Integer) && n != 0 }]
+      end
+
+      ##
+      # count total branches and executed branches
+      # @param result [Hash] object with the result of the coverage
+      # @return [Array] Array with two values: First: the total branches. Second: the branches executed
+      def count_branches(result)
+        [
+          result[:branches].values.reduce(0) { |sum, v| sum + v.size },
+          result[:branches].values.reduce(0) { |sum, v| sum + v.values.reject(&:zero?).count }
+        ]
+      end
+
+      ##
+      # count total methods and executed methods
+      # @param result [Hash] object with the result of the coverage
+      # @return [Array] Array with two values: First: the total methods. Second: the methods executed
+      def count_methods(result)
+        [result[:methods].length, result[:methods].values.reject(&:zero?).count]
+      end
+
+      ##
+      # Transform the object to a readable string
+      # @return [String] contains the information ready to print
+      def to_s
+        if tested
+          str = "#{relative_path}: \n lines: #{lines_executed}/#{lines} #{lines_percent}%"
+          str += "\tbranches: #{branches_executed}/#{branches} #{branches_percent}%" if branches
+          str += "\tmethods: #{methods_executed}/#{methods} #{methods_percent}%" if methods
+          str
+        else
+          "#{relative_path} : Not executed during the tests."
+        end
+      end
+
+      ##
+      # Calculate the percent of coverage lines
+      # @return [Integer] percent of coverage. executed lines / total lines
+      def lines_percent
+        lines_executed * 100 / lines
+      rescue ZeroDivisionError
+        0
+      end
+
+      ##
+      # Calculate the percent of coverage branches
+      # @return [Integer] percent of coverage. executed branches / total branches
+      def branches_percent
+        branches_executed * 100 / branches
+      rescue ZeroDivisionError
+        0
+      end
+
+      ##
+      # Calculate the percent of coverage methods
+      # @return [Integer] percent of coverage. executed methods / total methods
+      def methods_percent
+        methods_executed * 100 / methods
+      rescue ZeroDivisionError
+        0
+      end
+    end
+  end
+end

data/lib/minitest/cc/reporter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'minitest'
+
+module Minitest
+  module Cc
+    # Reporter class extend of Minitest Reporter
+    # this get 5 important methods from the parent
+    # but we use only 2
+    class Reporter < Minitest::AbstractReporter
+      ##
+      # Executed in the beginin of the minitest run
+      def start
+        Cc.start_coverage
+      end
+
+      ##
+      # Executed in the final of the minitest run
+      def report
+        Cc.summary
+      end
+    end
+  end
+end

data/lib/minitest/cc/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Cc
+    # plugin version
+    VERSION = '0.1.0.beta'
+  end
+end

data/lib/minitest/cc.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative 'cc/version'
+require_relative 'cc/reporter'
+require_relative 'cc/file_coverage'
+require_relative 'cc/file_array'
+
+module Minitest
+  # Main module of the plugin
+  # @author Andres
+  module Cc
+    @results = []
+    @files = FileArray.new
+
+    def self.cattr_accessor(name) # :nodoc:
+      (class << self; self; end).attr_accessor name
+    end
+
+    # @return [Symbol] mode of the summary. Could be :resume or :per_file
+    cattr_accessor :cc_mode
+    self.cc_mode = :resume
+
+    # @return [Array] pattern to find files that must be cover by the tests
+    cattr_accessor :tracked_files
+    self.tracked_files = [
+      './app/**/*.rb',
+      './lib/**/*.rb'
+    ]
+
+    # @return [Array] mode of the coverage, this array could contain:
+    #   :lines, :branches, :methods
+    cattr_accessor :coverage_mode
+    self.coverage_mode = %i[
+      lines
+      branches
+      methods
+    ]
+
+    class << self
+      ##
+      # Start the coverage process
+      # @see https://runebook.dev/en/docs/ruby/coverage Coverage blog post explaining the use
+      # @see https://ruby-doc.org/stdlib-2.7.6/libdoc/coverage/rdoc/Coverage.html Documentation of the module
+      def start_coverage
+        Coverage.start(coverage_mode.collect { |m| [m, true] }.to_h)
+      end
+
+      ##
+      # Print the results after the runs
+      def summary
+        @results = Coverage.peek_result
+        list_files
+        puts "\n\n# Coverage:\n\n"
+        @files.each { |f| puts f.to_s } if cc_mode == :per_file
+        puts resume if cc_mode == :resume
+        puts
+      end
+
+      ##
+      # This method populate the FileArray variable with results
+      def list_files
+        Dir.glob(tracked_files.each { |f| File.expand_path(f) }).each do |d|
+          full_path = File.expand_path(d)
+          @files << FileCoverage.new(full_path, d, result_for_file(full_path))
+        end
+      end
+
+      ##
+      # Find the result for a file with the full path
+      # if the file was not tracked by Coverage this will return nil
+      # @param file_path [String] Absolute path to the file
+      # @return [Hash, nil] Object with all the results for the selected file or nil
+      def result_for_file(file_path)
+        return if @results.empty?
+
+        @results[file_path]
+      end
+
+      ##
+      # compose the string with resume of averages
+      # @return [String] String with averages
+      def resume
+        "lines: #{@files.lines_average}% branches: #{@files.branches_average}% methods: #{@files.methods_average}%"
+      end
+    end
+  end
+end

data/lib/minitest/cc_plugin.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'coverage'
+require 'minitest'
+require 'minitest/cc'
+
+# Minitest module
+module Minitest
+  # Init method called from minitest
+  # it start the plugin
+  def self.plugin_cc_init(_options)
+    # insert ower reporter to minitest reporters
+    reporter << Minitest::Cc::Reporter.new
+  rescue StandardError
+    puts 'The coverage plugin cannot be initialized.'
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: minitest-cc
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta
+platform: ruby
+authors:
+- a-chacon
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-06-29 00:00:00.000000000 Z
+dependencies: []
+description: 'Plugin for minitest, provide a minimal information of code coverage
+  to your test output. '
+email:
+- andres.ch@protonmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/minitest/cc.rb
+- lib/minitest/cc/file_array.rb
+- lib/minitest/cc/file_coverage.rb
+- lib/minitest/cc/reporter.rb
+- lib/minitest/cc/version.rb
+- lib/minitest/cc_plugin.rb
+homepage: https://github.com/a-chacon/minitest-cc
+licenses:
+- GPL-3.0
+metadata:
+  bug_tracker_uri: https://github.com/a-chacon/minitest-cc/issues
+  changelog_uri: https://github.com/a-chacon/minitest-cc
+  documentation_uri: https://www.rubydoc.info/gems/minitest-cc
+  homepage_uri: https://github.com/a-chacon/minitest-cc
+  source_code_uri: https://github.com/a-chacon/minitest-cc
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Minitest plugin, add code coverage metrics.
+test_files: []