omg-railties 8.0.0.alpha3

data/lib/rails/autoloaders/inflector.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+
+module Rails
+  class Autoloaders
+    module Inflector # :nodoc:
+      # Concurrent::Map is not needed. This is a private class, and overrides
+      # must be defined while the application boots.
+      @overrides = {}
+
+      def self.camelize(basename, _abspath)
+        @overrides[basename] || basename.camelize
+      end
+
+      def self.inflect(overrides)
+        @overrides.merge!(overrides)
+      end
+    end
+  end
+end

data/lib/rails/autoloaders.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Rails
+  class Autoloaders # :nodoc:
+    require_relative "autoloaders/inflector"
+
+    include Enumerable
+
+    attr_reader :main, :once
+
+    def initialize
+      # This `require` delays loading the library on purpose.
+      #
+      # In Rails 7.0.0, railties/lib/rails.rb loaded Zeitwerk as a side-effect,
+      # but a couple of edge cases related to Bundler and Bootsnap showed up.
+      # They had to do with order of decoration of `Kernel#require`, something
+      # the three of them do.
+      #
+      # Delaying this `require` up to this point is a convenient trade-off.
+      require "zeitwerk"
+
+      @main = Zeitwerk::Loader.new
+      @main.tag = "rails.main"
+      @main.inflector = Inflector
+
+      @once = Zeitwerk::Loader.new
+      @once.tag = "rails.once"
+      @once.inflector = Inflector
+    end
+
+    def each
+      yield main
+      yield once
+    end
+
+    def logger=(logger)
+      each { |loader| loader.logger = logger }
+    end
+
+    def log!
+      each(&:log!)
+    end
+
+    def zeitwerk_enabled?
+      true
+    end
+  end
+end

