railties 5.0.7.2 → 5.1.0.beta1

data/lib/rails/code_statistics_calculator.rb

@@ -43,7 +43,7 @@ class CodeStatisticsCalculator #:nodoc:
 
   def add_by_file_path(file_path)
     File.open(file_path) do |f|
-      self.add_by_io(f, file_type(file_path))
+      add_by_io(f, file_type(file_path))
     end
   end
 
@@ -77,10 +77,10 @@ class CodeStatisticsCalculator #:nodoc:
 
   private
     def file_type(file_path)
-      if file_path.end_with? '_test.rb'
+      if file_path.end_with? "_test.rb"
         :minitest
       else
-        File.extname(file_path).sub(/\A\./, '').downcase.to_sym
+        File.extname(file_path).sub(/\A\./, "").downcase.to_sym
       end
     end
 end

data/lib/rails/command.rb

@@ -0,0 +1,111 @@
+require "active_support"
+require "active_support/dependencies/autoload"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/hash/transform_values"
+
+require "thor"
+
+module Rails
+  module Command
+    extend ActiveSupport::Autoload
+
+    autoload :Behavior
+    autoload :Base
+
+    include Behavior
+
+    HELP_MAPPINGS = %w(-h -? --help)
+
+    class << self
+      def hidden_commands # :nodoc:
+        @hidden_commands ||= []
+      end
+
+      def environment # :nodoc:
+        ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+      end
+
+      # Receives a namespace, arguments and the behavior to invoke the command.
+      def invoke(full_namespace, args = [], **config)
+        namespace = full_namespace = full_namespace.to_s
+
+        if char = namespace =~ /:(\w+)$/
+          command_name, namespace = $1, namespace.slice(0, char)
+        else
+          command_name = namespace
+        end
+
+        command_name = "help" if command_name.blank? || HELP_MAPPINGS.include?(command_name)
+        namespace = "version" if %w( -v --version ).include?(command_name)
+
+        command = find_by_namespace(namespace, command_name)
+        if command && command.all_commands[command_name]
+          command.perform(command_name, args, config)
+        else
+          find_by_namespace("rake").perform(full_namespace, args, config)
+        end
+      end
+
+      # Rails finds namespaces similar to Thor, it only adds one rule:
+      #
+      # Command names must end with "_command.rb". This is required because Rails
+      # looks in load paths and loads the command just before it's going to be used.
+      #
+      #   find_by_namespace :webrat, :rails, :integration
+      #
+      # Will search for the following commands:
+      #
+      #   "rails:webrat", "webrat:integration", "webrat"
+      #
+      # Notice that "rails:commands:webrat" could be loaded as well, what
+      # Rails looks for is the first and last parts of the namespace.
+      def find_by_namespace(namespace, command_name = nil) # :nodoc:
+        lookups = [ namespace ]
+        lookups << "#{namespace}:#{command_name}" if command_name
+        lookups.concat lookups.map { |lookup| "rails:#{lookup}" }
+
+        lookup(lookups)
+
+        namespaces = subclasses.index_by(&:namespace)
+        namespaces[(lookups & namespaces.keys).first]
+      end
+
+      # Returns the root of the Rails engine or app running the command.
+      def root
+        if defined?(ENGINE_ROOT)
+          Pathname.new(ENGINE_ROOT)
+        elsif defined?(APP_PATH)
+          Pathname.new(File.expand_path("../..", APP_PATH))
+        end
+      end
+
+      def print_commands # :nodoc:
+        sorted_groups.each { |b, n| print_list(b, n) }
+      end
+
+      def sorted_groups # :nodoc:
+        lookup!
+
+        groups = (subclasses - hidden_commands).group_by { |c| c.namespace.split(":").first }
+        groups.transform_values! { |commands| commands.flat_map(&:printing_commands).sort }
+
+        rails = groups.delete("rails")
+        [[ "rails", rails ]] + groups.sort.to_a
+      end
+
+      private
+        def command_type # :doc:
+          @command_type ||= "command"
+        end
+
+        def lookup_paths # :doc:
+          @lookup_paths ||= %w( rails/commands commands )
+        end
+
+        def file_lookup_paths # :doc:
+          @file_lookup_paths ||= [ "{#{lookup_paths.join(',')}}", "**", "*_command.rb" ]
+        end
+    end
+  end
+end

data/lib/rails/command/actions.rb

