countless 1.0.0

data/lib/countless/configuration.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Countless
+  # The configuration for the countless gem.
+  #
+  # rubocop:disable Metrics/ClassLength because of the various defaults
+  # rubocop:disable Metrics/BlockLength ditoditodito
+  class Configuration
+    include ActiveSupport::Configurable
+
+    # The base/root path of the project to work on. This path is used as a
+    # prefix to all relative path/file configurations.
+    config_accessor(:base_path) do
+      # Check for a Rake invoked call
+      if defined? Rake
+        path = Rake.application.rakefile_location
+        path = Rake.application.original_dir unless path.present?
+        next path
+      end
+
+      # Check for Rails as fallback
+      next Rails.root if defined? Rails
+
+      # Use the current working directory
+      # of the process as last resort
+      Dir.pwd
+    end
+
+    # The path to the CLOC (https://github.com/AlDanial/cloc) binary. The gem
+    # comes with a bundled version of the utility, ready to be used. But you
+    # can also change the used binary path in order to use a different version
+    # which you manually provisioned.
+    config_accessor(:cloc_path) { File.expand_path('../../bin/cloc', __dir__) }
+
+    # We allow to configure additional file extensions to consider for
+    # statistics calculation. They will be included in the default list. This
+    # way you can easily extend the list.
+    config_accessor(:additional_stats_file_extensions) { [] }
+
+    # All the file extensions to consider for statistics calculation
+    config_accessor(:stats_file_extensions) do
+      %w[rb js jsx ts tsx css scss coffee rake erb haml h c cpp rs] +
+        additional_stats_file_extensions
+    end
+
+    # We allow to configure additional application object types. They will be
+    # included in the default list. This way you can easily extend the list.
+    config_accessor(:additional_stats_app_object_types) { [] }
+
+    # Configure the application (in the root +app+ directory) object types,
+    # they will be added as regular directories as well as their testing
+    # counter parts (minitest/RSpec)
+    config_accessor(:stats_app_object_types) do
+      %w[channels consumers controllers dashboards decorators fields helpers
+         jobs mailboxes mailers models policies serializers services uploaders
+         validators value_objects views] + additional_stats_app_object_types
+    end
+
+    # We allow to configure additional statistics directories. They will be
+    # included in the default list. This way you can easily extend the list.
+    config_accessor(:additional_stats_directories) { [] }
+
+    # A list of custom base directories in an application / gem
+    config_accessor(:stats_base_directories) do
+      [
+        { name: 'JavaScripts', dir: 'app/assets/javascripts' },
+        { name: 'Stylesheets', dir: 'app/assets/stylesheets' },
+        { name: 'JavaScript', dir: 'app/javascript' },
+        { name: 'API', dir: 'app/api' },
+        { name: 'API tests', dir: 'test/api', test: true },
+        { name: 'API specs', dir: 'spec/api', test: true },
+        { name: 'APIs', dir: 'app/apis' },
+        { name: 'API tests', dir: 'test/apis', test: true },
+        { name: 'API specs', dir: 'spec/apis', test: true },
+        { name: 'Libraries', dir: 'app/lib' },
+        { name: 'Library tests', dir: 'test/lib', test: true },
+        { name: 'Library specs', dir: 'spec/lib', test: true },
+        { name: 'Libraries', dir: 'lib' },
+        { name: 'Library tests', dir: 'test/lib', test: true },
+        { name: 'Library specs', dir: 'spec/lib', test: true }
+      ] + additional_stats_directories
+    end
+
+    # We allow to configure additional detailed statistics patterns. They will
+    # be included in the default list. This way you can easily extend the list.
+    config_accessor(:additional_detailed_stats_patterns) { {} }
+
+    # All the detailed statistics (class/method and tests/examples) patterns
+    # which will be used for parsing the source files to gather the metrics
+    config_accessor(:detailed_stats_patterns) do
+      {
+        ruby: {
+          extensions: %w[rb rake],
+          class: /^\s*class\s+[_A-Z]/, # regular Ruby classes
+          method: Regexp.union(
+            [
+              /^\s*def\s+[_a-z]/, # regular Ruby methods
+              /^\s*def test_/, # minitest
+              /^\s*x?it(\s+|\()['"_a-z]/ # RSpec
+            ]
+          )
+        },
+        javascript: {
+          extensions: %w[js jsx ts tsx],
+          class: /^\s*class\s+[_A-Z]/,
+          method: Regexp.union(
+            [
+              /function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/, # regular method
+              /^\s*x?it(\s+|\()['"_a-z]/, # jsspec, jasmine, jest
+              /^\s*test(\s+|\()['"_a-z]/, # jest
+              /^\s*QUnit.test(\s+|\()['"_a-z]/ # qunit
+            ]
+          )
+        },
+        coffee: {
+          extensions: %w[coffee],
+          class: /^\s*class\s+[_A-Z]/,
+          method: /[-=]>/
+        },
+        rust: {
+          extensions: %(rs),
+          class: /^\s*struct\s+[_A-Z]/,
+          method: Regexp.union(
+            [
+              /^\s*fn\s+[_a-z]/, # regular Rust methods
+              /#\[test\]/ # methods with test config
+            ]
+          )
+        },
+        c_cpp: {
+          extensions: %(h c cpp),
+          class: /^\s*(struct|class)\s+[_a-z]/i,
+          method: /^\s*\w.* \w.*\(.*\)\s*{/m
+        }
+      }.deep_merge(additional_detailed_stats_patterns)
+    end
+
+    # We allow to configure additional annotation directories. They will be
+    # included in the default list. This way you can easily extend the list.
+    config_accessor(:additional_annotations_directories) { [] }
+
+    # Configure the directories which should be checked for annotations
+    config_accessor(:annotations_directories) do
+      %w[app config db src lib test tests spec doc docs] +
+        additional_annotations_directories
+    end
+
+    # We allow to configure additional annotation files/patterns. They will be
+    # included in the default list. This way you can easily extend the list.
+    config_accessor(:additional_annotations_files) { [] }
+
+    # Configure the files/patterns which should be checked for annotations
+    config_accessor(:annotations_files) do
+      %w[
+        Appraisals
+        CHANGELOG.md
+        CODE_OF_CONDUCT.md
+        config.ru
+        docker-compose.yml
+        Dockerfile
+        Envfile
+        Gemfile
+        *.gemspec
+        Makefile
+        Rakefile
+        README.md
+      ] + additional_annotations_files
+    end
+
+    # We allow to configure additional annotation tags. They will be included
+    # in the default list. This way you can easily extend the list.
+    config_accessor(:additional_annotation_tags) { [] }
+
+    # Configure the annotation tags which will be search
+    config_accessor(:annotation_tags) do
+      %w[OPTIMIZE FIXME TODO TESTME DEPRECATEME] + additional_annotation_tags
+    end
+
+    # We allow to configure additional annotation patterns. They will be
+    # included in the default list. This way you can easily extend the list.
+    config_accessor(:additional_annotation_patterns) { {} }
+
+    # Configure all known file extensions of annotations files
+    config_accessor(:annotation_patterns) do
+      {
+        hashtag: {
+          files: %w[Appraisals Dockerfile Envfile Gemfile Rakefile
+                    Makefile Appraisals],
+          extensions: %w[builder md ru rb rake yml yaml ruby gemspec toml],
+          regex: ->(tag) { /#\s*(#{tag}):?\s*(.*)$/ }
+        },
+        double_slash: {
+          extensions: %w[css js jsx ts tsx rust c h],
+          regex: ->(tag) { %r{//\s*(#{tag}):?\s*(.*)$} }
+        },
+        erb: {
+          extensions: %w[erb],
+          regex: ->(tag) { /<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/ }
+        },
+        haml: {
+          extensions: %w[haml],
+          regex: ->(tag) { /-#\s*(#{tag}):?\s*(.*)$/ }
+        }
+      }.deep_merge(additional_annotation_patterns)
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+  # rubocop:enable Metrics/BlockLength
+end

data/lib/countless/extensions/configuration_handling.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Countless
+  module Extensions
+    # A top-level gem-module extension to handle configuration needs.
+    #
+    # rubocop:disable Metrics/BlockLength because this is how
+    #   an +ActiveSupport::Concern+ looks like
+    module ConfigurationHandling
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Retrieve the current configuration object.
+        #
+        # @return [Configuration] the current configuration object
+        def configuration
+          @configuration ||= Configuration.new
+        end
+
+        # Configure the concern by providing a block which takes
+        # care of this task. Example:
+        #
+        #   Countless.configure do |conf|
+        #     # conf.xyz = [..]
+        #   end
+        def configure
+          yield(configuration)
+        end
+
+        # Reset the current configuration with the default one.
+        def reset_configuration!
+          @configuration = Configuration.new
+        end
+
+        # A shortcut to the configured CLOC binary.
+        delegate :cloc_path, to: :configuration
+
+        # Get an assembled list of directories which should be
+        # checked for code statistics.
+        #
+        # @return [Array<Hash{Symbol => Mixed}>] the statistics directories
+        #
+        # rubocop:disable Metrics/MethodLength because of the
+        #   configuration assembling
+        # rubocop:disable Metrics/AbcSize dito
+        # rubocop:disable Metrics/CyclomaticComplexity dito
+        def statistic_directories
+          conf = configuration
+          pattern_suffix = "/**/*.{#{conf.stats_file_extensions.join(',')}}"
+
+          res = conf.stats_base_directories.deep_dup
+          conf.stats_app_object_types.each do |type|
+            one_type = type.singularize.titleize
+            many_types = type.pluralize.titleize
+
+            res << { name: many_types, dir: "app/#{type}" }
+            res << { name: "#{one_type} tests",
+                     dir: "test/#{type}", test: true }
+            res << { name: "#{one_type} specs",
+                     dir: "specs/#{type}", test: true }
+          end
+
+          res.each do |cur|
+            # Add the configured base dir, when we hit a relative dir config
+            cur[:dir] = "#{conf.base_path}/#{cur[:dir]}" \
+              unless (cur[:dir] || '').start_with? '/'
+            # Add the default pattern, when no user configured pattern
+            # is present
+            cur[:pattern] ||= "#{cur[:dir]}#{pattern_suffix}"
+            # Fallback to regular code, when not otherwise configured
+            cur[:test] ||= false
+          end
+
+          res.sort_by { |cur| [cur[:test].to_s, cur[:name]] }
+        end
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/CyclomaticComplexity
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/countless/rake_tasks.rake

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'rspec/core/rake_task'
+require 'pp'
+
+desc 'Report code statistics (KLOCs, etc)'
+task :stats do
+  puts Countless::Statistics.new.to_s
+end
+
+desc 'Enumerate all annotations'
+task :notes do
+  puts Countless::Annotations.new.to_s
+end
+
+namespace :notes do
+  Countless.configuration.annotation_tags.each do |annotation|
+    task annotation.downcase.to_sym do
+      puts Countless::Annotations.new("@?#{annotation}").to_s
+    end
+  end
+
+  task :custom do
+    annotation = ENV.fetch('ANNOTATION')
+    puts Countless::Annotations.new("@?#{annotation}").to_s
+  rescue KeyError
+    puts 'No annotation was specified.'
+    puts "Usage: ANNOTATION='FIXME' rake notes:custom"
+    exit 1
+  end
+end

data/lib/countless/rake_tasks.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# @TODO: This is just for testing purposes here. Keep it exactly like that.
+
+require 'countless'
+load 'countless/rake_tasks.rake'

data/lib/countless/statistics.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+module Countless
+  # The source code statistics displaying handler.
+  #
+  # Heavily stolen from: https://bit.ly/3qpvgfu
+  #
+  # rubocop:disable Metrics/ClassLength because of the calculation
+  #   and formatting logic
+  class Statistics
+    # Make the extracted information accessible
+    attr_reader :dirs, :statistics, :total
+
+    # Initialize a new source code statistics displaying handler. When no
+    # configurations are passed in directly, we fallback to the configured
+    # statistics directories of the gem.
+    #
+    # @param dirs [Array<Hash{Symbol => Mixed}>] the configurations
+    # @return [Countless::Statistics] the new instance
+    #
+    # rubocop:disable Metrics/AbcSize because of the
+    #   directory/config resolving
+    # rubocop:disable Metrics/PerceivedComplexity dito
+    # rubocop:disable Metrics/CyclomaticComplexity dito
+    # rubocop:disable Metrics/MethodLength dito
+    def initialize(*dirs)
+      base_path = Countless.configuration.base_path
+
+      # Resolve the given directory configurations to actual files
+      dirs = (dirs.presence || Countless.statistic_directories)
+      @dirs = dirs.each_with_object([]) do |cur, memo|
+        copy = cur.deep_dup
+        copy[:files] = Array(copy[:files])
+
+        if copy[:pattern].is_a? Regexp
+          copy[:files] += Dir[
+            File.join(copy[:dir] || base_path, '**/*')
+          ].select { |path| File.file?(path) && copy[:pattern].match?(path) }
+        else
+          copy[:files] += Dir[copy[:pattern]]
+        end
+
+        copy[:files].uniq!
+        memo << copy if copy[:files].present?
+      end
+
+      @statistics = calculate_statistics
+      @total = calculate_total if @dirs.length > 1
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength
+
+    # Calculate the total statistics of all sub-statistics for the configured
+    # directories.
+    #
+    # @return [Countless::Statistics::Calculator] the total statistics
+    def calculate_total
+      calculator = Calculator.new(name: 'Total')
+      @statistics.values.each_with_object(calculator) do |conf, total|
+        total.add(conf[:stats])
+      end
+    end
+
+    # Calculate all statistics for the configured directories and pass back a
+    # named hash.
+    #
+    # @return [Hash{String => Hash{Symbol => Mixed}}] the statistics
+    #   per configuration
+    def calculate_statistics
+      @dirs.map do |conf|
+        [
+          conf[:name],
+          conf.merge(stats: calculate_file_statistics(conf[:name],
+                                                      conf[:files]))
+        ]
+      end.to_h
+    end
+
+    # Setup a new +Calculator+ for the given directory/pattern in order to
+    # extract the individual file statistics and calculate the sub-totals.
+    #
+    # We match the pattern against the individual file name and the relative
+    # file path. This allows top-level only matches.
+    #
+    # @param name [String] the name/description/label of the directory
+    # @param files [Array<String, Pathname>] the files to extract
+    #   statistics from
+    # @return [Countless::Statistics::Calculator] the calculator runtime
+    #   for the given directory/pattern
+    def calculate_file_statistics(name, files)
+      Calculator.new(name: name).tap do |calc|
+        Cloc.stats(*files).each do |path, stats|
+          calc.add_by_file_path(path, **stats)
+        end
+      end
+    end
+
+    # Calculate the total lines of code.
+    #
+    # @return [Integer] the total lines of code
+    def calculate_code
+      @statistics.values.reject { |conf| conf[:test] }
+                 .map { |conf| conf[:stats].code_lines }.sum
+    end
+
+    # Calculate the total lines of testing code.
+    #
+    # @return [Integer] the total lines of testing code
+    def calculate_tests
+      @statistics.values.select { |conf| conf[:test] }
+                 .map { |conf| conf[:stats].code_lines }.sum
+    end
+
+    # Convert the code statistics to a formatted string buffer.
+    #
+    # @return [String] the formatted code statistics
+    #
+    # rubocop:disable Metrics/MethodLength because of the complex formatting
+    #   logic with fully dynamic columns widths
+    # rubocop:disable Metrics/PerceivedComplexity dito
+    # rubocop:disable Metrics/CyclomaticComplexity dito
+    # rubocop:disable Metrics/AbcSize dito
+    def to_s
+      col_sizes = {}
+      rows = to_table.map do |row|
+        next row unless row.is_a?(Array)
+
+        row = row.map(&:to_s)
+        cols = row.map(&:length).each_with_index.map { |len, idx| [idx, [len]] }
+        col_sizes.deep_merge!(cols.to_h) { |_, left, right| left + right }
+        row
+      end
+
+      # Calculate the correct column sizes
+      col_sizes = col_sizes.values.each_with_object([]) do |widths, memo|
+        memo << widths.max + 2
+      end
+
+      # Enforce the correct column sizes per row
+      splitter = ([0] + col_sizes + [0]).map { |size| '-' * size }.join('+')
+      rows.each_with_object([]) do |row, memo|
+        next memo << splitter if row == :splitter
+        next memo << row if row.is_a?(String)
+
+        cols = row.each_with_index.map do |col, idx|
+          meth = idx.zero? ? :ljust : :rjust
+          col.send(meth, col_sizes[idx] - 2)
+        end
+        memo << "| #{cols.join(' | ')} |"
+      end.join("\n")
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/AbcSize
+
+    # Convert the code statistics to a processable table structure. Each
+    # element in the resulting array is a single line, while array elements
+    # reflect columns. The special +:splitter+ row value will be converted
+    # later by +#to_s+.
+    #
+    # @return [Array<Array<String, Integer>, Symbol>] the raw table
+    #
+    # rubocop:disable Metrics/MethodLength because of the table construction
+    def to_table
+      table = [
+        :splitter,
+        %w[Name Lines LOC Comments Classes Methods M/C LOC/M],
+        :splitter
+      ]
+      @statistics.each_value { |conf| table << conf[:stats].to_h.values }
+      table << :splitter
+
+      if @total
+        table << @total.to_h.values
+        table << :splitter
+      end
+
+      table << code_test_stats_line
+      table
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Return the final meta statistics line.
+    #
+    # @return [String] the meta statistics line
+    def code_test_stats_line
+      code  = calculate_code
+      tests = calculate_tests
+      ratio = tests.fdiv(code)
+      ratio = '0' if ratio.nan?
+
+      res = [
+        "Code LOC: #{code}",
+        "Test LOC: #{tests}",
+        "Code to Test Ratio: 1:#{format('%.1f', ratio)}"
+      ].join(' ' * 5)
+      "  #{res}"
+    end
+
+    # The source code statistics calculator which holds the data of a single
+    # runtime.
+    #
+    # Heavily stolen from: https://bit.ly/3tk7ZgJ
+    class Calculator
+      # Expose each metric as simple readers
+      attr_reader :name, :lines, :code_lines, :comment_lines,
+                  :classes, :methods
+
+      # Setup a new source code statistics calculator instance.
+      #
+      # @param name [String, nil] the name of the calculated path
+      # @param lines [Integer] the initial lines count
+      # @param code_lines [Integer] the initial code lines count
+      # @param comment_lines [Integer] the initial comment lines count
+      # @param classes [Integer] the initial classes count
+      # @param methods [Integer] the initial methods count
+      # @return [Countless::Statistics::Calculator] the new instance
+      #
+      # rubocop:disable Metrics/ParameterLists because of the
+      #   various metrics we support
+      def initialize(name: nil, lines: 0, code_lines: 0, comment_lines: 0,
+                     classes: 0, methods: 0)
+        @name = name
+        @lines = lines
+        @code_lines = code_lines
+        @comment_lines = comment_lines
+        @classes = classes
+        @methods = methods
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Add the metrics from another calculator instance to the current one.
+      #
+      # @param calculator [Countless::Statistics::Calculator] the other
+      #   calculator instance to fetch metrics from
+      def add(calculator)
+        @lines += calculator.lines
+        @code_lines += calculator.code_lines
+        @comment_lines += calculator.comment_lines
+        @classes += calculator.classes
+        @methods += calculator.methods
+      end
+
+      # Parse and add statistics of a single file by path.
+      #
+      # @param path [String] the path of the file
+      # @param stats [Hash{Symbol => Integer}] addtional CLOC statistics
+      def add_by_file_path(path, **stats)
+        @lines += stats.fetch(:total, 0)
+        @code_lines += stats.fetch(:code, 0)
+        @comment_lines += stats.fetch(:comment, 0)
+        add_details_by_file_path(path)
+      end
+
+      # Analyse a given input file and extract the corresponding detailed
+      # metrics. (class and method counts) Afterwards apply the new metrics to
+      # the current calculator instance metrics.
+      #
+      # @param path [String] the path of the file
+      #
+      # rubocop:disable Metrics/AbcSize because of the pattern search by file
+      #   extension and pattern matching on each line afterwards
+      # rubocop:disable Metrics/CyclomaticComplexity dito
+      # rubocop:disable Metrics/PerceivedComplexity dito
+      def add_details_by_file_path(path)
+        all_patterns = Countless.configuration.detailed_stats_patterns
+
+        ext = path.split('.').last
+        patterns = all_patterns.find do |_, conf|
+          conf[:extensions].include? ext
+        end&.last
+
+        # When no detailed patterns are configured for this file,
+        # we skip further processing
+        return unless patterns
+
+        # Walk through the given file, line by line
+        File.read(path).lines.each do |line|
+          @classes += 1 if patterns[:class]&.match? line
+          @methods += 1 if patterns[:method]&.match? line
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      # Return the methods per classes.
+      #
+      # @return [Integer] the methods per classes
+      def m_over_c
+        methods / classes
+      rescue StandardError
+        0
+      end
+
+      # Return the lines of code per methods.
+      #
+      # @return [Integer] the lines of code per methods
+      def loc_over_m
+        code_lines / methods
+      rescue StandardError
+        0
+      end
+
+      # Convert the current calculator instance to a simple hash.
+      #
+      # @return [Hash{Symbol => Mixed}] the calculator values as simple hash
+      def to_h
+        %i[
+          name lines code_lines comment_lines
+          classes methods m_over_c loc_over_m
+        ].each_with_object({}) { |key, memo| memo[key] = send(key) }
+      end
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/countless/version.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# The gem version details.
+module Countless
+  # The version of the +countless+ gem
+  VERSION = '1.0.0'
+
+  class << self
+    # Returns the version of gem as a string.
+    #
+    # @return [String] the gem version as string
+    def version
+      VERSION
+    end
+
+    # Returns the version of the gem as a +Gem::Version+.
+    #
+    # @return [Gem::Version] the gem version as object
+    def gem_version
+      Gem::Version.new VERSION
+    end
+  end
+end