omg-railties 8.0.0.alpha3

data/lib/rails/railtie.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require "rails/initializable"
+require "active_support/descendants_tracker"
+require "active_support/inflector"
+require "active_support/core_ext/module/introspection"
+require "active_support/core_ext/module/delegation"
+
+module Rails
+  # +Rails::Railtie+ is the core of the \Rails framework and provides
+  # several hooks to extend \Rails and/or modify the initialization process.
+  #
+  # Every major component of \Rails (Action Mailer, Action Controller, Active
+  # Record, etc.) implements a railtie. Each of them is responsible for their
+  # own initialization. This makes \Rails itself absent of any component hooks,
+  # allowing other components to be used in place of any of the \Rails defaults.
+  #
+  # Developing a \Rails extension does _not_ require implementing a railtie, but
+  # if you need to interact with the \Rails framework during or after boot, then
+  # a railtie is needed.
+  #
+  # For example, an extension doing any of the following would need a railtie:
+  #
+  # * creating initializers
+  # * configuring a \Rails framework for the application, like setting a generator
+  # * adding <tt>config.*</tt> keys to the environment
+  # * setting up a subscriber with ActiveSupport::Notifications
+  # * adding Rake tasks
+  #
+  # == Creating a Railtie
+  #
+  # To extend \Rails using a railtie, create a subclass of +Rails::Railtie+.
+  # This class must be loaded during the \Rails boot process, and is conventionally
+  # called +MyNamespace::Railtie+.
+  #
+  # The following example demonstrates an extension which can be used with or
+  # without \Rails.
+  #
+  #   # lib/my_gem/railtie.rb
+  #   module MyGem
+  #     class Railtie < Rails::Railtie
+  #     end
+  #   end
+  #
+  #   # lib/my_gem.rb
+  #   require "my_gem/railtie" if defined?(Rails::Railtie)
+  #
+  # == Initializers
+  #
+  # To add an initialization step to the \Rails boot process from your railtie, just
+  # define the initialization code with the +initializer+ macro:
+  #
+  #   class MyGem::Railtie < Rails::Railtie
+  #     initializer "my_gem.configure_rails_initialization" do
+  #       # some initialization behavior
+  #     end
+  #   end
+  #
+  # If specified, the block can also receive the application object, in case you
+  # need to access some application-specific configuration, like middleware:
+  #
+  #   class MyGem::Railtie < Rails::Railtie
+  #     initializer "my_gem.configure_rails_initialization" do |app|
+  #       app.middleware.use MyGem::Middleware
+  #     end
+  #   end
+  #
+  # Finally, you can also pass <tt>:before</tt> and <tt>:after</tt> as options to
+  # +initializer+, in case you want to couple it with a specific step in the
+  # initialization process.
+  #
+  # == Configuration
+  #
+  # Railties can access a config object which contains configuration shared by all
+  # railties and the application:
+  #
+  #   class MyGem::Railtie < Rails::Railtie
+  #     # Customize the ORM
+  #     config.app_generators.orm :my_gem_orm
+  #
+  #     # Add a to_prepare block which is executed once in production
+  #     # and before each request in development.
+  #     config.to_prepare do
+  #       MyGem.setup!
+  #     end
+  #   end
+  #
+  # == Loading Rake Tasks and Generators
+  #
+  # If your railtie has Rake tasks, you can tell \Rails to load them through the method
+  # +rake_tasks+:
+  #
+  #   class MyGem::Railtie < Rails::Railtie
+  #     rake_tasks do
+  #       load "path/to/my_gem.tasks"
+  #     end
+  #   end
+  #
+  # By default, \Rails loads generators from your load path. However, if you want to place
+  # your generators at a different location, you can specify in your railtie a block which
+  # will load them during normal generators lookup:
+  #
+  #   class MyGem::Railtie < Rails::Railtie
+  #     generators do
+  #       require "path/to/my_gem_generator"
+  #     end
+  #   end
+  #
+  # Since filenames on the load path are shared across gems, be sure that files you load
+  # through a railtie have unique names.
+  #
+  # == Run another program when the \Rails server starts
+  #
+  # In development, it's very usual to have to run another process next to the \Rails Server. In example
+  # you might want to start the Webpack or React server. Or maybe you need to run your job scheduler process
+  # like Sidekiq. This is usually done by opening a new shell and running the program from here.
+  #
+  # \Rails allow you to specify a +server+ block which will get called when a \Rails server starts.
+  # This way, your users don't need to remember to have to open a new shell and run another program, making
+  # this less confusing for everyone.
+  # It can be used like this:
+  #
+  #   class MyGem::Railtie < Rails::Railtie
+  #     server do
+  #       WebpackServer.start
+  #     end
+  #   end
+  #
+  # == Application and Engine
+  #
+  # An engine is nothing more than a railtie with some initializers already set. And since
+  # Rails::Application is an engine, the same configuration described here can be
+  # used in both.
+  #
+  # Be sure to look at the documentation of those specific classes for more information.
+  class Railtie
+    autoload :Configuration, "rails/railtie/configuration"
+
+    extend ActiveSupport::DescendantsTracker
+    include Initializable
+
+    ABSTRACT_RAILTIES = %w(Rails::Railtie Rails::Engine Rails::Application)
+
+    class << self
+      private :new
+      delegate :config, to: :instance
+
+      def subclasses
+        super.reject(&:abstract_railtie?).sort
+      end
+
+      def rake_tasks(&blk)
+        register_block_for(:rake_tasks, &blk)
+      end
+
+      def console(&blk)
+        register_block_for(:load_console, &blk)
+      end
+
+      def runner(&blk)
+        register_block_for(:runner, &blk)
+      end
+
+      def generators(&blk)
+        register_block_for(:generators, &blk)
+      end
+
+      def server(&blk)
+        register_block_for(:server, &blk)
+      end
+
+      def abstract_railtie?
+        ABSTRACT_RAILTIES.include?(name)
+      end
+
+      def railtie_name(name = nil)
+        @railtie_name = name.to_s if name
+        @railtie_name ||= generate_railtie_name(self.name)
+      end
+
+      # Since Rails::Railtie cannot be instantiated, any methods that call
+      # +instance+ are intended to be called only on subclasses of a Railtie.
+      def instance
+        @instance ||= new
+      end
+
+      # Allows you to configure the railtie. This is the same method seen in
+      # Railtie::Configurable, but this module is no longer required for all
+      # subclasses of Railtie so we provide the class method here.
+      def configure(&block)
+        instance.configure(&block)
+      end
+
+      def <=>(other) # :nodoc:
+        load_index <=> other.load_index
+      end
+
+      def inherited(subclass)
+        subclass.increment_load_index
+        super
+      end
+
+      protected
+        attr_reader :load_index
+
+        def increment_load_index
+          @@load_counter ||= 0
+          @load_index = (@@load_counter += 1)
+        end
+
+      private
+        def generate_railtie_name(string)
+          ActiveSupport::Inflector.underscore(string).tr("/", "_")
+        end
+
+        def respond_to_missing?(name, _)
+          return super if abstract_railtie?
+
+          instance.respond_to?(name) || super
+        end
+
+        # If the class method does not have a method, then send the method call
+        # to the Railtie instance.
+        def method_missing(name, ...)
+          if !abstract_railtie? && instance.respond_to?(name)
+            instance.public_send(name, ...)
+          else
+            super
+          end
+        end
+
+        # receives an instance variable identifier, set the variable value if is
+        # blank and append given block to value, which will be used later in
+        # `#each_registered_block(type, &block)`
+        def register_block_for(type, &blk)
+          var_name = "@#{type}"
+          blocks = instance_variable_defined?(var_name) ? instance_variable_get(var_name) : instance_variable_set(var_name, [])
+          blocks << blk if blk
+          blocks
+        end
+    end
+
+    delegate :railtie_name, to: :class
+
+    def initialize # :nodoc:
+      if self.class.abstract_railtie?
+        raise "#{self.class.name} is abstract, you cannot instantiate it directly."
+      end
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name}>"
+    end
+
+    def configure(&block) # :nodoc:
+      instance_eval(&block)
+    end
+
+    # This is used to create the <tt>config</tt> object on Railties, an instance of
+    # Railtie::Configuration, that is used by Railties and Application to store
+    # related configuration.
+    def config
+      @config ||= Railtie::Configuration.new
+    end
+
+    def railtie_namespace # :nodoc:
+      @railtie_namespace ||= self.class.module_parents.detect { |n| n.respond_to?(:railtie_namespace) }
+    end
+
+    protected
+      def run_console_blocks(app) # :nodoc:
+        each_registered_block(:console) { |block| block.call(app) }
+      end
+
+      def run_generators_blocks(app) # :nodoc:
+        each_registered_block(:generators) { |block| block.call(app) }
+      end
+
+      def run_runner_blocks(app) # :nodoc:
+        each_registered_block(:runner) { |block| block.call(app) }
+      end
+
+      def run_tasks_blocks(app) # :nodoc:
+        extend Rake::DSL
+        each_registered_block(:rake_tasks) { |block| instance_exec(app, &block) }
+      end
+
+      def run_server_blocks(app) # :nodoc:
+        each_registered_block(:server) { |block| block.call(app) }
+      end
+
+    private
+      # run `&block` in every registered block in `#register_block_for`
+      def each_registered_block(type, &block)
+        klass = self.class
+        while klass.respond_to?(type)
+          klass.public_send(type).each(&block)
+          klass = klass.superclass
+        end
+      end
+  end
+end