@@ -0,0 +1,42 @@
+module Rails
+  module Command
+    module Actions
+      # Change to the application's path if there is no config.ru file in current directory.
+      # This allows us to run `rails server` from other directories, but still get
+      # the main config.ru and properly set the tmp directory.
+      def set_application_directory!
+        Dir.chdir(File.expand_path("../../", APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
+      end
+
+      def require_application_and_environment!
+        require ENGINE_PATH if defined?(ENGINE_PATH)
+
+        if defined?(APP_PATH)
+          require APP_PATH
+          Rails.application.require_environment!
+        end
+      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,149 @@
+require "thor"
+require "erb"
+
+require "active_support/core_ext/string/filters"
+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 << self
+        # 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
+            @desc ||= ERB.new(File.read(usage_path)).result(binding) if usage_path
+          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 !~ /Base$/
+            Rails::Command.subclasses << base
+          end
+        end
+
+        def perform(command, args, config) # :nodoc:
+          if Rails::Command::HELP_MAPPINGS.include?(args.first)
+            command, args = "help", []
+          end
+
+          dispatch(command, args.dup, nil, config)
+        end
+
+        def printing_commands
+          namespace.sub(/^rails:/, "")
+        end
+
+        def executable
+          "bin/rails #{command_name}"
+        end
+
+        # Use Rails' default banner.
+        def banner(*)
+          "#{executable} #{arguments.map(&:usage).join(' ')} [options]".squish!
+        end
+
+        # Sets the base_name taking into account the current class namespace.
+        #
+        #   Rails::Command::TestCommand.base_name # => 'rails'
+        def base_name
+          @base_name ||= begin
+            if base = name.to_s.split("::").first
+              base.underscore
+            end
+          end
+        end
+
+        # Return command name without namespaces.
+        #
+        #   Rails::Command::TestCommand.command_name # => 'test'
+        def command_name
+          @command_name ||= begin
+            if command = name.to_s.split("::").last
+              command.chomp!("Command")
+              command.underscore
+            end
+          end
+        end
+
+        # Path to lookup a USAGE description in a file.
+        def usage_path
+          if default_command_root
+            path = File.join(default_command_root, "USAGE")
+            path if File.exist?(path)
+          end
+        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 `rails/command/test_command.rb`
+        # would return `rails/test`.
+        def default_command_root
+          path = File.expand_path(File.join("../commands", command_root_namespace), __dir__)
+          path if File.exist?(path)
+        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 ||= ""
+              @desc  ||= ""
+
+              super
+            end
+          end
+
+          def command_root_namespace
+            (namespace.split(":") - %w( rails )).first
+          end
+      end
+
+      def help
+        if command_name = self.class.command_name
+          self.class.command_help(shell, command_name)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rails/command/behavior.rb

@@ -0,0 +1,123 @@
+require "active_support"
+
+module Rails
+  module Command
+    module Behavior #:nodoc:
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Remove the color from output.
+        def no_color!
+          Thor::Base.shell = Thor::Shell::Basic
+        end
+
+        # Track all command subclasses.
+        def subclasses
+          @subclasses ||= []
+        end
+
+        private
+
+          # This code is based directly on the Text gem implementation.
+          # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
+          #
+          # Returns a value representing the "cost" of transforming str1 into str2.
+          def levenshtein_distance(str1, str2) # :doc:
+            s = str1
+            t = str2
+            n = s.length
+            m = t.length
+
+            return m if (0 == n)
+            return n if (0 == m)
+
+            d = (0..m).to_a
+            x = nil
+
+            # avoid duplicating an enumerable object in the loop
+            str2_codepoint_enumerable = str2.each_codepoint
+
+            str1.each_codepoint.with_index do |char1, i|
+              e = i + 1
+
+              str2_codepoint_enumerable.with_index do |char2, j|
+                cost = (char1 == char2) ? 0 : 1
+                x = [
+                     d[j + 1] + 1, # insertion
+                     e + 1,      # deletion
+                     d[j] + cost # substitution
+                    ].min
+                d[j] = e
+                e = x
+              end
+
+              d[m] = x
+            end
+
+            x
+          end
+
+          # Prints a list of generators.
+          def print_list(base, namespaces)
+            return if namespaces.empty?
+            puts "#{base.camelize}:"
+
+            namespaces.each do |namespace|
+              puts("  #{namespace}")
+            end
+
+            puts
+          end
+
+          # Receives namespaces in an array and tries to find matching generators
+          # in the load path.
+          def lookup(namespaces)
+            paths = namespaces_to_paths(namespaces)
+
+            paths.each do |raw_path|
+              lookup_paths.each do |base|
+                path = "#{base}/#{raw_path}_#{command_type}"
+
+                begin
+                  require path
+                  return
+                rescue LoadError => e
+                  raise unless e.message =~ /#{Regexp.escape(path)}$/
+                rescue Exception => e
+                  warn "[WARNING] Could not load #{command_type} #{path.inspect}. Error: #{e.message}.\n#{e.backtrace.join("\n")}"
+                end
+              end
+            end
+          end
+
+          # This will try to load any command in the load path to show in help.
+          def lookup!
+            $LOAD_PATH.each do |base|
+              Dir[File.join(base, *file_lookup_paths)].each do |path|
+                begin
+                  path = path.sub("#{base}/", "")
+                  require path
+                rescue Exception
+                  # No problem
+                end
+              end
+            end
+          end
+
+          # Convert namespaces to paths by replacing ":" for "/" and adding
+          # an extra lookup. For example, "rails:model" should be searched
+          # in both: "rails/model/model_generator" and "rails/model_generator".
+          def namespaces_to_paths(namespaces)
+            paths = []
+            namespaces.each do |namespace|
+              pieces = namespace.split(":")
+              paths << pieces.dup.push(pieces.last).join("/")
+              paths << pieces.join("/")
+            end
+            paths.uniq!
+            paths
+          end
+      end
+    end
+  end
+end