data/lib/rails/backtrace_cleaner.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "active_support/backtrace_cleaner"
+require "active_support/core_ext/string/access"
+
+module Rails
+  class BacktraceCleaner < ActiveSupport::BacktraceCleaner # :nodoc:
+    APP_DIRS_PATTERN = /\A(?:\.\/)?(?:app|config|lib|test|\(\w*\))/
+    RENDER_TEMPLATE_PATTERN = /:in [`'].*_\w+_{2,3}\d+_\d+'/
+
+    def initialize
+      super
+      add_filter do |line|
+        # We may be called before Rails.root is assigned.
+        # When that happens we fallback to not truncating.
+        @root ||= Rails.root && "#{Rails.root}/"
+        @root && line.start_with?(@root) ? line.from(@root.size) : line
+      end
+      add_filter do |line|
+        if RENDER_TEMPLATE_PATTERN.match?(line)
+          line.sub(RENDER_TEMPLATE_PATTERN, "")
+        else
+          line
+        end
+      end
+      add_silencer { |line| !APP_DIRS_PATTERN.match?(line) }
+    end
+
+    def clean(backtrace, kind = :silent)
+      kind = nil if ENV["BACKTRACE"]
+
+      super(backtrace, kind)
+    end
+    alias_method :filter, :clean
+
+    def clean_frame(frame, kind = :silent)
+      kind = nil if ENV["BACKTRACE"]
+
+      super(frame, kind)
+    end
+  end
+end

data/lib/rails/cli.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails/app_loader"
+
+# If we are inside a Rails application this method performs an exec and thus
+# the rest of this script is not run.
+Rails::AppLoader.exec_app
+
+Signal.trap("INT") { puts; exit(1) }
+
+require "rails/command"
+case ARGV.first
+when Rails::Command::HELP_MAPPINGS, "help", nil
+  ARGV.shift
+  Rails::Command.invoke :gem_help, ARGV
+when "plugin"
+  ARGV.shift
+  Rails::Command.invoke :plugin, ARGV
+else
+  Rails::Command.invoke :application, ARGV
+end

data/lib/rails/code_statistics.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "rails/code_statistics_calculator"
+require "active_support/core_ext/enumerable"
+
+module Rails
+  class CodeStatistics
+    DIRECTORIES = [
+      %w(Controllers        app/controllers),
+      %w(Helpers            app/helpers),
+      %w(Jobs               app/jobs),
+      %w(Models             app/models),
+      %w(Mailers            app/mailers),
+      %w(Mailboxes          app/mailboxes),
+      %w(Channels           app/channels),
+      %w(Views              app/views),
+      %w(JavaScripts        app/assets/javascripts),
+      %w(Stylesheets        app/assets/stylesheets),
+      %w(JavaScript         app/javascript),
+      %w(Libraries          lib/),
+      %w(APIs               app/apis),
+      %w(Controller\ tests  test/controllers),
+      %w(Helper\ tests      test/helpers),
+      %w(Job\ tests         test/jobs),
+      %w(Model\ tests       test/models),
+      %w(Mailer\ tests      test/mailers),
+      %w(Mailbox\ tests     test/mailboxes),
+      %w(Channel\ tests     test/channels),
+      %w(Integration\ tests test/integration),
+      %w(System\ tests      test/system),
+    ]
+
+    TEST_TYPES = ["Controller tests",
+                  "Helper tests",
+                  "Model tests",
+                  "Mailer tests",
+                  "Mailbox tests",
+                  "Channel tests",
+                  "Job tests",
+                  "Integration tests",
+                  "System tests"]
+
+    HEADERS = { lines: " Lines", code_lines: "   LOC", classes: "Classes", methods: "Methods" }
+
+    class_attribute :directories, default: DIRECTORIES
+    class_attribute :test_types, default: TEST_TYPES
+
+    # Add directories to the output of the `bin/rails stats` command.
+    #
+    #   Rails::CodeStatistics.register_directory("My Directory", "path/to/dir")
+    #
+    # For directories that contain test code, set the `test_directory` argument to true.
+    #
+    #   Rails::CodeStatistics.register_directory("Model specs", "spec/models", test_directory: true)
+    def self.register_directory(label, path, test_directory: false)
+      self.directories << [label, path]
+      self.test_types << label if test_directory
+    end
+
+    def initialize(*pairs)
+      @pairs      = pairs
+      @statistics = calculate_statistics
+      @total      = calculate_total if pairs.length > 1
+    end
+
+    def to_s
+      print_header
+      @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
+      print_splitter
+
+      if @total
+        print_line("Total", @total)
+        print_splitter
+      end
+
+      print_code_test_stats
+    end
+
+    private
+      def calculate_statistics
+        Hash[@pairs.map { |pair| [pair.first, calculate_directory_statistics(pair.last)] }]
+      end
+
+      def calculate_directory_statistics(directory, pattern = /^(?!\.).*?\.(rb|js|ts|css|scss|coffee|rake|erb)$/)
+        stats = Rails::CodeStatisticsCalculator.new
+
+        Dir.foreach(directory) do |file_name|
+          path = "#{directory}/#{file_name}"
+
+          if File.directory?(path) && !file_name.start_with?(".")
+            stats.add(calculate_directory_statistics(path, pattern))
+          elsif file_name&.match?(pattern)
+            stats.add_by_file_path(path)
+          end
+        end
+
+        stats
+      end
+
+      def calculate_total
+        @statistics.each_with_object(Rails::CodeStatisticsCalculator.new) do |pair, total|
+          total.add(pair.last)
+        end
+      end
+
+      def calculate_code
+        code_loc = 0
+        @statistics.each { |k, v| code_loc += v.code_lines unless test_types.include? k }
+        code_loc
+      end
+
+      def calculate_tests
+        test_loc = 0
+        @statistics.each { |k, v| test_loc += v.code_lines if test_types.include? k }
+        test_loc
+      end
+
+      def width_for(label)
+        [@statistics.values.sum { |s| s.public_send(label) }.to_s.size, HEADERS[label].length].max
+      end
+
+      def print_header
+        print_splitter
+        print "| Name                "
+        HEADERS.each do |k, v|
+          print " | #{v.rjust(width_for(k))}"
+        end
+        puts " | M/C | LOC/M |"
+        print_splitter
+      end
+
+      def print_splitter
+        print "+----------------------"
+        HEADERS.each_key do |k|
+          print "+#{'-' * (width_for(k) + 2)}"
+        end
+        puts "+-----+-------+"
+      end
+
+      def print_line(name, statistics)
+        m_over_c   = (statistics.methods / statistics.classes) rescue 0
+        loc_over_m = (statistics.code_lines / statistics.methods) - 2 rescue 0
+
+        print "| #{name.ljust(20)} "
+        HEADERS.each_key do |k|
+          print "| #{statistics.send(k).to_s.rjust(width_for(k))} "
+        end
+        puts "| #{m_over_c.to_s.rjust(3)} | #{loc_over_m.to_s.rjust(5)} |"
+      end
+
+      def print_code_test_stats
+        code  = calculate_code
+        tests = calculate_tests
+
+        puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f / code)}"
+        puts ""
+      end
+  end
+end

data/lib/rails/code_statistics_calculator.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Rails
+  class CodeStatisticsCalculator # :nodoc:
+    attr_reader :lines, :code_lines, :classes, :methods
+
+    PATTERNS = {
+      rb: {
+        line_comment: /^\s*#/,
+        begin_block_comment: /^=begin/,
+        end_block_comment: /^=end/,
+        class: /^\s*class\s+[_A-Z]/,
+        method: /^\s*def\s+[_a-z]/,
+      },
+      erb: {
+        line_comment: %r{((^\s*<%#.*%>)|(<!--.*-->))},
+      },
+      css: {
+        line_comment: %r{^\s*/\*.*\*/},
+      },
+      scss: {
+        line_comment: %r{((^\s*/\*.*\*/)|(^\s*//))},
+      },
+      js: {
+        line_comment: %r{^\s*//},
+        begin_block_comment: %r{^\s*/\*},
+        end_block_comment: %r{\*/},
+        method: /function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
+      },
+      coffee: {
+        line_comment: /^\s*#/,
+        begin_block_comment: /^\s*###/,
+        end_block_comment: /^\s*###/,
+        class: /^\s*class\s+[_A-Z]/,
+        method: /[-=]>/,
+      }
+    }
+
+    PATTERNS[:minitest] = PATTERNS[:rb].merge method: /^\s*(def|test)\s+['"_a-z]/
+    PATTERNS[:rake] = PATTERNS[:rb]
+
+    def initialize(lines = 0, code_lines = 0, classes = 0, methods = 0)
+      @lines = lines
+      @code_lines = code_lines
+      @classes = classes
+      @methods = methods
+    end
+
+    def add(code_statistics_calculator)
+      @lines += code_statistics_calculator.lines
+      @code_lines += code_statistics_calculator.code_lines
+      @classes += code_statistics_calculator.classes
+      @methods += code_statistics_calculator.methods
+    end
+
+    def add_by_file_path(file_path)
+      File.open(file_path) do |f|
+        add_by_io(f, file_type(file_path))
+      end
+    end
+
+    def add_by_io(io, file_type)
+      patterns = PATTERNS[file_type] || {}
+
+      comment_started = false
+
+      while line = io.gets
+        @lines += 1
+
+        if comment_started
+          if patterns[:end_block_comment] && patterns[:end_block_comment].match?(line)
+            comment_started = false
+          end
+          next
+        else
+          if patterns[:begin_block_comment] && patterns[:begin_block_comment].match?(line)
+            comment_started = true
+            next
+          end
+        end
+
+        @classes   += 1 if patterns[:class] && patterns[:class].match?(line)
+        @methods   += 1 if patterns[:method] && patterns[:method].match?(line)
+        if !line.match?(/^\s*$/) && (patterns[:line_comment].nil? || !line.match?(patterns[:line_comment]))
+          @code_lines += 1
+        end
+      end
+    end
+
+    private
+      def file_type(file_path)
+        if file_path.end_with? "_test.rb"
+          :minitest
+        else
+          File.extname(file_path).delete_prefix(".").downcase.to_sym
+        end
+      end
+  end
+end

data/lib/rails/command/actions.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    module Actions
+      # Change to the application's path if there is no <tt>config.ru</tt> file in current directory.
+      # This allows us to run <tt>rails server</tt> from other directories, but still get
+      # the main <tt>config.ru</tt> and properly set the <tt>tmp</tt> directory.
+      def set_application_directory!
+        Dir.chdir(File.expand_path("../..", APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
+      end
+
+      def require_application!
+        require ENGINE_PATH if defined?(ENGINE_PATH)
+        require APP_PATH if defined?(APP_PATH)
+      end
+
+      def boot_application!
+        require_application!
+        Rails.application.require_environment! if defined?(APP_PATH)
+      end
+
+      def load_environment_config!
+        require_application!
+        # Only run initializers that are in the :all group, which includes the
+        # :load_environment_config initializer.
+        Rails.application.initialize!(:_) if defined?(APP_PATH)
+      end
+
+      if defined?(ENGINE_PATH)
+        def load_tasks
+          Rake.application.init("rails")
+          Rake.application.load_rakefile
+        end
+
+        def load_generators
+          engine = ::Rails::Engine.find(ENGINE_ROOT)
+          Rails::Generators.namespace = engine.railtie_namespace
+          engine.load_generators
+        end
+      else
+        def load_tasks
+          Rails.application.load_tasks
+        end
+
+        def load_generators
+          Rails.application.load_generators
+        end
+      end
+    end
+  end
+end

data/lib/rails/command/base.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "thor"
+require "erb"
+
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/string/inflections"
+
+require "rails/command/actions"
+
+module Rails
+  module Command
+    class Base < Thor
+      class Error < Thor::Error # :nodoc:
+      end
+
+      include Actions
+
+      class_attribute :bin, instance_accessor: false, default: "bin/rails"
+
+      class << self
+        def exit_on_failure? # :nodoc:
+          false
+        end
+
+        # Returns true when the app is a \Rails engine.
+        def engine?
+          defined?(ENGINE_ROOT)
+        end
+
+        # Tries to get the description from a USAGE file one folder above the command
+        # root.
+        def desc(usage = nil, description = nil, options = {})
+          if usage
+            super
+          else
+            class_usage
+          end
+        end
+
+        # Convenience method to get the namespace from the class name. It's the
+        # same as Thor default except that the Command at the end of the class
+        # is removed.
+        def namespace(name = nil)
+          if name
+            super
+          else
+            @namespace ||= super.chomp("_command").sub(/:command:/, ":")
+          end
+        end
+
+        # Convenience method to hide this command from the available ones when
+        # running rails command.
+        def hide_command!
+          Rails::Command.hidden_commands << self
+        end
+
+        def inherited(base) # :nodoc:
+          super
+
+          if base.name && !base.name.end_with?("Base")
+            Rails::Command.subclasses << base
+          end
+        end
+
+        def perform(command, args, config) # :nodoc:
+          if Rails::Command::HELP_MAPPINGS.include?(args.first)
+            command, args = "help", [command]
+            args.clear if instance_method(:help).arity.zero?
+          end
+
+          dispatch(command, args.dup, nil, config)
+        end
+
+        def printing_commands
+          commands.filter_map do |name, command|
+            [namespaced_name(name), command.description] unless command.hidden?
+          end
+        end
+
+        def executable(command_name = self.command_name)
+          "#{bin} #{namespaced_name(command_name)}"
+        end
+
+        def banner(command = nil, *)
+          if command
+            # Similar to Thor's banner, but show the namespace (minus the
+            # "rails:" prefix), and show the command's declared bin instead of
+            # the command runner.
+            command.formatted_usage(self).gsub(/^#{namespace}:(\w+)/) { executable($1) }
+          else
+            executable
+          end
+        end
+
+        # Override Thor's class-level help to also show the USAGE.
+        def help(shell, *) # :nodoc:
+          super
+          shell.say class_usage if class_usage
+        end
+
+        # Sets the base_name taking into account the current class namespace.
+        #
+        #   Rails::Command::TestCommand.base_name # => 'rails'
+        def base_name
+          @base_name ||= if base = name.to_s.split("::").first
+            base.underscore
+          end
+        end
+
+        # Return command name without namespaces.
+        #
+        #   Rails::Command::TestCommand.command_name # => 'test'
+        def command_name
+          @command_name ||= if command = name.to_s.split("::").last
+            command.chomp!("Command")
+            command.underscore
+          end
+        end
+
+        def class_usage # :nodoc:
+          if usage_path
+            @class_usage ||= ERB.new(File.read(usage_path), trim_mode: "-").result(binding)
+          end
+        end
+
+        # Path to lookup a USAGE description in a file.
+        def usage_path
+          @usage_path = resolve_path("USAGE") unless defined?(@usage_path)
+          @usage_path
+        end
+
+        # Default file root to place extra files a command might need, placed
+        # one folder above the command file.
+        #
+        # For a Rails::Command::TestCommand placed in <tt>rails/command/test_command.rb</tt>
+        # would return <tt>rails/test</tt>.
+        def default_command_root
+          @default_command_root = resolve_path(".") unless defined?(@default_command_root)
+          @default_command_root
+        end
+
+        private
+          # Allow the command method to be called perform.
+          def create_command(meth)
+            if meth == "perform"
+              alias_method command_name, meth
+            else
+              # Prevent exception about command without usage.
+              # Some commands define their documentation differently.
+              @usage ||= meth
+              @desc  ||= ""
+
+              super
+            end
+          end
+
+          def namespaced_name(name)
+            *prefix, basename = namespace.delete_prefix("rails:").split(":")
+            prefix.concat([basename, name.to_s].uniq).join(":")
+          end
+
+          def resolve_path(path)
+            path = File.join("../commands", *namespace.delete_prefix("rails:").split(":"), path)
+            path = File.expand_path(path, __dir__)
+            path if File.exist?(path)
+          end
+      end
+
+      no_commands do
+        delegate :executable, to: :class
+        attr_reader :current_subcommand
+
+        def invoke_command(command, *) # :nodoc:
+          @current_subcommand ||= nil
+          original_subcommand, @current_subcommand = @current_subcommand, command.name
+          super
+        ensure
+          @current_subcommand = original_subcommand
+        end
+      end
+    end
+  end
+end