rake 10.0.0.beta.2 → 13.0.0.pre.1

data/lib/rake/ext/string.rb

@@ -1,19 +1,20 @@
-require 'rake/ext/core'
+# frozen_string_literal: true
+require "rake/ext/core"
 
-######################################################################
-# Rake extension methods for String.
-#
 class String
+
   rake_extension("ext") do
     # Replace the file extension with +newext+.  If there is no extension on
     # the string, append the new extension to the end.  If the new extension
     # is not given, or is the empty string, remove any existing extension.
     #
     # +ext+ is a user added method for the String class.
-    def ext(newext='')
-      return self.dup if ['.', '..'].include? self
-      if newext != ''
-        newext = (newext =~ /^\./) ? newext : ("." + newext)
+    #
+    # This String extension comes from Rake
+    def ext(newext="")
+      return self.dup if [".", ".."].include? self
+      if newext != ""
+        newext = "." + newext unless newext =~ /^\./
       end
       self.chomp(File.extname(self)) << newext
     end
@@ -21,11 +22,13 @@ class String
 
   rake_extension("pathmap") do
     # Explode a path into individual components.  Used by +pathmap+.
+    #
+    # This String extension comes from Rake
     def pathmap_explode
       head, tail = File.split(self)
       return [self] if head == self
-      return [tail] if head == '.' || tail == '/'
-      return [head, tail] if head == '/'
+      return [tail] if head == "." || tail == "/"
+      return [head, tail] if head == "/"
       return head.pathmap_explode + [tail]
     end
     protected :pathmap_explode
@@ -33,6 +36,8 @@ class String
     # Extract a partial path from the path.  Include +n+ directories from the
     # front end (left hand side) if +n+ is positive.  Include |+n+|
     # directories from the back end (right hand side) if +n+ is negative.
+    #
+    # This String extension comes from Rake
     def pathmap_partial(n)
       dirs = File.dirname(self).pathmap_explode
       partial_dirs =
@@ -47,19 +52,21 @@ class String
     end
     protected :pathmap_partial
 
-    # Preform the pathmap replacement operations on the given path. The
+    # Perform the pathmap replacement operations on the given path. The
     # patterns take the form 'pat1,rep1;pat2,rep2...'.
+    #
+    # This String extension comes from Rake
     def pathmap_replace(patterns, &block)
       result = self
-      patterns.split(';').each do |pair|
-        pattern, replacement = pair.split(',')
+      patterns.split(";").each do |pair|
+        pattern, replacement = pair.split(",")
         pattern = Regexp.new(pattern)
-        if replacement == '*' && block_given?
+        if replacement == "*" && block_given?
           result = result.sub(pattern, &block)
         elsif replacement
           result = result.sub(pattern, replacement)
         else
-          result = result.sub(pattern, '')
+          result = result.sub(pattern, "")
         end
       end
       result
@@ -70,35 +77,36 @@ class String
     # controls the details of the mapping.  The following special patterns are
     # recognized:
     #
-    # * <b>%p</b> -- The complete path.
-    # * <b>%f</b> -- The base file name of the path, with its file extension,
-    #   but without any directories.
-    # * <b>%n</b> -- The file name of the path without its file extension.
-    # * <b>%d</b> -- The directory list of the path.
-    # * <b>%x</b> -- The file extension of the path.  An empty string if there
-    #   is no extension.
-    # * <b>%X</b> -- Everything *but* the file extension.
-    # * <b>%s</b> -- The alternate file separator if defined, otherwise use
-    #   the standard file separator.
-    # * <b>%%</b> -- A percent sign.
-    #
-    # The %d specifier can also have a numeric prefix (e.g. '%2d'). If the
-    # number is positive, only return (up to) +n+ directories in the path,
-    # starting from the left hand side.  If +n+ is negative, return (up to)
-    # |+n+| directories from the right hand side of the path.
+    # <tt>%p</tt> :: The complete path.
+    # <tt>%f</tt> :: The base file name of the path, with its file extension,
+    #                but without any directories.
+    # <tt>%n</tt> :: The file name of the path without its file extension.
+    # <tt>%d</tt> :: The directory list of the path.
+    # <tt>%x</tt> :: The file extension of the path.  An empty string if there
+    #                is no extension.
+    # <tt>%X</tt> :: Everything *but* the file extension.
+    # <tt>%s</tt> :: The alternate file separator if defined, otherwise use #
+    #                the standard file separator.
+    # <tt>%%</tt> :: A percent sign.
+    #
+    # The <tt>%d</tt> specifier can also have a numeric prefix (e.g. '%2d').
+    # If the number is positive, only return (up to) +n+ directories in the
+    # path, starting from the left hand side.  If +n+ is negative, return (up
+    # to) +n+ directories from the right hand side of the path.
     #
     # Examples:
     #
     #   'a/b/c/d/file.txt'.pathmap("%2d")   => 'a/b'
     #   'a/b/c/d/file.txt'.pathmap("%-2d")  => 'c/d'
     #
