omg-railties 8.0.0.alpha3

data/lib/rails/generators.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+require "thor/group"
+require "rails/command"
+
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/hash/deep_merge"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/string/indent"
+require "active_support/core_ext/string/inflections"
+
+module Rails
+  module Generators
+    include Rails::Command::Behavior
+
+    autoload :Actions,         "rails/generators/actions"
+    autoload :ActiveModel,     "rails/generators/active_model"
+    autoload :Base,            "rails/generators/base"
+    autoload :Migration,       "rails/generators/migration"
+    autoload :Database,        "rails/generators/database"
+    autoload :AppName,         "rails/generators/app_name"
+    autoload :NamedBase,       "rails/generators/named_base"
+    autoload :ResourceHelpers, "rails/generators/resource_helpers"
+    autoload :TestCase,        "rails/generators/test_case"
+
+    mattr_accessor :namespace
+
+    DEFAULT_ALIASES = {
+      rails: {
+        actions: "-a",
+        orm: "-o",
+        javascripts: ["-j", "--js"],
+        resource_controller: "-c",
+        scaffold_controller: "-c",
+        stylesheets: "-y",
+        template_engine: "-e",
+        test_framework: "-t"
+      },
+
+      test_unit: {
+        fixture_replacement: "-r",
+      }
+    }
+
+    DEFAULT_OPTIONS = {
+      rails: {
+        api: false,
+        assets: true,
+        force_plural: false,
+        helper: true,
+        integration_tool: nil,
+        orm: false,
+        resource_controller: :controller,
+        resource_route: true,
+        scaffold_controller: :scaffold_controller,
+        system_tests: nil,
+        test_framework: nil,
+        template_engine: :erb
+      }
+    }
+
+    # We need to store the RAILS_DEV_PATH in a constant, otherwise the path
+    # can change when we FileUtils.cd.
+    RAILS_DEV_PATH = File.expand_path("../../..", __dir__) # :nodoc:
+
+    class << self
+      def configure!(config) # :nodoc:
+        api_only! if config.api_only
+        no_color! unless config.colorize_logging
+        aliases.deep_merge! config.aliases
+        options.deep_merge! config.options
+        fallbacks.merge! config.fallbacks
+        templates_path.concat config.templates
+        templates_path.uniq!
+        hide_namespaces(*config.hidden_namespaces)
+        after_generate_callbacks.replace config.after_generate_callbacks
+      end
+
+      def templates_path # :nodoc:
+        @templates_path ||= []
+      end
+
+      def aliases # :nodoc:
+        @aliases ||= DEFAULT_ALIASES.dup
+      end
+
+      def options # :nodoc:
+        @options ||= DEFAULT_OPTIONS.dup
+      end
+
+      def after_generate_callbacks # :nodoc:
+        @after_generate_callbacks ||= []
+      end
+
+      # Hold configured generators fallbacks. If a plugin developer wants a
+      # generator group to fall back to another group in case of missing generators,
+      # they can add a fallback.
+      #
+      # For example, shoulda is considered a test_framework and is an extension
+      # of test_unit. However, most part of shoulda generators are similar to
+      # test_unit ones.
+      #
+      # Shoulda then can tell generators to search for test_unit generators when
+      # some of them are not available by adding a fallback:
+      #
+      #   Rails::Generators.fallbacks[:shoulda] = :test_unit
+      def fallbacks
+        @fallbacks ||= {}
+      end
+
+      # Configure generators for API only applications. It basically hides
+      # everything that is usually browser related, such as assets and session
+      # migration generators, and completely disable helpers and assets
+      # so generators such as scaffold won't create them.
+      def api_only!
+        hide_namespaces "assets", "helper", "css", "js"
+
+        options[:rails].merge!(
+          api: true,
+          assets: false,
+          helper: false,
+          template_engine: nil
+        )
+
+        options[:mailer] ||= {}
+        options[:mailer][:template_engine] ||= :erb
+      end
+
+      # Returns an array of generator namespaces that are hidden.
+      # Generator namespaces may be hidden for a variety of reasons.
+      # Some are aliased such as "rails:migration" and can be
+      # invoked with the shorter "migration".
+      def hidden_namespaces
+        @hidden_namespaces ||= begin
+          orm      = options[:rails][:orm]
+          test     = options[:rails][:test_framework]
+          template = options[:rails][:template_engine]
+
+          [
+            "rails",
+            "resource_route",
+            "#{orm}:migration",
+            "#{orm}:model",
+            "#{test}:controller",
+            "#{test}:helper",
+            "#{test}:integration",
+            "#{test}:system",
+            "#{test}:mailer",
+            "#{test}:model",
+            "#{test}:scaffold",
+            "#{test}:view",
+            "#{test}:job",
+            "#{template}:controller",
+            "#{template}:scaffold",
+            "#{template}:mailer",
+            "action_text:install",
+            "action_mailbox:install",
+            "devcontainer"
+          ]
+        end
+      end
+
+      def hide_namespaces(*namespaces)
+        hidden_namespaces.concat(namespaces)
+      end
+      alias hide_namespace hide_namespaces
+
+      # Show help message with available generators.
+      def help(command = "generate")
+        puts "Usage:"
+        puts "  bin/rails #{command} GENERATOR [args] [options]"
+        puts
+        puts "General options:"
+        puts "  -h, [--help]     # Print generator's options and usage"
+        puts "  -p, [--pretend]  # Run but do not make any changes"
+        puts "  -f, [--force]    # Overwrite files that already exist"
+        puts "  -s, [--skip]     # Skip files that already exist"
+        puts "  -q, [--quiet]    # Suppress status output"
+        puts
+        puts "Please choose a generator below."
+        puts
+
+        print_generators
+      end
+
+      def public_namespaces
+        lookup!
+        subclasses.map(&:namespace)
+      end
+
+      def print_generators
+        sorted_groups.each { |b, n| print_list(b, n) }
+      end
+
+      def sorted_groups
+        namespaces = public_namespaces
+        namespaces.sort!
+
+        groups = Hash.new { |h, k| h[k] = [] }
+        namespaces.each do |namespace|
+          base = namespace.split(":").first
+          groups[base] << namespace
+        end
+
+        rails = groups.delete("rails")
+        rails.map! { |n| n.delete_prefix("rails:") }
+        rails.delete("app")
+        rails.delete("plugin")
+        rails.delete("encrypted_file")
+        rails.delete("encryption_key_file")
+        rails.delete("master_key")
+        rails.delete("credentials")
+        rails.delete("db:system:change")
+
+        hidden_namespaces.each { |n| groups.delete(n.to_s) }
+
+        [[ "rails", rails ]] + groups.sort.to_a
+      end
+
+      # Rails finds namespaces similar to Thor, it only adds one rule:
+      #
+      # Generators names must end with "_generator.rb". This is required because Rails
+      # looks in load paths and loads the generator just before it's going to be used.
+      #
+      #   find_by_namespace :webrat, :rails, :integration
+      #
+      # Will search for the following generators:
+      #
+      #   "rails:webrat", "webrat:integration", "webrat"
+      #
+      # Notice that "rails:generators:webrat" could be loaded as well, what
+      # Rails looks for is the first and last parts of the namespace.
+      def find_by_namespace(name, base = nil, context = nil) # :nodoc:
+        lookups = []
+        lookups << "#{base}:#{name}"    if base
+        lookups << "#{name}:#{context}" if context
+
+        unless base || context
+          unless name.to_s.include?(?:)
+            lookups << "#{name}:#{name}"
+            lookups << "rails:#{name}"
+          end
+          lookups << "#{name}"
+        end
+
+        lookup(lookups)
+
+        namespaces = subclasses.index_by(&:namespace)
+        lookups.each do |namespace|
+          klass = namespaces[namespace]
+          return klass if klass
+        end
+
+        invoke_fallbacks_for(name, base) || invoke_fallbacks_for(context, name)
+      end
+
+      # Receives a namespace, arguments, and the behavior to invoke the generator.
+      # It's used as the default entry point for generate, destroy, and update
+      # commands.
+      def invoke(namespace, args = ARGV, config = {})
+        names = namespace.to_s.split(":")
+        if klass = find_by_namespace(names.pop, names.any? && names.join(":"))
+          args << "--help" if args.empty? && klass.arguments.any?(&:required?)
+          klass.start(args, config)
+          run_after_generate_callback if config[:behavior] == :invoke
+        else
+          options = sorted_groups.flat_map(&:last)
+          error = Command::CorrectableNameError.new("Could not find generator '#{namespace}'.", namespace, options)
+
+          puts <<~MSG
+            #{error.detailed_message}
+            Run `bin/rails generate --help` for more options.
+          MSG
+        end
+      end
+
+      def add_generated_file(file) # :nodoc:
+        (@@generated_files ||= []) << file
+        file
+      end
+
+      private
+        def print_list(base, namespaces) # :doc:
+          namespaces = namespaces.reject { |n| hidden_namespaces.include?(n) }
+          super
+        end
+
+        # Try fallbacks for the given base.
+        def invoke_fallbacks_for(name, base)
+          return nil unless base && fallbacks[base.to_sym]
+          invoked_fallbacks = []
+
+          Array(fallbacks[base.to_sym]).each do |fallback|
+            next if invoked_fallbacks.include?(fallback)
+            invoked_fallbacks << fallback
+
+            klass = find_by_namespace(name, fallback)
+            return klass if klass
+          end
+
+          nil
+        end
+
+        def command_type # :doc:
+          @command_type ||= "generator"
+        end
+
+        def lookup_paths # :doc:
+          @lookup_paths ||= %w( rails/generators generators )
+        end
+
+        def file_lookup_paths # :doc:
+          @file_lookup_paths ||= [ "{#{lookup_paths.join(',')}}", "**", "*_generator.rb" ]
+        end
+
+        def run_after_generate_callback
+          if defined?(@@generated_files) && !@@generated_files.empty?
+            @after_generate_callbacks.each do |callback|
+              callback.call(@@generated_files)
+            end
+            @@generated_files = []
+          end
+        end
+    end
+  end
+end

