rails_stats 2.0.1 → 2.2.0

data/lib/rails_stats/all.rb

@@ -1,9 +1,17 @@
+module RailsStats
+  # Vendored / generated directory names we never descend into or treat as a
+  # pack. Shared by PackFinder (which builds IGNORED_PATH from it) and Util
+  # (which matches them by basename while walking the tree).
+  IGNORED_DIRS = %w[node_modules vendor tmp log .git].freeze
+end
+
 require 'rails_stats/stats_calculator'
 require 'rails_stats/stats_formatter'
 require 'rails_stats/json_formatter'
 require 'rails_stats/console_formatter'
 require 'rails_stats/inflector'
 require 'rails_stats/code_statistics_calculator'
+require 'rails_stats/pack_finder'
 require 'rails_stats/util'
 require 'rails_stats/app_statistics'
 require 'rails_stats/test_statistics'

data/lib/rails_stats/app_statistics.rb

@@ -1,6 +1,6 @@
 module RailsStats
   class AppStatistics
-    attr_reader :statistics, :total, :test
+    attr_reader :statistics, :total, :test, :directory
 
     def initialize(directory)
       @directories = []

data/lib/rails_stats/code_statistics_calculator.rb

@@ -18,6 +18,24 @@ module RailsStats
         end_block_comment: %r{\*/},
         method: /function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
       },