data/lib/rails/source_annotation_extractor.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+begin
+  require "prism"
+rescue LoadError
+  # If Prism isn't available (because of using an older Ruby version) then we'll
+  # define a fallback for the ParserExtractor using ripper.
+  require "ripper"
+end
+
+module Rails
+  # Implements the logic behind +Rails::Command::NotesCommand+. See <tt>rails notes --help</tt> for usage information.
+  #
+  # Annotation objects are triplets <tt>:line</tt>, <tt>:tag</tt>, <tt>:text</tt> that
+  # represent the line where the annotation lives, its tag, and its text. Note
+  # the filename is not stored.
+  #
+  # Annotations are looked for in comments and modulus whitespace they have to
+  # start with the tag optionally followed by a colon. Everything up to the end
+  # of the line (or closing ERB comment tag) is considered to be their text.
+  class SourceAnnotationExtractor
+    # Wraps a regular expression that will be tested against each of the source
+    # file's comments.
+    class ParserExtractor < Struct.new(:pattern)
+      if defined?(Prism)
+        def annotations(file)
+          result = Prism.parse_file(file)
+          return [] unless result.success?
+
+          result.comments.filter_map do |comment|
+            Annotation.new(comment.location.start_line, $1, $2) if comment.location.slice =~ pattern
+          end
+        end
+      else
+        class Parser < Ripper
+          attr_reader :comments, :pattern
+
+          def initialize(source, pattern:)
+            super(source)
+            @pattern = pattern
+            @comments = []
+          end
+
+          def on_comment(value)
+            @comments << Annotation.new(lineno, $1, $2) if value =~ pattern
+          end
+        end
+
+        def annotations(file)
+          contents = File.read(file, encoding: Encoding::BINARY)
+          parser = Parser.new(contents, pattern: pattern).tap(&:parse)
+          parser.error? ? [] : parser.comments
+        end
+      end
+    end
+
+    # Wraps a regular expression that will iterate through a file's lines and
+    # test each one for the given pattern.
+    class PatternExtractor < Struct.new(:pattern)
+      def annotations(file)
+        lineno = 0
+
+        File.readlines(file, encoding: Encoding::BINARY).inject([]) do |list, line|
+          lineno += 1
+          next list unless line =~ pattern
+          list << Annotation.new(lineno, $1, $2)
+        end
+      end
+    end
+
+    class Annotation < Struct.new(:line, :tag, :text)
+      def self.directories
+        @@directories ||= %w(app config db lib test)
+      end
+
+      # Registers additional directories to be included
+      #   Rails::SourceAnnotationExtractor::Annotation.register_directories("spec", "another")
+      def self.register_directories(*dirs)
+        directories.push(*dirs)
+      end
+
+      def self.tags
+        @@tags ||= %w(OPTIMIZE FIXME TODO)
+      end
+
+      # Registers additional tags
+      #   Rails::SourceAnnotationExtractor::Annotation.register_tags("TESTME", "DEPRECATEME")
+      def self.register_tags(*additional_tags)
+        tags.push(*additional_tags)
+      end
+
+      def self.extensions
+        @@extensions ||= {}
+      end
+
+      # Registers new Annotations File Extensions
+      #   Rails::SourceAnnotationExtractor::Annotation.register_extensions("css", "scss", "sass", "less", "js") { |tag| /\/\/\s*(#{tag}):?\s*(.*)$/ }
+      def self.register_extensions(*exts, &block)
+        extensions[/\.(#{exts.join("|")})$/] = block
+      end
+
+      register_extensions("builder", "rb", "rake", "ruby") do |tag|
+        ParserExtractor.new(/#\s*(#{tag}):?\s*(.*)$/)
+      end
+
+      register_extensions("yml", "yaml") do |tag|
+        PatternExtractor.new(/#\s*(#{tag}):?\s*(.*)$/)
+      end
+
+      register_extensions("css", "js") do |tag|
+        PatternExtractor.new(/\/\/\s*(#{tag}):?\s*(.*)$/)
+      end
+
+      register_extensions("erb") do |tag|
+        PatternExtractor.new(/<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/)
+      end
+
+      # Returns a representation of the annotation that looks like this:
+      #
+      #   [126] [TODO] This algorithm is simple and clearly correct, make it faster.
+      #
+      # If +options+ has a flag <tt>:tag</tt> the tag is shown as in the example above.
+      # Otherwise the string contains just line and text.
+      def to_s(options = {})
+        s = +"[#{line.to_s.rjust(options[:indent])}] "
+        s << "[#{tag}] " if options[:tag]
+        s << text
+      end
+    end
+
+    # Prints all annotations with tag +tag+ under the root directories +app+,
+    # +config+, +db+, +lib+, and +test+ (recursively).
+    #
+    # If +tag+ is <tt>nil</tt>, annotations with either default or registered tags are printed.
+    #
+    # Specific directories can be explicitly set using the <tt>:dirs</tt> key in +options+.
+    #
+    #   Rails::SourceAnnotationExtractor.enumerate 'TODO|FIXME', dirs: %w(app lib), tag: true
+    #
+    # If +options+ has a <tt>:tag</tt> flag, it will be passed to each annotation's +to_s+.
+    #
+    # See SourceAnnotationExtractor#find_in for a list of file extensions that will be taken into account.
+    #
+    # This class method is the single entry point for the <tt>rails notes</tt> command.
+    def self.enumerate(tag = nil, options = {})
+      tag ||= Annotation.tags.join("|")
+      extractor = new(tag)
+      dirs = options.delete(:dirs) || Annotation.directories
+      extractor.display(extractor.find(dirs), options)
+    end
+
+    attr_reader :tag
+
+    def initialize(tag)
+      @tag = tag
+    end
+
+    # Returns a hash that maps filenames under +dirs+ (recursively) to arrays
+    # with their annotations.
+    def find(dirs)
+      dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
+    end
+
+    # Returns a hash that maps filenames under +dir+ (recursively) to arrays
+    # with their annotations. Files with extensions registered in
+    # <tt>Rails::SourceAnnotationExtractor::Annotation.extensions</tt> are
+    # taken into account. Only files with annotations are included.
+    def find_in(dir)
+      results = {}
+
+      Dir.glob("#{dir}/*") do |item|
+        next if File.basename(item).start_with?(".")
+
+        if File.directory?(item)
+          results.update(find_in(item))
+        else
+          extension = Annotation.extensions.detect do |regexp, _block|
+            regexp.match(item)
+          end
+
+          if extension
+            pattern = extension.last.call(tag)
+
+            # In case a user-defined pattern returns nothing for the given set
+            # of tags, we exit early.
+            next unless pattern
+
+            # If a user-defined pattern returns a regular expression, we will
+            # wrap it in a PatternExtractor to keep the same API.
+            pattern = PatternExtractor.new(pattern) if pattern.is_a?(Regexp)
+
+            annotations = pattern.annotations(item)
+            results.update(item => annotations) if annotations.any?
+          end
+        end
+      end
+
+      results
+    end
+
+    # Prints the mapping from filenames to annotations in +results+ ordered by filename.
+    # The +options+ hash is passed to each annotation's +to_s+.
+    def display(results, options = {})
+      options[:indent] = results.flat_map { |f, a| a.map(&:line) }.max.to_s.size
+      results.keys.sort.each do |file|
+        puts "#{file}:"
+        results[file].each do |note|
+          puts "  * #{note.to_s(options)}"
+        end
+        puts
+      end
+    end
+  end
+end

data/lib/rails/tasks/engine.rake

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+task "load_app" do
+  namespace :app do
+    load APP_RAKEFILE
+
+    desc "Update some initially generated files"
+    task update: [ "update:bin" ]
+
+    namespace :update do
+      require "rails/engine/updater"
+      # desc "Adds new executables to the engine bin/ directory"
+      task :bin do
+        Rails::Engine::Updater.run(:create_bin_files)
+      end
+    end
+  end
+  task environment: "app:environment"
+
+  if !defined?(ENGINE_ROOT) || !ENGINE_ROOT
+    ENGINE_ROOT = find_engine_path(Pathname.new(APP_RAKEFILE))
+  end
+end
+
+def app_task(name)
+  task name => [:load_app, "app:db:#{name}"]
+end
+
+namespace :db do
+  app_task "reset"
+
+  desc "Migrate the database (options: VERSION=x, VERBOSE=false)."
+  app_task "migrate"
+  app_task "migrate:up"
+  app_task "migrate:down"
+  app_task "migrate:redo"
+  app_task "migrate:reset"
+
+  desc "Display status of migrations"
+  app_task "migrate:status"
+
+  desc "Create the database from config/database.yml for the current Rails.env (use db:create:all to create all databases in the config)"
+  app_task "create"
+  app_task "create:all"
+
+  desc "Drop the database for the current Rails.env (use db:drop:all to drop all databases)"
+  app_task "drop"
+  app_task "drop:all"
+
+  desc "Load fixtures into the current environment's database."
+  app_task "fixtures:load"
+
+  desc "Roll the schema back to the previous version (specify steps w/ STEP=n)."
+  app_task "rollback"
+
+  desc "Create a database schema file (either db/schema.rb or db/structure.sql, depending on `config.active_record.schema_format`)"
+  app_task "schema:dump"
+
+  desc "Load a schema.rb file into the database"
+  app_task "schema:load"
+
+  desc "Load the seed data from db/seeds.rb"
+  app_task "seed"
+
+  desc "Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the database first)"
+  app_task "setup"
+
+  desc "Retrieve the current schema version number"
+  app_task "version"
+
+  # desc 'Load the test schema'
+  app_task "test:prepare"
+end
+
+def find_engine_path(path)
+  return File.expand_path(Dir.pwd) if path.root?
+
+  if Rails::Engine.find(path)
+    path.to_s
+  else
+    find_engine_path(path.join(".."))
+  end
+end
+
+Rake.application.invoke_task(:load_app)

data/lib/rails/tasks/framework.rake

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+namespace :app do
+  desc "Apply the template supplied by LOCATION=(/path/to/template) or URL"
+  task template: :environment do
+    template = ENV["LOCATION"]
+    raise "No LOCATION value given. Please set LOCATION either as path to a file or a URL" if template.blank?
+    require "rails/generators"
+    require "rails/generators/rails/app/app_generator"
+    Rails::Generators::AppGenerator.apply_rails_template(template, Rails.root)
+  end
+
+  namespace :templates do
+    # desc "Copy all the templates from rails to the application directory for customization. Already existing local copies will be overwritten"
+    task :copy do
+      generators_lib = File.expand_path("../generators", __dir__)
+      project_templates = "#{Rails.root}/lib/templates"
+
+      default_templates = { "erb"   => %w{controller mailer scaffold},
+                            "rails" => %w{controller helper scaffold_controller} }
+
+      default_templates.each do |type, names|
+        local_template_type_dir = File.join(project_templates, type)
+        mkdir_p local_template_type_dir, verbose: false
+
+        names.each do |name|
+          dst_name = File.join(local_template_type_dir, name)
+          src_name = File.join(generators_lib, type, name, "templates")
+          cp_r src_name, dst_name, verbose: false
+        end
+      end
+    end
+  end
+end

data/lib/rails/tasks/log.rake

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+namespace :log do
+  ##
+  # Truncates all/specified log files
+  # ENV['LOGS']
+  #   - defaults to all environments log files i.e. 'development,test,production'
+  #   - ENV['LOGS']=all truncates all files i.e. log/*.log
+  #   - ENV['LOGS']='test,development' truncates only specified files
+  desc "Truncate all/specified *.log files in log/ to zero bytes (specify which logs with LOGS=test,development)"
+  task :clear do
+    log_files.each do |file|
+      clear_log_file(file)
+    end
+  end
+
+  def log_files
+    if ENV["LOGS"] == "all"
+      FileList["log/*.log"]
+    elsif ENV["LOGS"]
+      log_files_to_truncate(ENV["LOGS"])
+    else
+      log_files_to_truncate(all_environments.join(","))
+    end
+  end
+
+  def log_files_to_truncate(envs)
+    envs.split(",")
+        .map    { |file| "log/#{file.strip}.log" }
+        .select { |file| File.exist?(file) }
+  end
+
+  def clear_log_file(file)
+    f = File.open(file, "w")
+    f.close
+  end
+
+  def all_environments
+    Dir["config/environments/*.rb"].map { |fname| File.basename(fname, ".*") }
+  end
+end