data/lib/rails/health_controller.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rails
+  # Built-in Health Check Endpoint
+  #
+  # \Rails also comes with a built-in health check endpoint that is reachable at
+  # the +/up+ path. This endpoint will return a 200 status code if the app has
+  # booted with no exceptions, and a 500 status code otherwise.
+  #
+  # In production, many applications are required to report their status upstream,
+  # whether it's to an uptime monitor that will page an engineer when things go
+  # wrong, or a load balancer or Kubernetes controller used to determine a pod's
+  # health. This health check is designed to be a one-size fits all that will work
+  # in many situations.
+  #
+  # While any newly generated \Rails applications will have the health check at
+  # +/up+, you can configure the path to be anything you'd like in your
+  # <tt>"config/routes.rb"</tt>:
+  #
+  #   Rails.application.routes.draw do
+  #     get "healthz" => "rails/health#show", as: :rails_health_check
+  #   end
+  #
+  # The health check will now be accessible via the +/healthz+ path.
+  #
+  # NOTE: This endpoint does not reflect the status of all of your application's
+  # dependencies, such as the database or Redis cluster. Replace
+  # <tt>"rails/health#show"</tt> with your own controller action if you have
+  # application specific needs.
+  #
+  # Think carefully about what you want to check as it can lead to situations
+  # where your application is being restarted due to a third-party service going
+  # bad. Ideally, you should design your application to handle those outages
+  # gracefully.
+  class HealthController < ActionController::Base
+    rescue_from(Exception) { render_down }
+
+    def show
+      render_up
+    end
+
+    private
+      def render_up
+        render html: html_status(color: "green")
+      end
+
+      def render_down
+        render html: html_status(color: "red"), status: 500
+      end
+
+      def html_status(color:)
+        %(<!DOCTYPE html><html><body style="background-color: #{color}"></body></html>).html_safe
+      end
+  end
+end