+      jsx: {
+        line_comment: %r{^\s*//},
+        begin_block_comment: %r{^\s*/\*},
+        end_block_comment: %r{\*/},
+        method: /^\s*function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
+      },
+      ts: {
+        line_comment: %r{^\s*//},
+        begin_block_comment: %r{^\s*/\*},
+        end_block_comment: %r{\*/},
+        method: /^\s*function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
+      },
+      tsx: {
+        line_comment: %r{^\s*//},
+        begin_block_comment: %r{^\s*/\*},
+        end_block_comment: %r{\*/},
+        method: /^\s*function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
+      },
       coffee: {
         line_comment: /^\s*#/,
         begin_block_comment: /^\s*###/,

data/lib/rails_stats/console_formatter.rb

@@ -3,25 +3,59 @@ require "bundler/stats/cli"
 module RailsStats
   class ConsoleFormatter < StatsFormatter
     def to_s
-      Bundler::Stats::CLI.start
+      Bundler::Stats::CLI.start(['--format', 'text'])
 
-      print_header
-      sorted_keys = @statistics.keys.sort
-      sorted_keys.each { |key| print_line(key, @statistics[key]) }
-      print_splitter
-
-      if @grand_total
-        print_line("Code", @code_total)
-        print_line("Tests", @tests_total)
-        print_line("Total", @grand_total)
-        print_splitter
+      if calculator.packs?
+        print_grouped
+      else
+        print_flat
       end
 
       print_code_test_stats
+      print_polymorphic_stats
+      print_schema_stats
     end
 
     private
 
+      def print_flat
+        print_table(@statistics)
+      end
+
+      def print_grouped
+        @statistics_by_group.each do |group, group_statistics|
+          puts "== #{group_label(group)} =="
+          print_table(group_statistics)
+          puts ""
+        end
+
+        puts "== #{grand_total_label} =="
+        print_table(@statistics)
+      end
+
+      def group_label(group)
+        group == RailsStats::StatsCalculator::CORE_GROUP ? "Core Application" : "Pack: #{group}"
+      end
+
+      def grand_total_label
+        "Total (all packs)"
+      end
+
+      # Prints a full table (header, one line per concept, and Code/Tests/Total
+      # totals) for the given {concept => CodeStatisticsCalculator} hash.
+      def print_table(statistics)
+        code, tests, grand = calculator.totals_for(statistics)
+
+        print_header
+        statistics.keys.sort.each { |key| print_line(key, statistics[key]) }
+        print_splitter
+
+        print_line("Code", code)
+        print_line("Tests", tests)
+        print_line("Total", grand)
+        print_splitter
+      end
+
       def print_header
         print_splitter
         puts "| Name                 | Files   | Lines   |     LOC | Classes | Methods | M/C | LOC/M |"
@@ -53,5 +87,19 @@ module RailsStats
         puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f/code)}  Files: #{calculator.files_total}"
         puts ""
       end
+
+      def print_polymorphic_stats
+        puts "  Polymorphic models count: #{calculator.polymorphic} polymorphic associations"
+      end
+
+      def print_schema_stats
+        if File.exist?(calculator.schema_path)
+          puts "  Schema Stats: #{calculator.schema} `create_table` calls in schema.rb"
+        elsif File.exist?(calculator.structure_path)
+          puts "  Schema Stats: #{calculator.schema} `CREATE TABLE` calls in structure.sql"
+        else
+          puts "  Schema Stats: No schema.rb or structure.sql file found"
+        end
+      end
   end
-end
+end

data/lib/rails_stats/cucumber_statistics.rb

@@ -1,6 +1,6 @@
 module RailsStats
   class CucumberStatistics
-    attr_reader :statistics, :total, :test
+    attr_reader :statistics, :total, :test, :directory
 
     def initialize(directory)
       @test = true

data/lib/rails_stats/gem_statistics.rb

@@ -1,6 +1,6 @@
 module RailsStats
   class GemStatistics
-    attr_reader :statistics, :total, :test
+    attr_reader :statistics, :total, :test, :directory
 
     def initialize(directory)
       @test = false

data/lib/rails_stats/json_formatter.rb

@@ -3,21 +3,50 @@ require "json"
 module RailsStats
   class JSONFormatter < StatsFormatter
     def result
-      @result = @statistics.map { |key, stats| stat_hash(key, stats) }
+      @result = []
+      old_stdout = $stdout
+      $stdout = StringIO.new
+      Bundler::Stats::CLI.start(["-f", "json"])
+      bundler_stats_cli_json_result = $stdout.string
+      $stdout = old_stdout
 
-      if @grand_total
-        @result << stat_hash("Total", @grand_total).merge(code_test_hash)
-      end
+      @result << JSON.parse(bundler_stats_cli_json_result) unless bundler_stats_cli_json_result.strip.empty?
+
+      @result += @statistics.map { |key, stats| stat_hash(key, stats) }
+      @result << stat_hash("Code", @code_total).merge(code_test_hash) if @code_total
+      @result << stat_hash("Tests", @tests_total).merge(code_test_hash) if @tests_total
+      @result << stat_hash("Total", @grand_total).merge(code_test_hash) if @grand_total
+
+      @result << { "packs" => packs_breakdown } if calculator.packs?
+
+      @result << { "schema_stats" => schema_info }
+      @result << { "polymorphic_stats" => print_polymorphic_stats }
 
       @result
     end
 
     def to_s
-      puts result.to_json
+      puts JSON.generate(result, ascii_only: false)
     end
 
     private
 
+      # Per-pack / per-component breakdown, keyed by group name ("Core" plus
+      # each pack's relative path). Each group lists its concept stats followed
+      # by Code/Tests/Total rows for that group.
+      def packs_breakdown
+        @statistics_by_group.each_with_object({}) do |(group, group_statistics), out|
+          code, tests, grand = calculator.totals_for(group_statistics)
+
+          rows = group_statistics.map { |key, stats| stat_hash(key, stats) }
+          rows << stat_hash("Code", code).merge("total" => true)
+          rows << stat_hash("Tests", tests).merge("total" => true)
+          rows << stat_hash("Total", grand).merge("total" => true)
+
+          out[group] = rows
+        end
+      end
+
       def code_test_hash
         code  = calculator.code_loc
         tests = calculator.test_loc
@@ -42,5 +71,29 @@ module RailsStats
           "loc_over_m" => loc_over_m.to_s
         }
       end
+
+      def print_polymorphic_stats
+        if calculator.polymorphic
+          {
+            "polymorphic_models_count" => calculator.polymorphic,
+          }
+        end
+      end
+
+      def schema_info
+        if File.exist?(calculator.schema_path)
+          {
+            "schema_path" => calculator.schema_path,
+            "create_table calls count" => calculator.schema,
+          }
+        elsif File.exist?(calculator.structure_path)
+          {
+            "structure_path" => calculator.structure_path,
+            "create_table calls count" => calculator.schema
+          }
+        else
+          { "schema_stats" => "No schema.rb or structure.sql file found" }
+        end
+      end
   end
-end
+end

data/lib/rails_stats/pack_finder.rb

@@ -0,0 +1,67 @@
+module RailsStats
+  # Detects "packs" (packwerk / packs-rails) and "components" (component-based
+  # Rails, à la Stephan Hagemann) inside a Rails application so that stats can
+  # be reported per pack/component plus a "Core" group for everything else.
+  #
+  # A directory is considered a pack when either:
+  #
+  #   * it contains a `package.yml` file (the packwerk marker), or
+  #   * it is a direct child of a `packs/` or `components/` directory and holds
+  #     any of the usual code folders (`app`, `lib`, `spec`, `test`).
+  #
+  # Nested packs (e.g. `packs/a/packs/b`) are supported. The root directory
+  # itself is never reported as a pack.
+  module PackFinder
+    extend self
+
+    CODE_FOLDERS   = %w[app lib spec test].freeze
+    PACK_CONTAINERS = %w[packs components].freeze
+
+    # Path regex used to filter glob results to skip vendored/generated
+    # directories. Built from the shared RailsStats::IGNORED_DIRS list.
+    IGNORED_PATH   = %r{/(#{IGNORED_DIRS.map { |dir| Regexp.escape(dir) }.join("|")})/}.freeze
+
+    # Returns the absolute paths of every detected pack/component, sorted.
+    def find(root_directory)
+      root = File.absolute_path(root_directory)
+      packs = {}
+
+      collect_packwerk_packs(root, packs)
+      collect_convention_packs(root, packs)
+
+      packs.keys.sort
+    end
+
+    private
+
+    def collect_packwerk_packs(root, packs)
+      Dir.glob(File.join(root, "**", "package.yml")).each do |marker_path|
+        next if marker_path =~ IGNORED_PATH
+
+        dir = File.absolute_path(File.dirname(marker_path))
+        next if dir == root
+
+        packs[dir] = true
+      end
+    end
+
+    def collect_convention_packs(root, packs)
+      PACK_CONTAINERS.each do |container|
+        Dir.glob(File.join(root, "**", container, "*")).each do |path|
+          next if path =~ IGNORED_PATH
+          next unless File.directory?(path)
+
+          dir = File.absolute_path(path)
+          next if dir == root
+          next unless code_folder?(dir)
+
+          packs[dir] = true
+        end
+      end
+    end
+
+    def code_folder?(dir)
+      CODE_FOLDERS.any? { |folder| File.directory?(File.join(dir, folder)) }
+    end
+  end
+end

data/lib/rails_stats/root_statistics.rb

@@ -1,6 +1,6 @@
 module RailsStats
   class RootStatistics
-    attr_reader :statistics, :total, :test
+    attr_reader :statistics, :total, :test, :directory
 
     ROOT_FOLDERS = {
       "lib" => "Libraries",

data/lib/rails_stats/spec_statistics.rb

@@ -1,6 +1,6 @@
 module RailsStats
   class SpecStatistics
-    attr_reader :statistics, :total, :test
+    attr_reader :statistics, :total, :test, :directory
 
     SPEC_FOLDERS = ['controllers',
                     'features',

data/lib/rails_stats/stats_calculator.rb

@@ -8,16 +8,46 @@ module RailsStats
                          'assets']
 
     def initialize(root_directory)
-      @root_directory = root_directory
+      @root_directory = File.absolute_path(root_directory)
+      @schema_path    = File.join(@root_directory, "db", "schema.rb")
+      @structure_path = File.join(@root_directory, "db", "structure.sql")
+      @pack_roots     = PackFinder.find(@root_directory)
       @key_concepts   = calculate_key_concepts
       @projects       = calculate_projects
       @statistics     = calculate_statistics
+      @statistics_by_group = calculate_statistics_by_group
       @code_loc       = calculate_code
       @test_loc       = calculate_tests
+      @schema         = calculate_create_table_calls
+      @polymorphic    = calculate_polymorphic
       @files_total, @code_total, @tests_total, @grand_total = calculate_totals
     end
 
-    attr_reader :code_loc, :code_total, :files_total, :grand_total, :statistics, :test_loc, :tests_total
+    attr_reader :code_loc, :code_total, :files_total, :grand_total, :statistics, :test_loc, :tests_total, :schema, :schema_path, :structure_path, :polymorphic, :pack_roots, :statistics_by_group
+
+    CORE_GROUP = "Core".freeze
+
+    # Returns true when the application is split into packs/components, i.e.
+    # there is at least one group beyond the core application.
+    def packs?
+      @pack_roots.any?
+    end
+
+    # Given a {concept => CodeStatisticsCalculator} hash (such as one of the
+    # values in +statistics_by_group+ or the flat +statistics+), returns the
+    # [code, tests, grand] totals for that group.
+    def totals_for(group_statistics)
+      code  = CodeStatisticsCalculator.new
+      tests = CodeStatisticsCalculator.new
+      grand = CodeStatisticsCalculator.new
+
+      group_statistics.each_value do |stats|
+        grand.add(stats)
+        stats.test ? tests.add(stats) : code.add(stats)
+      end
+
+      [code, tests, grand]
+    end
 
     private
 
@@ -46,7 +76,6 @@ module RailsStats
         out
       end
 
-
       def app_projects
         @app_projects ||= calculate_app_projects
       end
@@ -79,9 +108,24 @@ module RailsStats
         end
       end
 
-
       def calculate_root_projects
-        [RootStatistics.new(@root_directory)]
+        projects = [RootStatistics.new(@root_directory)]
+        projects + calculate_pack_root_projects
+      end
+
+      # Packs that are not self-contained gems/engines (no gemspec) still have
+      # a `lib` (and sometimes `config`) directory that would otherwise be
+      # missed, since only the root RootStatistics scans the top-level lib.
+      # Gems are already covered by GemStatistics, so skip them here to avoid
+      # double-counting.
+      def calculate_pack_root_projects
+        @pack_roots.reject { |pack_root| gem_pack?(pack_root) }.collect do |pack_root|
+          RootStatistics.new(pack_root)
+        end
+      end
+
+      def gem_pack?(pack_root)
+        Dir[File.join(pack_root, "*.gemspec")].any?
       end
 
       def calculate_cucumber_projects
@@ -102,6 +146,62 @@ module RailsStats
         out
       end
 
+      # Same aggregation as +calculate_statistics+, but keeps each project's
+      # numbers grouped by the pack/component it belongs to (or "Core"). The
+      # returned hash is ordered with "Core" first followed by packs sorted by
+      # their relative path.
+      def calculate_statistics_by_group
+        grouped = {}
+        @projects.each do |project|
+          group = group_key_for(project.directory)
+          grouped[group] ||= {}
+          project.statistics.each do |key, stats|
+            grouped[group][key] ||= CodeStatisticsCalculator.new(project.test)
+            grouped[group][key].add(stats)
+          end
+        end
+
+        # Drop empty concepts so a pack with, say, only models does not list a
+        # bunch of zero-line rows.
+        grouped.each_value do |group_statistics|
+          group_statistics.delete_if { |_key, stats| stats.lines == 0 }
+        end
+        grouped.delete_if { |_group, group_statistics| group_statistics.empty? }
+
+        sort_groups(grouped)
+      end
+
+      def sort_groups(grouped)
+        ordered = {}
+        ordered[CORE_GROUP] = grouped[CORE_GROUP] if grouped.key?(CORE_GROUP)
+        grouped.keys.reject { |key| key == CORE_GROUP }.sort.each do |key|
+          ordered[key] = grouped[key]
+        end
+        ordered
+      end
+
+      # Maps a project directory to its group: the relative path of the pack it
+      # lives in, or "Core" when it belongs to the main application.
+      def group_key_for(directory)
+        pack_root = pack_root_for(directory)
+        return CORE_GROUP unless pack_root
+
+        relative = pack_root.sub(/\A#{Regexp.escape(@root_directory)}\/?/, "")
+        relative.empty? ? CORE_GROUP : relative
+      end
+
+      # Returns the most specific (longest matching) pack root that contains the
+      # given directory, or nil when it is not part of any pack.
+      def pack_root_for(directory)
+        directory = File.absolute_path(directory.to_s)
+        best = nil
+        @pack_roots.each do |pack_root|
+          next unless directory == pack_root || directory.start_with?("#{pack_root}/")
+          best = pack_root if best.nil? || pack_root.length > best.length
+        end
+        best
+      end
+
       def calculate_totals
         files_total = @statistics.sum do |k,value|
           value.files_total
@@ -133,5 +233,35 @@ module RailsStats
         @statistics.each { |k, v| @test_loc += v.code_lines if v.test }
         @test_loc
       end
+
+      def calculate_create_table_calls
+        if @schema_path && File.exist?(@schema_path)
+          count_create_table_calls(schema_path, "create_table")
+        elsif @structure_path && File.exist?(@structure_path)
+          count_create_table_calls(structure_path, "CREATE TABLE")
+        else
+          0
+        end
+      end
+
+      def count_create_table_calls(file_path, keyword)
+        create_table_count = 0
+        File.foreach(file_path) do |line|
+          create_table_count += 1 if line.strip.start_with?(keyword)
+        end
+        create_table_count
+      end
+
+      def calculate_polymorphic
+        polymorphic_count = 0
+        Dir.glob(File.join(@root_directory, "app", "models", "*.rb")).each do |file|
+          File.foreach(file) do |line|
+            if line =~ /belongs_to\s+:\w+,\s+polymorphic:\s+true/
+              polymorphic_count += 1
+            end
+          end
+        end
+        polymorphic_count
+      end
   end
 end

data/lib/rails_stats/stats_formatter.rb

@@ -3,6 +3,7 @@ module RailsStats
     def initialize(calculator, opts = {})
       @calculator  = calculator
       @statistics  = calculator.statistics
+      @statistics_by_group = calculator.statistics_by_group
       @code_total  = calculator.code_total
       @tests_total = calculator.tests_total
       @grand_total = calculator.grand_total

data/lib/rails_stats/tasks.rb

@@ -3,8 +3,11 @@ task :stats, [:path, :format] do |t, args|
   Rake::Task["stats"].clear # clear out normal one if there
   require 'rails_stats/all'
 
+  # Respect an explicitly given path even when running inside a booted Rails
+  # app. Only fall back to Rails.root when no path was provided. This is what
+  # makes `rake stats[packs/pack1]` work from inside the app (see issue #23).
   path = args[:path]
-  path = Rails.root.to_s if defined?(Rails)
+  path ||= Rails.root.to_s if defined?(Rails)
   fmt = args[:format] || ""
   raise "no path given for stats" unless path
 

data/lib/rails_stats/test_statistics.rb

@@ -1,6 +1,6 @@
 module RailsStats
   class TestStatistics
-    attr_reader :statistics, :total, :test
+    attr_reader :statistics, :total, :test, :directory
 
     SPEC_FOLDERS = ['controllers',
                     'functional',

data/lib/rails_stats/util.rb

@@ -75,14 +75,22 @@ module RailsStats
       out
     end
 
-    def calculate_directory_statistics(directory, pattern = /.*\.(rb|js|coffee|feature)$/)
+    def calculate_directory_statistics(directory, pattern = /.*\.(rb|js|jsx|ts|tsx|coffee|feature)$/)
       stats = CodeStatisticsCalculator.new
 
       Dir.foreach(directory) do |file_name|
         path = "#{directory}/#{file_name}"
 
-        if File.directory?(path) && (/^\./ !~ file_name)
+        # Skip vendored / generated directories (e.g. a pack's
+        # app/webpack/node_modules). Pruning here avoids both the wasted walk
+        # and opening a directory that merely looks like a source file, such as
+        # node_modules/popper.js (which would raise Errno::EISDIR).
+        if File.directory?(path)
+          next if /^\./ =~ file_name
+          next if IGNORED_DIRS.include?(file_name)
+
           stats.add(calculate_directory_statistics(path, pattern))
+          next
         end
 
         next unless file_name =~ pattern

data/lib/rails_stats/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsStats
-  VERSION = "2.0.1"
+  VERSION = "2.2.0"
 end

data/rails_stats.gemspec

@@ -6,15 +6,16 @@ require 'rails_stats/version'
 Gem::Specification.new do |spec|
   spec.name          = "rails_stats"
   spec.version       = RailsStats::VERSION
-  spec.authors       = ["Brian Leonard"]
-  spec.email         = ["brian@bleonard.com"]
+  spec.authors       = ["Brian Leonard", "Ernesto Tagwerker"]
+  spec.email         = ["brian@bleonard.com", "ernesto@ombulabs.com"]
   spec.summary       = %q{Analyze a Rails project}
   spec.description   = %q{Point it to a directory and see stuff about the app}
   spec.homepage      = "https://github.com/fastruby/rails_stats"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.bindir        = "bin"
+  spec.executables   = ["rails-stats"]
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 

data/test/dummy/app/javascript/dummy.jsx

@@ -0,0 +1 @@
+

data/test/dummy/app/models/comment.rb

@@ -0,0 +1,3 @@
+class Comments < ApplicationRecord
+  belongs_to :commentable, polymorphic: true
+end

data/test/dummy/app/models/pet.rb

@@ -0,0 +1,2 @@
+class Pets < User
+end

data/test/dummy/app/models/user.rb

@@ -0,0 +1,2 @@
+class Users < ApplicationRecord
+end

data/test/dummy/db/schema.rb

@@ -0,0 +1,10 @@
+
+ActiveRecord::Schema[7.0].define(version: 2023_04_25_154701) do
+  create_table "users", force: :cascade do |t|
+    t.string "email"
+  end
+  create_table "comments", force: :cascade do |t|
+    t.bigint  :commentable_id
+    t.string  :commentable_type
+  end
+end