omg-railties 8.0.0.alpha3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c971e119d56fd6eaead8a8c18ace16df3ef5b8a87476912a8c417e2ddaffb0c6
+  data.tar.gz: e37f8a490c4ffff7c4ea46de4432227c5f3cd68039ac718ed64dd04d6804a15b
+SHA512:
+  metadata.gz: 93079933917d862c96d7620702d8959b9ef8d2594d1326a57b0e12ce5c9253705bc7c3c0442067c83c98c5dcd14df960732bbea615f18401c0ca021f5643ae8d
+  data.tar.gz: 5f89b209b54631104084516de80dd06aa82c5e7f3172dcca01c2f9bdd7603941c9bb26ade37dc9a4108398df42ffb8622eb6233d7250f92534d5a46043adff0f

data/CHANGELOG.md

@@ -0,0 +1,171 @@
+*   Do not include redis by default in generated Dev Containers.
+
+    Now that applications use the Solid Queue and Solid Cache gems by default, we do not need to include redis
+    in the Dev Container. We will only include redis if `--skip-solid` is used when generating an app that uses
+    Active Job or Action Cable.
+
+    When generating a Dev Container for an existing app, we will not include redis if either of the solid gems
+    are in use.
+
+    *Andrew Novoselac*
+
+*   Use [Solid Cable](https://github.com/rails/solid_cable) as the default Action Cable adapter in production, configured as a separate queue database in config/database.yml. It keeps messages in a table and continuously polls for updates. This makes it possible to drop the common dependency on Redis, if it isn't needed for any other purpose. Despite polling, the performance of Solid Cable is comparable to Redis in most situations. And in all circumstances, it makes it easier to deploy Rails when Redis is no longer a required dependency for Action Cable functionality.
+
+    *DHH*
+
+*   Use [Solid Queue](https://github.com/rails/solid_queue) as the default Active Job backend in production, configured as a separate queue database in config/database.yml. In a single-server deployment, it'll run as a Puma plugin. This is configured in `config/deploy.yml` and can easily be changed to use a dedicated jobs machine.
+
+    *DHH*
+
+*   Use [Solid Cache](https://github.com/rails/solid_cache) as the default Rails.cache backend in production, configured as a separate cache database in config/database.yml.
+
+    *DHH*
+
+*   Add Rails::Rack::SilenceRequest middleware and use it via `config.silence_healthcheck_path = path`
+    to silence requests to "/up". This prevents the Kamal-required health checks from clogging up
+    the production logs.
+
+    *DHH*
+
+*   Introduce `mariadb-mysql` and `mariadb-trilogy` database options for `rails new`
+
+    When used with the `--devcontainer` flag, these options will use `mariadb` as the database for the
+    Dev Container. The original `mysql` and `trilogy` options will use `mysql`. Users who are not
+    generating a Dev Container do not need to use the new options.
+
+    *Andrew Novoselac*
+
+*   Deprecate `::STATS_DIRECTORIES`.
+
+    The global constant `STATS_DIRECTORIES` has been deprecated in favor of
+    `Rails::CodeStatistics.register_directory`.
+
+    Add extra directories with `Rails::CodeStatistics.register_directory(label, path)`:
+
+    ```ruby
+    require "rails/code_statistics"
+    Rails::CodeStatistics.register_directory('My Directory', 'path/to/dir')
+    ```
+
+    *Petrik de Heus*
+
+*   Enable query log tags by default on development env
+
+    This can be used to trace troublesome SQL statements back to the application
+    code that generated these statements. It is also useful when using multiple
+    databases because the query logs can identify which database is being used.
+
+    *Matheus Richard*
+
+*   Defer route drawing to the first request, or when url_helpers are called
+
+    Executes the first routes reload in middleware, or when a route set's
+    url_helpers receives a route call / asked if it responds to a route.
+    Previously, this was executed unconditionally on boot, which can
+    slow down boot time unnecessarily for larger apps with lots of routes.
+
+    Environments like production that have `config.eager_load = true` will
+    continue to eagerly load routes on boot.
+
+    *Gannon McGibbon*
+
+*   Generate form helpers to use `textarea*` methods instead of `text_area*` methods
+
+    *Sean Doyle*
+
+*   Add authentication generator to give a basic start to an authentication system using database-tracked sessions and password reset.
+
+    Generate with...
+
+    ```
+    bin/rails generate authentication
+    ```
+
+    Generated files:
+
+    ```
+    app/models/current.rb
+    app/models/user.rb
+    app/models/session.rb
+    app/controllers/sessions_controller.rb
+    app/controllers/passwords_controller.rb
+    app/mailers/passwords_mailer.rb
+    app/views/sessions/new.html.erb
+    app/views/passwords/new.html.erb
+    app/views/passwords/edit.html.erb
+    app/views/passwords_mailer/reset.html.erb
+    app/views/passwords_mailer/reset.text.erb
+    db/migrate/xxxxxxx_create_users.rb
+    db/migrate/xxxxxxx_create_sessions.rb
+    test/mailers/previews/passwords_mailer_preview.rb
+    ```
+
+    *DHH*
+
+
+*   Add not-null type modifier to migration attributes.
+
+    Generating with...
+
+    ```
+    bin/rails generate migration CreateUsers email_address:string!:uniq password_digest:string!
+    ```
+
+    Produces:
+
+    ```ruby
+    class CreateUsers < ActiveRecord::Migration[8.0]
+      def change
+        create_table :users do |t|
+          t.string :email_address, null: false
+          t.string :password_digest, null: false
+
+          t.timestamps
+        end
+        add_index :users, :email_address, unique: true
+      end
+    end
+    ```
+
+    *DHH*
+
+*   Add a `script` folder to applications, and a scripts generator.
+
+    The new `script` folder is meant to hold one-off or general purpose scripts,
+    such as data migration scripts, cleanup scripts, etc.
+
+    A new script generator allows you to create such scripts:
+
+    ```
+    bin/rails generate script my_script
+    bin/rails generate script data/backfill
+    ```
+
+    You can run the generated script using:
+
+    ```
+    bundle exec ruby script/my_script.rb
+    bundle exec ruby script/data/backfill.rb
+    ```
+
+    *Jerome Dalbert*, *Haroon Ahmed*
+
+*   Deprecate `bin/rake stats` in favor of `bin/rails stats`.
+
+    *Juan Vásquez*
+
+*   Add internal page `/rails/info/notes`, that displays the same information as `bin/rails notes`.
+
+    *Deepak Mahakale*
+
+*   Add Rubocop and GitHub Actions to plugin generator.
+    This can be skipped using --skip-rubocop and --skip-ci.
+
+    *Chris Oliver*
+
+*   Use Kamal for deployment by default, which includes generating a Rails-specific config/deploy.yml.
+    This can be skipped using --skip-kamal. See more: https://kamal-deploy.org/
+
+    *DHH*
+
+Please check [7-2-stable](https://github.com/rails/rails/blob/7-2-stable/railties/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) David Heinemeier Hansson
+
+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/RDOC_MAIN.md

@@ -0,0 +1,99 @@
+# Welcome to \Rails
+
+## What's \Rails?
+
+\Rails is a web-application framework that includes everything needed to
+create database-backed web applications according to the
+[Model-View-Controller (MVC)](https://en.wikipedia.org/wiki/Model-view-controller)
+pattern.
+
+Understanding the MVC pattern is key to understanding \Rails. MVC divides your
+application into three layers: Model, View, and Controller, each with a specific responsibility.
+
+## Model layer
+
+The _**Model layer**_ represents the domain model (such as Account, Product,
+Person, Post, etc.) and encapsulates the business logic specific to
+your application. In \Rails, database-backed model classes are derived from
+`ActiveRecord::Base`. [Active Record](files/activerecord/README.rdoc) allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods.
+Although most \Rails models are backed by a database, models can also be ordinary
+Ruby classes, or Ruby classes that implement a set of interfaces as provided by
+the [Active Model](files/activemodel/README.rdoc) module.
+
+## View layer
+
+The _**View layer**_ is composed of "templates" that are responsible for providing
+appropriate representations of your application's resources. Templates can
+come in a variety of formats, but most view templates are HTML with embedded
+Ruby code (\ERB files). Views are typically rendered to generate a controller response
+or to generate the body of an email. In \Rails, View generation is handled by [Action View](files/actionview/README.rdoc).
+
+## Controller layer
+
+The _**Controller layer**_ is responsible for handling incoming HTTP requests and
+providing a suitable response. Usually, this means returning HTML, but \Rails controllers
+can also generate XML, JSON, PDFs, mobile-specific views, and more. Controllers load and
+manipulate models, and render view templates in order to generate the appropriate HTTP response.
+In \Rails, incoming requests are routed by Action Dispatch to an appropriate controller, and
+controller classes are derived from `ActionController::Base`. Action Dispatch and Action Controller
+are bundled together in [Action Pack](files/actionpack/README.rdoc).
+
+## Frameworks and libraries
+
+[Active Record](files/activerecord/README.rdoc), [Active Model](files/activemodel/README.rdoc), [Action Pack](files/actionpack/README.rdoc), and [Action View](files/actionview/README.rdoc) can each be used independently outside \Rails.
+
+In addition to that, \Rails also comes with:
+
+- [Action Mailer](files/actionmailer/README.rdoc), a library to generate and send emails
+- [Action Mailbox](files/actionmailbox/README.md), a library to receive emails within a \Rails application
+- [Active Job](files/activejob/README.md), a framework for declaring jobs and making them run on a variety of queuing backends
+- [Action Cable](files/actioncable/README.md), a framework to integrate WebSockets with a \Rails application
+- [Active Storage](files/activestorage/README.md), a library to attach cloud and local files to \Rails applications
+- [Action Text](files/actiontext/README.md), a library to handle rich text content
+- [Active Support](files/activesupport/README.rdoc), a collection of utility classes and standard library extensions that are useful for \Rails, and may also be used independently outside \Rails
+
+## Getting Started
+
+1.  Install \Rails at the command prompt if you haven't yet:
+
+        $ gem install rails
+
+2.  At the command prompt, create a new \Rails application:
+
+        $ rails new myapp
+
+    where "myapp" is the application name.
+
+3.  Change directory to `myapp` and start the web server:
+
+        $ cd myapp
+        $ bin/rails server
+
+    Run with `--help` or `-h` for options.
+
+4.  Go to `http://localhost:3000` and you'll see the \Rails bootscreen with your
+    \Rails and Ruby versions.
+
+5.  Follow the guidelines to start developing your application. You may find the
+    following resources handy:
+
+    * [Getting Started with Rails](https://guides.rubyonrails.org/getting_started.html)
+    * [Ruby on Rails Guides](https://guides.rubyonrails.org)
+    * [The API Documentation](https://api.rubyonrails.org)
+
+## Contributing
+
+We encourage you to contribute to Ruby on \Rails! Please check out the
+[Contributing to Ruby on Rails guide](https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html) for guidelines about how to proceed. [Join us!](https://contributors.rubyonrails.org)
+
+Trying to report a possible security vulnerability in \Rails? Please
+check out our [security policy](https://rubyonrails.org/security) for
+guidelines about how to proceed.
+
+Everyone interacting in \Rails and its sub-projects' codebases, issue trackers, chat rooms, and mailing lists is expected to follow the \Rails [code of conduct](https://rubyonrails.org/conduct).
+
+## License
+
+Ruby on \Rails is released under the [MIT License](https://opensource.org/licenses/MIT).

data/README.rdoc

@@ -0,0 +1,39 @@
+= Railties -- Gluing the Engine to the \Rails
+
+Railties is responsible for gluing all frameworks together. Overall, it:
+
+* handles the bootstrapping process for a \Rails application;
+
+* manages the +rails+ command line interface;
+
+* and provides the \Rails generators core.
+
+== Download
+
+The latest version of Railties can be installed with RubyGems:
+
+* gem install railties
+
+Source code can be downloaded as part of the \Rails project on GitHub
+
+* https://github.com/rails/rails/tree/main/railties
+
+== License
+
+Railties is released under the MIT license:
+
+* https://opensource.org/licenses/MIT
+
+== Support
+
+API documentation is at
+
+* https://api.rubyonrails.org
+
+Bug reports can be filed for the Ruby on \Rails project here:
+
+* https://github.com/rails/rails/issues
+
+Feature requests should be discussed on the rails-core mailing list here:
+
+* https://discuss.rubyonrails.org/c/rubyonrails-core

data/exe/rails

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+git_path = File.expand_path("../../.git", __dir__)
+
+if File.exist?(git_path)
+  railties_path = File.expand_path("../lib", __dir__)
+  $:.unshift(railties_path)
+end
+require "rails/cli"

data/lib/minitest/rails_plugin.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
+require "rails/test_unit/reporter"
+require "rails/test_unit/runner"
+
+module Minitest
+  class BacktraceFilterWithFallback
+    def initialize(preferred, fallback)
+      @preferred = preferred
+      @fallback = fallback
+    end
+
+    def filter(backtrace)
+      filtered = @preferred.filter(backtrace)
+      filtered = @fallback.filter(backtrace) if filtered.empty?
+      filtered
+    end
+  end
+
+  class SuppressedSummaryReporter < SummaryReporter
+    # Disable extra failure output after a run if output is inline.
+    def aggregated_results(*)
+      super unless options[:output_inline]
+    end
+  end
+
+  class ProfileReporter < StatisticsReporter
+    def initialize(io = $stdout, options = {})
+      super
+      @results = []
+      @count = options[:profile]
+    end
+
+    def record(result)
+      @results << result
+    end
+
+    def report
+      total_time = @results.sum(&:time)
+
+      @results.sort! { |a, b| b.time <=> a.time }
+      slow_results = @results.take(@count)
+      slow_tests_total_time = slow_results.sum(&:time)
+
+      ratio = (total_time == 0) ? 0.0 : (slow_tests_total_time / total_time) * 100
+
+      io.puts("\nTop %d slowest tests (%.2f seconds, %.1f%% of total time):\n" % [slow_results.size, slow_tests_total_time, ratio])
+      slow_results.each do |result|
+        io.puts("  %s\n    %.4f seconds %s\n" % [result.location, result.time, source_location(result)])
+      end
+      io.puts("\n")
+    end
+
+    private
+      def source_location(result)
+        filename, line = result.source_location
+        return "" unless filename
+
+        pwd = Dir.pwd
+        if filename.start_with?(pwd)
+          filename = Pathname.new(filename).relative_path_from(pwd)
+        end
+        "#{filename}:#{line}"
+      end
+  end
+
+  def self.plugin_rails_options(opts, options)
+    ::Rails::TestUnit::Runner.attach_before_load_options(opts)
+
+    opts.on("-b", "--backtrace", "Show the complete backtrace") do
+      options[:full_backtrace] = true
+    end
+
+    opts.on("-d", "--defer-output", "Output test failures and errors after the test run") do
+      options[:output_inline] = false
+    end
+
+    opts.on("-f", "--fail-fast", "Abort test run on first failure or error") do
+      options[:fail_fast] = true
+    end
+
+    opts.on("-c", "--[no-]color", "Enable color in the output") do |value|
+      options[:color] = value
+    end
+
+    opts.on("--profile [COUNT]", "Enable profiling of tests and list the slowest test cases (default: 10)") do |value|
+      default_count = 10
+
+      if value.nil?
+        count = default_count
+      else
+        count = Integer(value, exception: false)
+        if count.nil?
+          warn("Non integer specified as profile count, separate " \
+               "your path from options with -- e.g. " \
+               "`#{::Rails::TestUnitReporter.executable} --profile -- #{value}`")
+          count = default_count
+        end
+      end
+
+      options[:profile] = count
+    end
+
+    options[:color] = true
+    options[:output_inline] = true
+  end
+
+  # Owes great inspiration to test runner trailblazers like RSpec,
+  # minitest-reporters, maxitest, and others.
+  def self.plugin_rails_init(options)
+    # Don't mess with Minitest unless RAILS_ENV is set
+    return unless ENV["RAILS_ENV"] || ENV["RAILS_MINITEST_PLUGIN"]
+
+    unless options[:full_backtrace]
+      # Plugin can run without Rails loaded, check before filtering.
+      if ::Rails.respond_to?(:backtrace_cleaner)
+        Minitest.backtrace_filter = BacktraceFilterWithFallback.new(::Rails.backtrace_cleaner, Minitest.backtrace_filter)
+      end
+    end
+
+    # Suppress summary reports when outputting inline rerun snippets.
+    if reporter.reporters.reject! { |reporter| reporter.kind_of?(SummaryReporter) }
+      reporter << SuppressedSummaryReporter.new(options[:io], options)
+    end
+
+    # Replace progress reporter for colors.
+    if reporter.reporters.reject! { |reporter| reporter.kind_of?(ProgressReporter) }
+      reporter << ::Rails::TestUnitReporter.new(options[:io], options)
+    end
+
+    # Add slowest tests reporter at the end.
+    if options[:profile]
+      reporter << ProfileReporter.new(options[:io], options)
+    end
+  end
+
+  # Backwards compatibility with Rails 5.0 generated plugin test scripts
+  mattr_reader :run_via, default: {}
+end

data/lib/rails/all.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails"
+
+%w(
+  active_record/railtie
+  active_storage/engine
+  action_controller/railtie
+  action_view/railtie
+  action_mailer/railtie
+  active_job/railtie
+  action_cable/engine
+  action_mailbox/engine
+  action_text/engine
+  rails/test_unit/railtie
+).each do |railtie|
+  begin # rubocop:disable Style/RedundantBegin
+    require railtie
+  rescue LoadError
+  end
+end

data/lib/rails/api/generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "sdoc"
+require "active_support/core_ext/array/extract"
+
+class RDoc::Generator::API < RDoc::Generator::SDoc # :nodoc:
+  RDoc::RDoc.add_generator self
+
+  def generate_class_tree_level(classes, visited = {})
+    # Only process core extensions on the first visit and remove
+    # Active Storage duplicated classes that are at the top level
+    # since they aren't nested under a definition of the `ActiveStorage` module.
+    if visited.empty?
+      classes = classes.reject { |klass| active_storage?(klass) }
+      core_exts = classes.extract! { |klass| core_extension?(klass) }
+
+      super.unshift([ "Core extensions", "", "", build_core_ext_subtree(core_exts, visited) ])
+    else
+      super
+    end
+  end
+
+  private
+    def build_core_ext_subtree(classes, visited)
+      classes.map do |klass|
+        [ klass.name, klass.document_self_or_methods ? klass.path : "", "",
+            generate_class_tree_level(klass.classes_and_modules, visited) ]
+      end
+    end
+
+    def core_extension?(klass)
+      klass.name != "ActiveSupport" && klass.in_files.any? { |file| file.absolute_name.include?("core_ext") }
+    end
+
+    def active_storage?(klass)
+      klass.name != "ActiveStorage" && klass.in_files.all? { |file| file.absolute_name.include?("active_storage") }
+    end
+end