-    # Also the %d, %p, %f, %n, %x, and %X operators can take a
-    # pattern/replacement argument to perform simple string substitutions on a
-    # particular part of the path.  The pattern and replacement are separated
-    # by a comma and are enclosed by curly braces.  The replacement spec comes
-    # after the % character but before the operator letter.  (e.g.
-    # "%{old,new}d").  Multiple replacement specs should be separated by
-    # semi-colons (e.g. "%{old,new;src,bin}d").
+    # Also the <tt>%d</tt>, <tt>%p</tt>, <tt>%f</tt>, <tt>%n</tt>,
+    # <tt>%x</tt>, and <tt>%X</tt> operators can take a pattern/replacement
+    # argument to perform simple string substitutions on a particular part of
+    # the path.  The pattern and replacement are separated by a comma and are
+    # enclosed by curly braces.  The replacement spec comes after the %
+    # character but before the operator letter.  (e.g. "%{old,new}d").
+    # Multiple replacement specs should be separated by semi-colons (e.g.
+    # "%{old,new;src,bin}d").
     #
     # Regular expressions may be used for the pattern, and back refs may be
     # used in the replacement text.  Curly braces, commas and semi-colons are
@@ -107,11 +115,11 @@ class String
     #
     # For example:
     #
-    #    "src/org/onestepback/proj/A.java".pathmap("%{^src,bin}X.class")
+    #    "src/org/onestepback/proj/A.java".pathmap("%{^src,class}X.class")
     #
     # returns:
     #
-    #    "bin/org/onestepback/proj/A.class"
+    #    "class/org/onestepback/proj/A.class"
     #
     # If the replacement text is '*', then a block may be provided to perform
     # some arbitrary calculation for the replacement.
@@ -126,34 +134,35 @@ class String
     #
     #  "/path/to/file.txt"
     #
+    # This String extension comes from Rake
     def pathmap(spec=nil, &block)
       return self if spec.nil?
-      result = ''
+      result = "".dup
       spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
         case frag
-        when '%f'
+        when "%f"
           result << File.basename(self)
-        when '%n'
+        when "%n"
           result << File.basename(self).ext
-        when '%d'
+        when "%d"
           result << File.dirname(self)
-        when '%x'
+        when "%x"
           result << File.extname(self)
-        when '%X'
+        when "%X"
           result << self.ext
-        when '%p'
+        when "%p"
           result << self
-        when '%s'
+        when "%s"
           result << (File::ALT_SEPARATOR || File::SEPARATOR)
-        when '%-'
+        when "%-"
           # do nothing
-        when '%%'
+        when "%%"
           result << "%"
         when /%(-?\d+)d/
           result << pathmap_partial($1.to_i)
         when /^%\{([^}]*)\}(\d*[dpfnxX])/
           patterns, operator = $1, $2
-          result << pathmap('%' + operator).pathmap_replace(patterns, &block)
+          result << pathmap("%" + operator).pathmap_replace(patterns, &block)
         when /^%/
           fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
         else
@@ -163,5 +172,5 @@ class String
       result
     end
   end
-end # class String
 
+end

data/lib/rake/file_creation_task.rb

@@ -1,5 +1,6 @@
-require 'rake/file_task'
-require 'rake/early_time'
+# frozen_string_literal: true
+require "rake/file_task"
+require "rake/early_time"
 
 module Rake
 
@@ -11,7 +12,7 @@ module Rake
   class FileCreationTask < FileTask
     # Is this file task needed?  Yes if it doesn't exist.
     def needed?
-      ! File.exist?(name)
+      !File.exist?(name)
     end
 
     # Time stamp for file creation task.  This time stamp is earlier

data/lib/rake/file_list.rb

@@ -1,11 +1,11 @@
-require 'rake/cloneable'
-require 'rake/file_utils_ext'
-require 'rake/pathmap'
+# frozen_string_literal: true
+require "rake/cloneable"
+require "rake/file_utils_ext"
+require "rake/ext/string"
 
-######################################################################
 module Rake
 
-  # #########################################################################
+  ##
   # A FileList is essentially an array with a few helper methods defined to
   # make file manipulation a bit easier.
   #
@@ -41,14 +41,14 @@ module Rake
 
     # List of array methods (that are not in +Object+) that need to be
     # delegated.
-    ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).map { |n| n.to_s }
+    ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).map(&:to_s)
 
     # List of additional methods that must be delegated.
-    MUST_DEFINE = %w[to_a inspect <=>]
+    MUST_DEFINE = %w[inspect <=>]
 
     # List of methods that should not be delegated here (we define special
     # versions of them explicitly below).
