rake 0.9.2 → 13.0.3

data/lib/rake/backtrace.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Rake
+  module Backtrace # :nodoc: all
+    SYS_KEYS  = RbConfig::CONFIG.keys.grep(/(?:[a-z]prefix|libdir)\z/)
+    SYS_PATHS = RbConfig::CONFIG.values_at(*SYS_KEYS).uniq +
+      [ File.join(File.dirname(__FILE__), "..") ]
+
+    SUPPRESSED_PATHS = SYS_PATHS.
+      map { |s| s.tr("\\", "/") }.
+      map { |f| File.expand_path(f) }.
+      reject { |s| s.nil? || s =~ /^ *$/ }
+    SUPPRESSED_PATHS_RE = SUPPRESSED_PATHS.map { |f| Regexp.quote(f) }.join("|")
+    SUPPRESSED_PATHS_RE << "|^org\\/jruby\\/\\w+\\.java" if
+      Object.const_defined?(:RUBY_ENGINE) and RUBY_ENGINE == "jruby"
+
+    SUPPRESS_PATTERN = %r!(\A(#{SUPPRESSED_PATHS_RE})|bin/rake:\d+)!i
+
+    def self.collapse(backtrace)
+      pattern = Rake.application.options.suppress_backtrace_pattern ||
+                SUPPRESS_PATTERN
+      backtrace.reject { |elem| elem =~ pattern }
+    end
+  end
+end

data/lib/rake/clean.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # The 'rake/clean' file defines two file lists (CLEAN and CLOBBER) and
 # two rake tasks (:clean and :clobber).
 #
@@ -11,21 +12,67 @@
 #            The intent of this task is to return a project to its
 #            pristine, just unpacked state.
 
-require 'rake'
+require "rake"
 
-CLEAN = Rake::FileList["**/*~", "**/*.bak", "**/core"]
+# :stopdoc:
+
+module Rake
+  module Cleaner
+    extend FileUtils
+
+    module_function
+
+    def cleanup_files(file_names)
+      file_names.each do |file_name|
+        cleanup(file_name)
+      end
+    end
+
+    def cleanup(file_name, **opts)
+      begin
+        opts = { verbose: Rake.application.options.trace }.merge(opts)
+        rm_r file_name, **opts
+      rescue StandardError => ex
+        puts "Failed to remove #{file_name}: #{ex}" unless file_already_gone?(file_name)
+      end
+    end
+
+    def file_already_gone?(file_name)
+      return false if File.exist?(file_name)
+
+      path = file_name
+      prev = nil
+
+      while path = File.dirname(path)
+        return false if cant_be_deleted?(path)
+        break if [prev, "."].include?(path)
+        prev = path
+      end
+      true
+    end
+    private_class_method :file_already_gone?
+
+    def cant_be_deleted?(path_name)
+      File.exist?(path_name) &&
+        (!File.readable?(path_name) || !File.executable?(path_name))
+    end
+    private_class_method :cant_be_deleted?
+  end
+end
+
+CLEAN = ::Rake::FileList["**/*~", "**/*.bak", "**/core"]
 CLEAN.clear_exclude.exclude { |fn|
-  fn.pathmap("%f") == 'core' && File.directory?(fn)
+  fn.pathmap("%f").downcase == "core" && File.directory?(fn)
 }
 
 desc "Remove any temporary products."
 task :clean do
-  CLEAN.each { |fn| rm_r fn rescue nil }
+  Rake::Cleaner.cleanup_files(CLEAN)
 end
 
-CLOBBER = Rake::FileList.new
+CLOBBER = ::Rake::FileList.new
 
-desc "Remove any generated file."
-task :clobber => [:clean] do
-  CLOBBER.each { |fn| rm_r fn rescue nil }
+desc "Remove any generated files."
+task clobber: [:clean] do
+  Rake::Cleaner.cleanup_files(CLOBBER)
 end

data/lib/rake/cloneable.rb

@@ -1,25 +1,17 @@
+# frozen_string_literal: true
 module Rake
-  # ##########################################################################
+  ##
   # Mixin for creating easily cloned objects.
-  #
-  module Cloneable
-    # Clone an object by making a new object and setting all the instance
-    # variables to the same values.
-    def dup
-      sibling = self.class.new
-      instance_variables.each do |ivar|
-        value = self.instance_variable_get(ivar)
-        new_value = value.clone rescue value
-        sibling.instance_variable_set(ivar, new_value)
-      end
-      sibling.taint if tainted?
-      sibling
-    end
 
-    def clone
-      sibling = dup
-      sibling.freeze if frozen?
-      sibling
+  module Cloneable # :nodoc:
+    # The hook that is invoked by 'clone' and 'dup' methods.
+    def initialize_copy(source)
+      super
+      source.instance_variables.each do |var|
+        src_value  = source.instance_variable_get(var)
+        value = src_value.clone rescue src_value
+        instance_variable_set(var, value)
+      end
     end
   end
 end

data/lib/rake/cpu_counter.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+module Rake
+
+  # Based on a script at:
+  #   http://stackoverflow.com/questions/891537/ruby-detect-number-of-cpus-installed
+  class CpuCounter # :nodoc: all
+    def self.count
+      new.count_with_default
+    end
+
+    def count_with_default(default=4)
+      count || default
+    rescue StandardError
+      default
+    end
+
+    begin
+      require "etc"
+    rescue LoadError
+    else
+      if Etc.respond_to?(:nprocessors)
+        def count
+          return Etc.nprocessors
+        end
+      end
+    end
+  end
+end
+
+unless Rake::CpuCounter.method_defined?(:count)
+  Rake::CpuCounter.class_eval <<-'end;', __FILE__, __LINE__+1
+    require 'rbconfig'
+
+    def count
+      if RUBY_PLATFORM == 'java'
+        count_via_java_runtime
+      else
+        case RbConfig::CONFIG['host_os']
+        when /linux/
+          count_via_cpuinfo
+        when /darwin|bsd/
+          count_via_sysctl
+        when /mswin|mingw/
+          count_via_win32
+        else
+          # Try everything
+          count_via_win32 ||
+          count_via_sysctl ||
+          count_via_cpuinfo
+        end
+      end
+    end
+
+    def count_via_java_runtime
+      Java::Java.lang.Runtime.getRuntime.availableProcessors
+    rescue StandardError
+      nil
+    end
+
+    def count_via_win32
+      require 'win32ole'
+      wmi = WIN32OLE.connect("winmgmts://")
+      cpu = wmi.ExecQuery("select NumberOfCores from Win32_Processor") # TODO count hyper-threaded in this
+      cpu.to_enum.first.NumberOfCores
+    rescue StandardError, LoadError
+      nil
+    end
+
+    def count_via_cpuinfo
+      open('/proc/cpuinfo') { |f| f.readlines }.grep(/processor/).size
+    rescue StandardError
+      nil
+    end
+
+    def count_via_sysctl
+      run 'sysctl', '-n', 'hw.ncpu'
+    end
+
+    def run(command, *args)
+      cmd = resolve_command(command)
+      if cmd
+        IO.popen [cmd, *args] do |io|
+          io.read.to_i
+        end
+      else
+        nil
+      end
+    end
+
+    def resolve_command(command)
+      look_for_command("/usr/sbin", command) ||
+        look_for_command("/sbin", command) ||
+        in_path_command(command)
+    end
+
+    def look_for_command(dir, command)
+      path = File.join(dir, command)
+      File.exist?(path) ? path : nil
+    end
+
+    def in_path_command(command)
+      IO.popen ['which', command] do |io|
+        io.eof? ? nil : command
+      end
+    end
+  end;
+end

data/lib/rake/default_loader.rb

@@ -1,7 +1,12 @@
+# frozen_string_literal: true
 module Rake
 
   # Default Rakefile loader used by +import+.
   class DefaultLoader
+
+    ##
+    # Loads a rakefile into the current application from +fn+
+
     def load(fn)
       Rake.load_rakefile(File.expand_path(fn))
     end

data/lib/rake/dsl_definition.rb

@@ -1,12 +1,23 @@
+# frozen_string_literal: true
 # Rake DSL functions.
-require 'rake/file_utils_ext'
+require "rake/file_utils_ext"
 
 module Rake
+
+  ##
+  # DSL is a module that provides #task, #desc, #namespace, etc.  Use this
+  # when you'd like to use rake outside the top level scope.
+  #
+  # For a Rakefile you run from the command line this module is automatically
+  # included.
+
   module DSL
 
+    #--
     # Include the FileUtils file manipulation functions in the top
     # level module, but mark them private so that they don't
     # unintentionally define methods on other objects.
+    #++
 
     include FileUtilsExt
     private(*FileUtils.instance_methods(false))
@@ -14,18 +25,41 @@ module Rake
 
     private
 
-    # Declare a basic task.
+    # :call-seq:
+    #   task(task_name)
+    #   task(task_name: dependencies)
+    #   task(task_name, arguments => dependencies)
     #
-    # Example:
-    #   task :clobber => [:clean] do
+    # Declare a basic task.  The +task_name+ is always the first argument.  If
+    # the task name contains a ":" it is defined in that namespace.
+    #
+    # The +dependencies+ may be a single task name or an Array of task names.
+    # The +argument+ (a single name) or +arguments+ (an Array of names) define
+    # the arguments provided to the task.
+    #
+    # The task, argument and dependency names may be either symbols or
+    # strings.
+    #
+    # A task with a single dependency:
+    #
+    #   task clobber: %w[clean] do
     #     rm_rf "html"
     #   end
     #
-    def task(*args, &block)
+    # A task with an argument and a dependency:
+    #
+    #   task :package, [:version] => :test do |t, args|
+    #     # ...
+    #   end
+    #
+    # To invoke this task from the command line:
+    #
+    #   $ rake package[1.2.3]
+    #
+    def task(*args, &block) # :doc:
       Rake::Task.define_task(*args, &block)
     end
 
-
     # Declare a file task.
     #
     # Example:
@@ -39,14 +73,14 @@ module Rake
     #     end
     #  end
     #
-    def file(*args, &block)
+    def file(*args, &block) # :doc:
       Rake::FileTask.define_task(*args, &block)
     end
 
     # Declare a file creation task.
     # (Mainly used for the directory command).
-    def file_create(args, &block)
-      Rake::FileCreationTask.define_task(args, &block)
+    def file_create(*args, &block)
+      Rake::FileCreationTask.define_task(*args, &block)
     end
 
     # Declare a set of files tasks to create the given directories on
@@ -55,12 +89,16 @@ module Rake
     # Example:
     #   directory "testdata/doc"
     #
-    def directory(dir)
+    def directory(*args, &block) # :doc:
+      result = file_create(*args, &block)
+      dir, _ = *Rake.application.resolve_args(args)
+      dir = Rake.from_pathname(dir)
       Rake.each_dir_parent(dir) do |d|
         file_create d do |t|
-          mkdir_p t.name if ! File.exist?(t.name)
+          mkdir_p t.name unless File.exist?(t.name)
         end
       end
+      result
     end
 
     # Declare a task that performs its prerequisites in
@@ -69,24 +107,32 @@ module Rake
     # about it)
     #
     # Example:
-    #   multitask :deploy => [:deploy_gem, :deploy_rdoc]
+    #   multitask deploy: %w[deploy_gem deploy_rdoc]
     #
-    def multitask(args, &block)
-      Rake::MultiTask.define_task(args, &block)
+    def multitask(*args, &block) # :doc:
+      Rake::MultiTask.define_task(*args, &block)
     end
 
     # Create a new rake namespace and use it for evaluating the given
     # block.  Returns a NameSpace object that can be used to lookup
     # tasks defined in the namespace.
     #
-    # E.g.
+    # Example:
     #
     #   ns = namespace "nested" do
+    #     # the "nested:run" task
     #     task :run
     #   end
     #   task_run = ns[:run] # find :run in the given namespace.
     #
-    def namespace(name=nil, &block)
+    # Tasks can also be defined in a namespace by using a ":" in the task
+    # name:
+    #
+    #   task "nested:test" do
+    #     # ...
+    #   end
+    #
+    def namespace(name=nil, &block) # :doc:
       name = name.to_s if name.kind_of?(Symbol)
       name = name.to_str if name.respond_to?(:to_str)
       unless name.kind_of?(String) || name.nil?
@@ -99,22 +145,24 @@ module Rake
     #
     # Example:
     #  rule '.o' => '.c' do |t|
-    #    sh %{cc -o #{t.name} #{t.source}}
+    #    sh 'cc', '-o', t.name, t.source
     #  end
     #
-    def rule(*args, &block)
+    def rule(*args, &block) # :doc:
       Rake::Task.create_rule(*args, &block)
     end
 
-    # Describe the next rake task.
+    # Describes the next rake task.  Duplicate descriptions are discarded.
+    # Descriptions are shown with <code>rake -T</code> (up to the first
+    # sentence) and <code>rake -D</code> (the entire description).
     #
     # Example:
     #   desc "Run the Unit Tests"
-    #   task :test => [:build]
-    #     runtests
+    #   task test: [:build]
+    #     # ... run tests
     #   end
     #
-    def desc(description)
+    def desc(description) # :doc:
       Rake.application.last_description = description
     end
 
@@ -132,36 +180,16 @@ module Rake
     # Example:
     #   import ".depend", "my_rules"
     #
-    def import(*fns)
+    def import(*fns) # :doc:
       fns.each do |fn|
         Rake.application.add_import(fn)
       end
     end
   end
-
-  module DeprecatedObjectDSL
-    Commands = Object.new.extend DSL
-    DSL.private_instance_methods(false).each do |name|
-      line = __LINE__+1
-      class_eval %{
-        def #{name}(*args, &block)
-          unless Rake.application.options.ignore_deprecate
-            unless @rake_dsl_warning
-              $stderr.puts "WARNING: Global access to Rake DSL methods is deprecated.  Please include"
-              $stderr.puts "    ...  Rake::DSL into classes and modules which use the Rake DSL methods."
-              @rake_dsl_warning = true
-            end
-            $stderr.puts "WARNING: DSL method \#{self.class}##{name} called at \#{caller.first}"
-          end
-          Rake::DeprecatedObjectDSL::Commands.send(:#{name}, *args, &block)
-          end
-        private :#{name}
-      }, __FILE__, line
-    end
-  end
-
   extend FileUtilsExt
 end
 
+# Extend the main object with the DSL commands. This allows top-level
+# calls to task, etc. to work from a Rakefile without polluting the
+# object inheritance tree.
 self.extend Rake::DSL
-include Rake::DeprecatedObjectDSL