data/lib/rails/info.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Rails
+  # This module helps build the runtime properties that are displayed in
+  # Rails::InfoController responses. These include the active \Rails version,
+  # Ruby version, Rack version, and so on.
+  module Info
+    mattr_accessor :properties, default: []
+
+    class << @@properties
+      def names
+        map(&:first)
+      end
+
+      def value_for(property_name)
+        if property = assoc(property_name)
+          property.last
+        end
+      end
+    end
+
+    class << self # :nodoc:
+      def property(name, value = nil)
+        value ||= yield
+        properties << [name, value] if value
+      rescue Exception
+      end
+
+      def to_s
+        column_width = properties.names.map(&:length).max
+        info = properties.map do |name, value|
+          value = value.join(", ") if value.is_a?(Array)
+          "%-#{column_width}s   %s" % [name, value]
+        end
+        info.unshift "About your application's environment"
+        info * "\n"
+      end
+
+      alias inspect to_s
+
+      def to_html
+        (+"<table>").tap do |table|
+          properties.each do |(name, value)|
+            table << %(<tr><td class="name">#{CGI.escapeHTML(name.to_s)}</td>)
+            formatted_value = if value.kind_of?(Array)
+              "<ul>" + value.map { |v| "<li>#{CGI.escapeHTML(v.to_s)}</li>" }.join + "</ul>"
+            else
+              CGI.escapeHTML(value.to_s)
+            end
+            table << %(<td class="value">#{formatted_value}</td></tr>)
+          end
+          table << "</table>"
+        end
+      end
+    end
+
+    # The Rails version.
+    property "Rails version" do
+      Rails.version.to_s
+    end
+
+    # The Ruby version and platform, e.g. "2.0.0-p247 (x86_64-darwin12.4.0)".
+    property "Ruby version" do
+      RUBY_DESCRIPTION
+    end
+
+    # The RubyGems version, if it's installed.
+    property "RubyGems version" do
+      Gem::VERSION
+    end
+
+    property "Rack version" do
+      ::Rack.release
+    end
+
+    property "JavaScript Runtime" do
+      ExecJS.runtime.name
+    end
+
+    property "Middleware" do
+      Rails.configuration.middleware.map(&:inspect)
+    end
+
+    # The application's location on the filesystem.
+    property "Application root" do
+      File.expand_path(Rails.root)
+    end
+
+    # The current Rails environment (development, test, or production).
+    property "Environment" do
+      Rails.env
+    end
+
+    # The name of the database adapter for the current environment.
+    property "Database adapter" do
+      ActiveRecord::Base.connection_pool.db_config.adapter
+    end
+
+    property "Database schema version" do
+      ActiveRecord::Base.connection_pool.migration_context.current_version rescue nil
+    end
+  end
+end

data/lib/rails/info_controller.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "rails/application_controller"
+require "action_dispatch/routing/inspector"
+
+class Rails::InfoController < Rails::ApplicationController # :nodoc:
+  prepend_view_path ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS
+  layout -> { request.xhr? ? false : "application" }
+
+  before_action :require_local!
+
+  def index
+    redirect_to action: :routes
+  end
+
+  def properties
+    @info = Rails::Info.to_html
+    @page_title = "Properties"
+  end
+
+  def routes
+    if query = params[:query]
+      query = URI::RFC2396_PARSER.escape query
+
+      render json: {
+        exact: matching_routes(query: query, exact_match: true),
+        fuzzy: matching_routes(query: query, exact_match: false)
+      }
+    else
+      @routes_inspector = ActionDispatch::Routing::RoutesInspector.new(_routes.routes)
+      @page_title = "Routes"
+    end
+  end
+
+  def notes
+    @annotations = Rails::SourceAnnotationExtractor.new(
+      Rails::SourceAnnotationExtractor::Annotation.tags.join("|")
+    ).find(
+      Rails::SourceAnnotationExtractor::Annotation.directories
+    )
+  end
+
+  private
+    def matching_routes(query:, exact_match:)
+      return [] if query.blank?
+
+      normalized_path = ("/" + query).squeeze("/")
+      query_without_url_or_path_suffix = query.gsub(/(\w)(_path$)/, '\1').gsub(/(\w)(_url$)/, '\1')
+
+      _routes.routes.filter_map do |route|
+        route_wrapper = ActionDispatch::Routing::RouteWrapper.new(route)
+
+        if exact_match
+          match = route.path.match(normalized_path)
+          match ||= (query_without_url_or_path_suffix === route_wrapper.name)
+        else
+          match = route_wrapper.path.match(query)
+          match ||= route_wrapper.name.include?(query_without_url_or_path_suffix)
+        end
+
+        match ||= (query === route_wrapper.verb)
+
+        unless match
+          controller_action = URI::RFC2396_PARSER.escape(route_wrapper.reqs)
+          match = exact_match ? (query === controller_action) : controller_action.include?(query)
+        end
+
+        route_wrapper.path if match
+      end
+    end
+end

data/lib/rails/initializable.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "tsort"
+
+module Rails
+  module Initializable
+    def self.included(base) # :nodoc:
+      base.extend ClassMethods
+    end
+
+    class Initializer
+      attr_reader :name, :block
+
+      def initialize(name, context, options, &block)
+        options[:group] ||= :default
+        @name, @context, @options, @block = name, context, options, block
+      end
+
+      def before
+        @options[:before]
+      end
+
+      def after
+        @options[:after]
+      end
+
+      def belongs_to?(group)
+        @options[:group] == group || @options[:group] == :all
+      end
+
+      def run(*args)
+        @context.instance_exec(*args, &block)
+      end
+
+      def bind(context)
+        return self if @context
+        Initializer.new(@name, context, @options, &block)
+      end
+
+      def context_class
+        @context.class
+      end
+    end
+
+    class Collection < Array
+      include TSort
+
+      alias :tsort_each_node :each
+      def tsort_each_child(initializer, &block)
+        select { |i| i.before == initializer.name || i.name == initializer.after }.each(&block)
+      end
+
+      def +(other)
+        Collection.new(to_a + other.to_a)
+      end
+    end
+
+    def run_initializers(group = :default, *args)
+      return if instance_variable_defined?(:@ran)
+      initializers.tsort_each do |initializer|
+        initializer.run(*args) if initializer.belongs_to?(group)
+      end
+      @ran = true
+    end
+
+    def initializers
+      @initializers ||= self.class.initializers_for(self)
+    end
+
+    module ClassMethods
+      def initializers
+        @initializers ||= Collection.new
+      end
+
+      def initializers_chain
+        initializers = Collection.new
+        ancestors.reverse_each do |klass|
+          next unless klass.respond_to?(:initializers)
+          initializers = initializers + klass.initializers
+        end
+        initializers
+      end
+
+      def initializers_for(binding)
+        Collection.new(initializers_chain.map { |i| i.bind(binding) })
+      end
+
+      def initializer(name, opts = {}, &blk)
+        raise ArgumentError, "A block must be passed when defining an initializer" unless blk
+        opts[:after] ||= initializers.last.name unless initializers.empty? || initializers.find { |i| i.name == opts[:before] }
+        initializers << Initializer.new(name, nil, opts, &blk)
+      end
+    end
+  end
+end