omg-railties 8.0.0.alpha3

data/lib/rails/generators/generated_attribute.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "active_support/time"
+require "active_support/core_ext/string/starts_ends_with"
+
+module Rails
+  module Generators
+    class GeneratedAttribute # :nodoc:
+      INDEX_OPTIONS = %w(index uniq)
+      UNIQ_INDEX_OPTIONS = %w(uniq)
+      DEFAULT_TYPES = %w(
+        attachment
+        attachments
+        belongs_to
+        boolean
+        date
+        datetime
+        decimal
+        digest
+        float
+        integer
+        references
+        rich_text
+        string
+        text
+        time
+        timestamp
+        token
+      )
+
+      attr_accessor :name, :type
+      attr_reader   :attr_options
+      attr_writer   :index_name
+
+      class << self
+        def parse(column_definition)
+          name, type, index_type = column_definition.split(":")
+
+          # if user provided "name:index" instead of "name:string:index"
+          # type should be set blank so GeneratedAttribute's constructor
+          # could set it to :string
+          index_type, type = type, nil if valid_index_type?(type)
+
+          type, attr_options = *parse_type_and_options(type)
+          type = type.to_sym if type
+
+          if dangerous_name?(name)
+            raise Error, "Could not generate field '#{name}', as it is already defined by Active Record."
+          end
+
+          if type && !valid_type?(type)
+            raise Error, "Could not generate field '#{name}' with unknown type '#{type}'."
+          end
+
+          if index_type && !valid_index_type?(index_type)
+            raise Error, "Could not generate field '#{name}' with unknown index '#{index_type}'."
+          end
+
+          if type && reference?(type)
+            if UNIQ_INDEX_OPTIONS.include?(index_type)
+              attr_options[:index] = { unique: true }
+            end
+          end
+
+          new(name, type, index_type, attr_options)
+        end
+
+        def dangerous_name?(name)
+          defined?(ActiveRecord::Base) &&
+            ActiveRecord::Base.dangerous_attribute_method?(name)
+        end
+
+        def valid_type?(type)
+          DEFAULT_TYPES.include?(type.to_s) ||
+            !defined?(ActiveRecord::Base) ||
+            ActiveRecord::Base.lease_connection.valid_type?(type)
+        end
+
+        def valid_index_type?(index_type)
+          INDEX_OPTIONS.include?(index_type.to_s)
+        end
+
+        def reference?(type)
+          [:references, :belongs_to].include? type
+        end
+
+        private
+          # parse possible attribute options like :limit for string/text/binary/integer, :precision/:scale for decimals or :polymorphic for references/belongs_to
+          # when declaring options curly brackets should be used
+          def parse_type_and_options(type)
+            case type
+            when /(text|binary)\{([a-z]+)\}/
+              parsed_type, parsed_options = $1, { size: $2.to_sym }
+            when /(string|text|binary|integer)\{(\d+)\}/
+              parsed_type, parsed_options = $1, { limit: $2.to_i }
+            when /decimal\{(\d+)[,.-](\d+)\}/
+              parsed_type, parsed_options = :decimal, { precision: $1.to_i, scale: $2.to_i }
+            when /(references|belongs_to)\{(.+)\}/
+              parsed_type = $1
+              provided_options = $2.split(/[,.-]/)
+              parsed_options = Hash[provided_options.map { |opt| [opt.to_sym, true] }]
+            else
+              parsed_type, parsed_options = type&.remove("!"), {}
+            end
+
+            if type&.ends_with?("!")
+              parsed_options[:null] = false
+            end
+
+            return parsed_type, parsed_options
+          end
+      end
+
+      def initialize(name, type = nil, index_type = false, attr_options = {})
+        @name           = name
+        @type           = type || :string
+        @has_index      = INDEX_OPTIONS.include?(index_type)
+        @has_uniq_index = UNIQ_INDEX_OPTIONS.include?(index_type)
+        @attr_options   = attr_options
+      end
+
+      def field_type
+        @field_type ||= case type
+                        when :integer                  then :number_field
+                        when :float, :decimal          then :text_field
+                        when :time                     then :time_field
+                        when :datetime, :timestamp     then :datetime_field
+                        when :date                     then :date_field
+                        when :text                     then :textarea
+                        when :rich_text                then :rich_textarea
+                        when :boolean                  then :checkbox
+                        when :attachment, :attachments then :file_field
+                        else
+                          :text_field
+        end
+      end
+
+      def default
+        @default ||= case type
+                     when :integer                     then 1
+                     when :float                       then 1.5
+                     when :decimal                     then "9.99"
+                     when :datetime, :timestamp, :time then Time.now.to_fs(:db)
+                     when :date                        then Date.today.to_fs(:db)
+                     when :string                      then name == "type" ? "" : "MyString"
+                     when :text                        then "MyText"
+                     when :boolean                     then false
+                     when :references, :belongs_to,
+                          :attachment, :attachments,
+                          :rich_text                   then nil
+                     else
+                       ""
+        end
+      end
+
+      def plural_name
+        name.delete_suffix("_id").pluralize
+      end
+
+      def singular_name
+        name.delete_suffix("_id").singularize
+      end
+
+      def human_name
+        name.humanize
+      end
+
+      def index_name
+        @index_name ||= if polymorphic?
+          %w(id type).map { |t| "#{name}_#{t}" }
+        else
+          column_name
+        end
+      end
+
+      def column_name
+        @column_name ||= reference? ? "#{name}_id" : name
+      end
+
+      def foreign_key?
+        name.end_with?("_id")
+      end
+
+      def reference?
+        self.class.reference?(type)
+      end
+
+      def polymorphic?
+        attr_options[:polymorphic]
+      end
+
+      def required?
+        reference? && Rails.application.config.active_record.belongs_to_required_by_default
+      end
+
+      def has_index?
+        @has_index
+      end
+
+      def has_uniq_index?
+        @has_uniq_index
+      end
+
+      def password_digest?
+        name == "password" && type == :digest
+      end
+
+      def token?
+        type == :token
+      end
+
+      def rich_text?
+        type == :rich_text
+      end
+
+      def attachment?
+        type == :attachment
+      end
+
+      def attachments?
+        type == :attachments
+      end
+
+      def virtual?
+        rich_text? || attachment? || attachments?
+      end
+
+      def inject_options
+        (+"").tap { |s| options_for_migration.each { |k, v| s << ", #{k}: #{v.inspect}" } }
+      end
+
+      def inject_index_options
+        has_uniq_index? ? ", unique: true" : ""
+      end
+
+      def options_for_migration
+        @attr_options.dup.tap do |options|
+          if required?
+            options[:null] = false
+          end
+
+          if reference? && !polymorphic?
+            options[:foreign_key] = true
+          end
+        end
+      end
+
+      def to_s
+        if has_uniq_index?
+          "#{name}:#{type}#{print_attribute_options}:uniq"
+        elsif has_index?
+          "#{name}:#{type}#{print_attribute_options}:index"
+        else
+          "#{name}:#{type}#{print_attribute_options}"
+        end
+      end
+
+      private
+        def print_attribute_options
+          if attr_options.empty?
+            ""
+          elsif attr_options[:size]
+            "{#{attr_options[:size]}}"
+          elsif attr_options[:limit]
+            "{#{attr_options[:limit]}}"
+          elsif attr_options[:precision] && attr_options[:scale]
+            "{#{attr_options[:precision]},#{attr_options[:scale]}}"
+          else
+            "{#{attr_options.keys.join(",")}}"
+          end
+        end
+    end
+  end
+end