-    MUST_NOT_DEFINE = %w[to_a to_ary partition *]
+    MUST_NOT_DEFINE = %w[to_a to_ary partition * <<]
 
     # List of delegated methods that return new array values which need
     # wrapping.
@@ -58,21 +58,21 @@ module Rake
       + - & |
     ]
 
-    DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).collect{ |s| s.to_s }.sort.uniq
+    DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).map(&:to_s).sort.uniq
 
     # Now do the delegation.
-    DELEGATING_METHODS.each_with_index do |sym, i|
+    DELEGATING_METHODS.each do |sym|
       if SPECIAL_RETURN.include?(sym)
-        ln = __LINE__+1
+        ln = __LINE__ + 1
         class_eval %{
           def #{sym}(*args, &block)
             resolve
             result = @items.send(:#{sym}, *args, &block)
-            FileList.new.import(result)
+            self.class.new.import(result)
           end
         }, __FILE__, ln
       else
-        ln = __LINE__+1
+        ln = __LINE__ + 1
         class_eval %{
           def #{sym}(*args, &block)
             resolve
@@ -83,6 +83,8 @@ module Rake
       end
     end
 
+    GLOB_PATTERN = %r{[*?\[\{]}
+
     # Create a file list from the globbable patterns given.  If you wish to
     # perform multiple includes or excludes at object build time, use the
     # "yield self" pattern.
@@ -117,7 +119,7 @@ module Rake
         if fn.respond_to? :to_ary
           include(*fn.to_ary)
         else
-          @pending_add << fn
+          @pending_add << Rake.from_pathname(fn)
         end
       end
       @pending = true
@@ -147,16 +149,17 @@ module Rake
     #
     def exclude(*patterns, &block)
       patterns.each do |pat|
-        @exclude_patterns << pat
-      end
-      if block_given?
-        @exclude_procs << block
+        if pat.respond_to? :to_ary
+          exclude(*pat.to_ary)
+        else
+          @exclude_patterns << Rake.from_pathname(pat)
+        end
       end
-      resolve_exclude if ! @pending
+      @exclude_procs << block if block_given?
+      resolve_exclude unless @pending
       self
     end
 
-
     # Clear all the exclude patterns so that we exclude nothing.
     def clear_exclude
       @exclude_patterns = []
@@ -164,7 +167,7 @@ module Rake
       self
     end
 
-    # Define equality.
+    # A FileList is equal through array equality.
     def ==(array)
       to_ary == array
     end
@@ -191,12 +194,18 @@ module Rake
       result = @items * other
       case result
       when Array
-        FileList.new.import(result)
+        self.class.new.import(result)
       else
         result
       end
     end
 
+    def <<(obj)
+      resolve
+      @items << Rake.from_pathname(obj)
+      self
+    end
+
     # Resolve all the pending adds now.
     def resolve
       if @pending
@@ -208,9 +217,9 @@ module Rake
       self
     end
 
-    def resolve_add(fn)
+    def resolve_add(fn) # :nodoc:
       case fn
-      when %r{[*?\[\{]}
+      when GLOB_PATTERN
         add_matching(fn)
       else
         self << fn
@@ -218,8 +227,8 @@ module Rake
     end
     private :resolve_add
 
-    def resolve_exclude
-      reject! { |fn| exclude?(fn) }
+    def resolve_exclude # :nodoc:
+      reject! { |fn| excluded_from_list?(fn) }
       self
     end
     private :resolve_exclude
@@ -231,7 +240,7 @@ module Rake
     #   FileList['a.c', 'b.c'].sub(/\.c$/, '.o')  => ['a.o', 'b.o']
     #
     def sub(pat, rep)
-      inject(FileList.new) { |res, fn| res << fn.sub(pat,rep) }
+      inject(self.class.new) { |res, fn| res << fn.sub(pat, rep) }
     end
 
     # Return a new FileList with the results of running +gsub+ against each
@@ -242,26 +251,26 @@ module Rake
     #      => ['lib\\test\\file', 'x\\y']
     #
     def gsub(pat, rep)
-      inject(FileList.new) { |res, fn| res << fn.gsub(pat,rep) }
+      inject(self.class.new) { |res, fn| res << fn.gsub(pat, rep) }
     end
 
     # Same as +sub+ except that the original file list is modified.
     def sub!(pat, rep)
-      each_with_index { |fn, i| self[i] = fn.sub(pat,rep) }
+      each_with_index { |fn, i| self[i] = fn.sub(pat, rep) }
       self
     end
 
     # Same as +gsub+ except that the original file list is modified.
     def gsub!(pat, rep)
-      each_with_index { |fn, i| self[i] = fn.gsub(pat,rep) }
+      each_with_index { |fn, i| self[i] = fn.gsub(pat, rep) }
       self
     end
 
     # Apply the pathmap spec to each of the included file names, returning a
     # new file list with the modified paths.  (See String#pathmap for
     # details.)
-    def pathmap(spec=nil)
-      collect { |fn| fn.pathmap(spec) }
+    def pathmap(spec=nil, &block)
+      collect { |fn| fn.pathmap(spec, &block) }
     end
 
     # Return a new FileList with <tt>String#ext</tt> method applied to
@@ -272,11 +281,10 @@ module Rake
     #    array.collect { |item| item.ext(newext) }
     #
     # +ext+ is a user added method for the Array class.
-    def ext(newext='')
+    def ext(newext="")
       collect { |fn| fn.ext(newext) }
     end
 
-
     # Grep each of the files in the filelist using the given pattern. If a
     # block is given, call the block on each matching line, passing the file
     # name, line number, and the matching line of text.  If no block is given,
@@ -286,7 +294,7 @@ module Rake
       matched = 0
       each do |fn|
         begin
-          open(fn, "r", *options) do |inf|
+          File.open(fn, "r", *options) do |inf|
             count = 0
             inf.each do |line|
               count += 1
@@ -310,14 +318,14 @@ module Rake
     # Return a new file list that only contains file names from the current
     # file list that exist on the file system.
     def existing
-      select { |fn| File.exist?(fn) }
+      select { |fn| File.exist?(fn) }.uniq
     end
 
     # Modify the current file list so that it contains only file name that
     # exist on the file system.
     def existing!
       resolve
-      @items = @items.select { |fn| File.exist?(fn) }
+      @items = @items.select { |fn| File.exist?(fn) }.uniq
       self
     end
 
@@ -327,33 +335,42 @@ module Rake
       resolve
       result = @items.partition(&block)
       [
-        FileList.new.import(result[0]),
-        FileList.new.import(result[1]),
+        self.class.new.import(result[0]),
+        self.class.new.import(result[1]),
       ]
     end
 
     # Convert a FileList to a string by joining all elements with a space.
     def to_s
       resolve
-      self.join(' ')
+      self.join(" ")
     end
 
     # Add matching glob patterns.
     def add_matching(pattern)
-      Rake.glob(pattern).each do |fn|
-        self << fn unless exclude?(fn)
+      self.class.glob(pattern).each do |fn|
+        self << fn unless excluded_from_list?(fn)
       end
     end
     private :add_matching
 
-    # Should the given file name be excluded?
-    def exclude?(fn)
+    # Should the given file name be excluded from the list?
+    #
+    # NOTE: This method was formerly named "exclude?", but Rails
+    # introduced an exclude? method as an array method and setup a
+    # conflict with file list. We renamed the method to avoid
+    # confusion. If you were using "FileList#exclude?" in your user
+    # code, you will need to update.
+    def excluded_from_list?(fn)
       return true if @exclude_patterns.any? do |pat|
         case pat
         when Regexp
           fn =~ pat
-        when /[*?]/
-          File.fnmatch?(pat, fn, File::FNM_PATHNAME)
+        when GLOB_PATTERN
+          flags = File::FNM_PATHNAME
+          # Ruby <= 1.9.3 does not support File::FNM_EXTGLOB
+          flags |= File::FNM_EXTGLOB if defined? File::FNM_EXTGLOB
+          File.fnmatch?(pat, fn, flags)
         else
           fn == pat
         end
@@ -368,10 +385,10 @@ module Rake
       /~$/
     ]
     DEFAULT_IGNORE_PROCS = [
-      proc { |fn| fn =~ /(^|[\/\\])core$/ && ! File.directory?(fn) }
+      proc { |fn| fn =~ /(^|[\/\\])core$/ && !File.directory?(fn) }
     ]
 
-    def import(array)
+    def import(array) # :nodoc:
       @items = array
       self
     end
@@ -383,6 +400,13 @@ module Rake
       def [](*args)
         new(*args)
       end
+
+      # Get a sorted list of files matching the pattern. This method
+      # should be preferred to Dir[pattern] and Dir.glob(pattern) because
+      # the files returned are guaranteed to be sorted.
+      def glob(pattern, *args)
+        Dir.glob(pattern, *args).sort
+      end
     end
   end
 end
@@ -393,11 +417,19 @@ module Rake
     # Yield each file or directory component.
     def each_dir_parent(dir)    # :nodoc:
       old_length = nil
-      while dir != '.' && dir.length != old_length
+      while dir != "." && dir.length != old_length
         yield(dir)
         old_length = dir.length
         dir = File.dirname(dir)
       end
     end
+
+    # Convert Pathname and Pathname-like objects to strings;
+    # leave everything else alone
+    def from_pathname(path)    # :nodoc:
+      path = path.to_path if path.respond_to?(:to_path)
+      path = path.to_str if path.respond_to?(:to_str)
+      path
+    end
   end
 end # module Rake