data/lib/rails/generators/migration.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "rails/generators/actions/create_migration"
+
+module Rails
+  module Generators
+    # Holds common methods for migrations. It assumes that migrations have the
+    # [0-9]*_name format and can be used by other frameworks (like Sequel)
+    # just by implementing the +next_migration_number+ method.
+    module Migration
+      extend ActiveSupport::Concern
+      attr_reader :migration_number, :migration_file_name, :migration_class_name
+
+      module ClassMethods # :nodoc:
+        def migration_lookup_at(dirname)
+          Dir.glob("#{dirname}/[0-9]*_*.rb")
+        end
+
+        def migration_exists?(dirname, file_name)
+          migration_lookup_at(dirname).grep(/\d+_#{file_name}.rb$/).first
+        end
+
+        def current_migration_number(dirname)
+          migration_lookup_at(dirname).collect do |file|
+            File.basename(file).split("_").first.to_i
+          end.max.to_i
+        end
+
+        def next_migration_number(dirname)
+          raise NotImplementedError
+        end
+      end
+
+      def create_migration(destination, data, config = {}, &block)
+        action Rails::Generators::Actions::CreateMigration.new(self, destination, block || data.to_s, config)
+      end
+
+      def set_migration_assigns!(destination)
+        destination = File.expand_path(destination, destination_root)
+
+        migration_dir = File.dirname(destination)
+        @migration_number     = self.class.next_migration_number(migration_dir)
+        @migration_file_name  = File.basename(destination, ".rb")
+        @migration_class_name = @migration_file_name.camelize
+      end
+
+      # Creates a migration template at the given destination. The difference
+      # to the default template method is that the migration number is prepended
+      # to the destination file name.
+      #
+      # The migration number, migration file name, migration class name are
+      # available as instance variables in the template to be rendered.
+      #
+      #   migration_template "migration.rb", "db/migrate/add_foo_to_bar.rb"
+      def migration_template(source, destination, config = {})
+        source = File.expand_path(find_in_source_paths(source.to_s))
+
+        set_migration_assigns!(destination)
+
+        dir, base = File.split(destination)
+        numbered_destination = File.join(dir, ["%migration_number%", base].join("_"))
+
+        file = create_migration numbered_destination, nil, config do
+          ERB.new(::File.binread(source), trim_mode: "-", eoutvar: "@output_buffer").result(binding)
+        end
+        Rails::Generators.add_generated_file(file)
+      end
+    end
+  end
+end

data/lib/rails/generators/model_helpers.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_model"
+
+module Rails
+  module Generators
+    module ModelHelpers # :nodoc:
+      PLURAL_MODEL_NAME_WARN_MESSAGE = "[WARNING] The model name '%s' was recognized as a plural, using the singular '%s' instead. " \
+                                       "Override with --force-plural or setup custom inflection rules for this noun before running the generator."
+      IRREGULAR_MODEL_NAME_WARN_MESSAGE = <<~WARNING
+      [WARNING] Rails cannot recover singular form from its plural form '%s'.
+      Please setup custom inflection rules for this noun before running the generator in config/initializers/inflections.rb.
+      WARNING
+      INFLECTION_IMPOSSIBLE_ERROR_MESSAGE = <<~ERROR
+      Rails cannot recover the underscored form from its camelcase form '%s'.
+      Please use an underscored name instead, either '%s' or '%s'.
+      Or setup custom inflection rules for this noun before running the generator in config/initializers/inflections.rb.
+      ERROR
+      mattr_accessor :skip_warn
+
+      def self.included(base) # :nodoc:
+        base.class_option :force_plural, type: :boolean, default: false,
+          desc: "Do not singularize the model name, even if it appears plural"
+      end
+
+      def initialize(args, *_options)
+        super
+        if plural_model_name?(name) && !options[:force_plural]
+          singular = name.singularize
+          unless ModelHelpers.skip_warn
+            say PLURAL_MODEL_NAME_WARN_MESSAGE % [name, singular]
+          end
+          name.replace singular
+          assign_names!(name)
+        end
+        if inflection_impossible?(name)
+          option1 = name.singularize.underscore
+          option2 = name.pluralize.underscore.singularize
+          raise Error, INFLECTION_IMPOSSIBLE_ERROR_MESSAGE % [name, option1, option2]
+        end
+        if irregular_model_name?(name) && ! ModelHelpers.skip_warn
+          say IRREGULAR_MODEL_NAME_WARN_MESSAGE % [name.pluralize]
+        end
+        ModelHelpers.skip_warn = true
+      end
+
+      private
+        def plural_model_name?(name)
+          name == name.pluralize && name.singularize != name.pluralize
+        end
+
+        def irregular_model_name?(name)
+          name.singularize != name.pluralize.singularize
+        end
+
+        def inflection_impossible?(name)
+          name != name.underscore &&
+            name.singularize.underscore != name.pluralize.underscore.singularize
+        end
+    end
+  end
+end

data/lib/rails/generators/named_base.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "rails/generators/generated_attribute"
+
+module Rails
+  module Generators
+    class NamedBase < Base
+      argument :name, type: :string
+
+      def initialize(args, *options) # :nodoc:
+        @inside_template = nil
+        # Unfreeze name in case it's given as a frozen string
+        args[0] = args[0].dup if args[0].is_a?(String) && args[0].frozen?
+        super
+        assign_names!(name)
+        parse_attributes! if respond_to?(:attributes)
+      end
+
+      # Overrides <tt>Thor::Actions#template</tt> so it can tell if
+      # a template is currently being created.
+      no_tasks do
+        def template(source, *args, &block)
+          inside_template do
+            Rails::Generators.add_generated_file(super)
+          end
+        end
+
+        def js_template(source, destination)
+          template(source + ".js", destination + ".js")
+        end
+      end
+
+      private
+        attr_reader :file_name
+
+        # FIXME: We are avoiding to use alias because a bug on thor that make
+        # this method public and add it to the task list.
+        def singular_name # :doc:
+          file_name
+        end
+
+        def inside_template # :doc:
+          @inside_template = true
+          yield
+        ensure
+          @inside_template = false
+        end
+
+        def inside_template? # :doc:
+          @inside_template
+        end
+
+        def file_path # :doc:
+          @file_path ||= (class_path + [file_name]).join("/")
+        end
+
+        def class_path # :doc:
+          inside_template? || !namespaced? ? regular_class_path : namespaced_class_path
+        end
+
+        def regular_class_path # :doc:
+          @class_path
+        end
+
+        def namespaced_class_path # :doc:
+          @namespaced_class_path ||= namespace_dirs + @class_path
+        end
+
+        def class_name # :doc:
+          (class_path + [file_name]).map!(&:camelize).join("::")
+        end
+
+        def human_name # :doc:
+          @human_name ||= singular_name.humanize
+        end
+
+        def plural_name # :doc:
+          @plural_name ||= singular_name.pluralize
+        end
+
+        def i18n_scope # :doc:
+          @i18n_scope ||= file_path.tr("/", ".")
+        end
+
+        def table_name # :doc:
+          @table_name ||= begin
+            base = pluralize_table_names? ? plural_name : singular_name
+            (class_path + [base]).join("_")
+          end
+        end
+
+        def uncountable? # :doc:
+          singular_name == plural_name
+        end
+
+        def index_helper(type: nil) # :doc:
+          [plural_route_name, ("index" if uncountable?), type].compact.join("_")
+        end
+
+        def show_helper(arg = "@#{singular_table_name}", type: :url) # :doc:
+          "#{singular_route_name}_#{type}(#{arg})"
+        end
+
+        def edit_helper(...) # :doc:
+          "edit_#{show_helper(...)}"
+        end
+
+        def new_helper(type: :url) # :doc:
+          "new_#{singular_route_name}_#{type}"
+        end
+
+        def singular_table_name # :doc:
+          @singular_table_name ||= (pluralize_table_names? ? table_name.singularize : table_name)
+        end
+
+        def plural_table_name # :doc:
+          @plural_table_name ||= (pluralize_table_names? ? table_name : table_name.pluralize)
+        end
+
+        def plural_file_name # :doc:
+          @plural_file_name ||= file_name.pluralize
+        end
+
+        def fixture_file_name # :doc:
+          @fixture_file_name ||= (pluralize_table_names? ? plural_file_name : file_name)
+        end
+
+        def route_url # :doc:
+          @route_url ||= controller_class_path.collect { |dname| "/" + dname }.join + "/" + plural_file_name
+        end
+
+        def url_helper_prefix # :doc:
+          @url_helper_prefix ||= (class_path + [file_name]).join("_")
+        end
+
+        # Tries to retrieve the application name or simply return application.
+        def application_name # :doc:
+          if defined?(Rails) && Rails.application
+            Rails.application.class.name.split("::").first.underscore
+          else
+            "application"
+          end
+        end
+
+        def redirect_resource_name # :doc:
+          model_resource_name(prefix: "@")
+        end
+
+        def model_resource_name(base_name = singular_table_name, prefix: "") # :doc:
+          resource_name = "#{prefix}#{base_name}"
+          if options[:model_name]
+            "[#{controller_class_path.map { |name| ":" + name }.join(", ")}, #{resource_name}]"
+          else
+            resource_name
+          end
+        end
+
+        def singular_route_name # :doc:
+          if options[:model_name]
+            "#{controller_class_path.join('_')}_#{singular_table_name}"
+          else
+            singular_table_name
+          end
+        end
+
+        def plural_route_name # :doc:
+          if options[:model_name]
+            "#{controller_class_path.join('_')}_#{plural_table_name}"
+          else
+            plural_table_name
+          end
+        end
+
+        def assign_names!(name)
+          @class_path = name.include?("/") ? name.split("/") : name.split("::")
+          @class_path.map!(&:underscore)
+          @file_name = @class_path.pop
+        end
+
+        # Convert attributes array into GeneratedAttribute objects.
+        def parse_attributes!
+          self.attributes = (attributes || []).map do |attr|
+            Rails::Generators::GeneratedAttribute.parse(attr)
+          end
+        end
+
+        def attributes_names # :doc:
+          @attributes_names ||= attributes.each_with_object([]) do |a, names|
+            names << a.column_name
+            names << "password_confirmation" if a.password_digest?
+            names << "#{a.name}_type" if a.polymorphic?
+          end
+        end
+
+        def pluralize_table_names? # :doc:
+          !defined?(ActiveRecord::Base) || ActiveRecord::Base.pluralize_table_names
+        end
+
+        def mountable_engine? # :doc:
+          defined?(ENGINE_ROOT) && namespaced?
+        end
+
+        # Add a class collisions name to be checked on class initialization. You
+        # can supply a hash with a +:prefix+ or +:suffix+ to be tested.
+        #
+        # ==== Examples
+        #
+        #   check_class_collision suffix: "Decorator"
+        #
+        # If the generator is invoked with class name Admin, it will check for
+        # the presence of "AdminDecorator".
+        #
+        def self.check_class_collision(options = {}) # :doc:
+          define_method :check_class_collision do
+            name = if respond_to?(:controller_class_name, true) # for ResourceHelpers
+              controller_class_name
+            else
+              class_name
+            end
+
+            class_collisions "#{options[:prefix]}#{name}#{options[:suffix]}"
+          end
+        end
+    end
+  end
+end

data/lib/rails/generators/rails/app/USAGE

@@ -0,0 +1,31 @@
+Description:
+    The `rails new` command creates a new Rails application with a default
+    directory structure and configuration at the path you specify.
+
+    You can specify extra command-line arguments to be used every time
+    `rails new` runs in the .railsrc configuration file in your home directory,
+    or in $XDG_CONFIG_HOME/rails/railsrc if XDG_CONFIG_HOME is set.
+
+    Note that the arguments specified in the .railsrc file don't affect the
+    default values shown above in this help message.
+
+    You can specify which version to use when creating a new rails application 
+    using `rails _<version>_ new`.
+
+Examples:
+    `rails new ~/Code/Ruby/weblog`
+
+    This generates a new Rails app in ~/Code/Ruby/weblog.
+
+    `rails _<version>_ new weblog`
+
+    This generates a new Rails app with the provided version in ./weblog.
+
+    `rails new weblog --api`
+
+    This generates a new Rails app in API mode in ./weblog.
+
+    `rails new weblog --skip-action-mailer`
+
+    This generates a new Rails app without Action Mailer in ./weblog.
+    Any part of Rails can be skipped during app generation.