rake 0.8.7 → 0.9.0

data/lib/rake/contrib/ftptools.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 # = Tools for FTP uploading.
 #
 # This file is still under development and is not released for general
@@ -25,7 +23,7 @@ module Rake # :nodoc:
 
     def initialize(path, entry)
       @path = path
-      @mode, line, @owner, @group, size, d1, d2, d3, @name = entry.split(' ')
+      @mode, _, @owner, @group, size, d1, d2, d3, @name = entry.split(' ')
       @size = size.to_i
       @time = determine_time(d1, d2, d3)
     end
@@ -59,7 +57,6 @@ module Rake # :nodoc:
     def determine_time(d1, d2, d3)
       now = self.class.time.now
       if /:/ =~ d3
-        h, m = d3.split(':')
         result = Time.parse("#{d1} #{d2} #{now.year} #{d3}")
         if result > now
           result = Time.parse("#{d1} #{d2} #{now.year-1} #{d3}")
@@ -102,7 +99,7 @@ module Rake # :nodoc:
       end
     end
 
-    # Create an FTP uploader targetting the directory +path+ on +host+
+    # Create an FTP uploader targeting the directory +path+ on +host+
     # using the given account and password.  +path+ will be the root
     # path of the uploader.
     def initialize(path, host, account, password)
@@ -121,7 +118,7 @@ module Rake # :nodoc:
         current_dir = File.join(route)
         if @created[current_dir].nil?
           @created[current_dir] = true
-          puts "Creating Directory  #{current_dir}" if @verbose
+          $stderr.puts "Creating Directory  #{current_dir}" if @verbose
           @ftp.mkdir(current_dir) rescue nil
         end
       end
@@ -134,7 +131,7 @@ module Rake # :nodoc:
         upload(fn)
       end
     end
-    
+
     # Close the uploader.
     def close
       @ftp.close
@@ -144,7 +141,7 @@ module Rake # :nodoc:
 
     # Upload a single file to the uploader's root path.
     def upload(file)
-      puts "Uploading #{file}" if @verbose
+      $stderr.puts "Uploading #{file}" if @verbose
       dir = File.dirname(file)
       makedirs(dir)
       @ftp.putbinaryfile(file, file) unless File.directory?(file)

data/lib/rake/contrib/publisher.rb

@@ -1,19 +1,13 @@
-#!/usr/bin/env ruby
-
-# Copyright 2003, 2004, 2005, 2006, 2007, 2008 by Jim Weirich (jim@weirichhouse.org)
+# Copyright 2003-2010 by Jim Weirich (jim.weirich@gmail.com)
 # All rights reserved.
 
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-
 # Configuration information about an upload host system.
 # * name   :: Name of host system.
 # * webdir :: Base directory for the web information for the
 #             application.  The application name (APP) is appended to
 #             this directory before using.
 # * pkgdir :: Directory on the host system where packages can be
-#             placed. 
+#             placed.
 HostInfo = Struct.new(:name, :webdir, :pkgdir)
 
 # Manage several publishers as a single entity.

data/lib/rake/contrib/rubyforgepublisher.rb

@@ -1,12 +1,10 @@
-#!/usr/bin/env ruby
-
 require 'rake/contrib/sshpublisher'
 
 module Rake
 
   class RubyForgePublisher < SshDirPublisher
     attr_reader :project, :proj_id, :user
-    
+
     def initialize(projname, user)
       super(
         "#{user}@rubyforge.org",
@@ -14,5 +12,5 @@ module Rake
         "html")
     end
   end
-  
+
 end

data/lib/rake/contrib/sshpublisher.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'rake/contrib/compositepublisher'
 
 module Rake
@@ -12,12 +10,12 @@ module Rake
       @remote_dir = remote_dir
       @local_dir = local_dir
     end
-    
+
     def upload
       sh %{scp -rq #{@local_dir}/* #{@host}:#{@remote_dir}}
     end
   end
-  
+
   # Publish an entire directory to a fresh remote directory using SSH.
   class SshFreshDirPublisher < SshDirPublisher
     def upload
@@ -26,7 +24,7 @@ module Rake
       super
     end
   end
-  
+
   # Publish a list of files to an existing remote directory.
   class SshFilePublisher
     # Create a publisher using the give host information.
@@ -36,7 +34,7 @@ module Rake
       @local_dir = local_dir
       @files = files
     end
-    
+
     # Upload the local directory to the remote directory.
     def upload
       @files.each do |fn|

data/lib/rake/contrib/sys.rb

@@ -1,26 +1,8 @@
-#!/usr/bin/env ruby
+warn 'Sys has been deprecated in favor of FileUtils'
 
 #--
-# Copyright 2003, 2004, 2005, 2006, 2007, 2008 by Jim Weirich (jim@weirichhouse.org)
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# Copyright 2003-2010 by Jim Weirich (jim.weirich@gmail.com)
+# All rights reserved.
 #++
 #
 begin
@@ -40,7 +22,7 @@ require 'rbconfig'
 # in Ruby 1.8.
 #
 module Sys
-  RUBY = Config::CONFIG['ruby_install_name']
+  RUBY = RbConfig::CONFIG['ruby_install_name']
 
   # Install all the files matching +wildcard+ into the +dest_dir+
   # directory.  The permission mode is set to +mode+.
@@ -60,7 +42,7 @@ module Sys
   def ruby(*args)
     run "#{RUBY} #{args.join(' ')}"
   end
-  
+
   # Copy a single file from +file_name+ to +dest_file+.
   def copy(file_name, dest_file)
     log "Copying file #{file_name} to #{dest_file}"
@@ -160,10 +142,10 @@ module Sys
     return split_all(head) + [tail]
   end
 
-  # Write a message to standard out if $verbose is enabled.
+  # Write a message to standard error if $verbose is enabled.
   def log(msg)
     print "  " if $trace && $verbose
-    puts msg if $verbose
+    $stderr.puts msg if $verbose
   end
 
   # Perform a block with $verbose disabled.

data/lib/rake/default_loader.rb

@@ -0,0 +1,10 @@
+module Rake
+
+  # Default Rakefile loader used by +import+.
+  class DefaultLoader
+    def load(fn)
+      Rake.load_rakefile(File.expand_path(fn))
+    end
+  end
+
+end

data/lib/rake/dsl.rb

@@ -0,0 +1,2 @@
+require 'rake'
+include Rake::DSL

data/lib/rake/dsl_definition.rb

@@ -0,0 +1,143 @@
+# Rake DSL functions.
+require 'rake/file_utils_ext'
+
+module Rake
+  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))
+    private(*FileUtilsExt.instance_methods(false))
+
+    # Declare a basic task.
+    #
+    # Example:
+    #   task :clobber => [:clean] do
+    #     rm_rf "html"
+    #   end
+    #
+    def task(*args, &block)
+      Rake::Task.define_task(*args, &block)
+    end
+
+
+    # Declare a file task.
+    #
+    # Example:
+    #   file "config.cfg" => ["config.template"] do
+    #     open("config.cfg", "w") do |outfile|
+    #       open("config.template") do |infile|
+    #         while line = infile.gets
+    #           outfile.puts line
+    #         end
+    #       end
+    #     end
+    #  end
+    #
+    def file(*args, &block)
+      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)
+    end
+
+    # Declare a set of files tasks to create the given directories on
+    # demand.
+    #
+    # Example:
+    #   directory "testdata/doc"
+    #
+    def directory(dir)
+      Rake.each_dir_parent(dir) do |d|
+        file_create d do |t|
+          mkdir_p t.name if ! File.exist?(t.name)
+        end
+      end
+    end
+
+    # Declare a task that performs its prerequisites in
+    # parallel. Multitasks does *not* guarantee that its prerequisites
+    # will execute in any given order (which is obvious when you think
+    # about it)
+    #
+    # Example:
+    #   multitask :deploy => [:deploy_gem, :deploy_rdoc]
+    #
+    def multitask(args, &block)
+      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.
+    #
+    #   ns = namespace "nested" do
+    #     task :run
+    #   end
+    #   task_run = ns[:run] # find :run in the given namespace.
+    #
+    def namespace(name=nil, &block)
+      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?
+        raise ArgumentError, "Expected a String or Symbol for a namespace name"
+      end
+      Rake.application.in_namespace(name, &block)
+    end
+
+    # Declare a rule for auto-tasks.
+    #
+    # Example:
+    #  rule '.o' => '.c' do |t|
+    #    sh %{cc -o #{t.name} #{t.source}}
+    #  end
+    #
+    def rule(*args, &block)
+      Rake::Task.create_rule(*args, &block)
+    end
+
+    # Describe the next rake task.
+    #
+    # Example:
+    #   desc "Run the Unit Tests"
+    #   task :test => [:build]
+    #     runtests
+    #   end
+    #
+    def desc(description)
+      Rake.application.last_description = description
+    end
+
+    # Import the partial Rakefiles +fn+.  Imported files are loaded
+    # _after_ the current file is completely loaded.  This allows the
+    # import statement to appear anywhere in the importing file, and yet
+    # allowing the imported files to depend on objects defined in the
+    # importing file.
+    #
+    # A common use of the import statement is to include files
+    # containing dependency declarations.
+    #
+    # See also the --rakelibdir command line option.
+    #
+    # Example:
+    #   import ".depend", "my_rules"
+    #
+    def import(*fns)
+      fns.each do |fn|
+        Rake.application.add_import(fn)
+      end
+    end
+  end
+
+  extend FileUtilsExt
+end
+
+self.extend Rake::DSL

data/lib/rake/early_time.rb

@@ -0,0 +1,18 @@
+module Rake
+
+  # EarlyTime is a fake timestamp that occurs _before_ any other time value.
+  class EarlyTime
+    include Comparable
+    include Singleton
+
+    def <=>(other)
+      -1
+    end
+
+    def to_s
+      "<EARLY TIME>"
+    end
+  end
+
+  EARLY = EarlyTime.instance
+end

data/lib/rake/ext/core.rb

@@ -0,0 +1,27 @@
+######################################################################
+# Core extension library
+#
+class Module
+  # Check for an existing method in the current class before extending.  IF
+  # the method already exists, then a warning is printed and the extension is
+  # not added.  Otherwise the block is yielded and any definitions in the
+  # block will take effect.
+  #
+  # Usage:
+  #
+  #   class String
+  #     rake_extension("xyz") do
+  #       def xyz
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  def rake_extension(method)
+    if method_defined?(method)
+      $stderr.puts "WARNING: Possible conflict with Rake extension: #{self}##{method} already exists"
+    else
+      yield
+    end
+  end
+end

data/lib/rake/ext/module.rb

@@ -0,0 +1,39 @@
+require 'rake/ext/core'
+require 'rake/task'
+require 'rake/file_task'
+require 'rake/file_creation_task'
+require 'rake/application'
+require 'rake/task_manager'
+
+######################################################################
+# Rake extensions to Module.
+#
+class Module
+
+  # Rename the original handler to make it available.
+  alias :rake_original_const_missing :const_missing
+
+  # Check for deprecated uses of top level (i.e. in Object) uses of
+  # Rake class names.  If someone tries to reference the constant
+  # name, display a warning and return the proper object.  Using the
+  # --classic-namespace command line option will define these
+  # constants in Object and avoid this handler.
+  def const_missing(const_name)
+    case const_name
+    when :Task
+      Rake.application.const_warning(const_name)
+      Rake::Task
+    when :FileTask
+      Rake.application.const_warning(const_name)
+      Rake::FileTask
+    when :FileCreationTask
+      Rake.application.const_warning(const_name)
+      Rake::FileCreationTask
+    when :RakeApp
+      Rake.application.const_warning(const_name)
+      Rake::Application
+    else
+      rake_original_const_missing(const_name)
+    end
+  end
+end

data/lib/rake/ext/string.rb

@@ -0,0 +1,167 @@
+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)
+      end
+      self.chomp(File.extname(self)) << newext
+    end
+  end
+
+  rake_extension("pathmap") do
+    # Explode a path into individual components.  Used by +pathmap+.
+    def pathmap_explode
+      head, tail = File.split(self)
+      return [self] if head == self
+      return [tail] if head == '.' || tail == '/'
+      return [head, tail] if head == '/'
+      return head.pathmap_explode + [tail]
+    end
+    protected :pathmap_explode
+
+    # 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.
+    def pathmap_partial(n)
+      dirs = File.dirname(self).pathmap_explode
+      partial_dirs =
+        if n > 0
+          dirs[0...n]
+        elsif n < 0
+          dirs.reverse[0...-n].reverse
+        else
+          "."
+        end
+      File.join(partial_dirs)
+    end
+    protected :pathmap_partial
+
+    # Preform the pathmap replacement operations on the given path. The
+    # patterns take the form 'pat1,rep1;pat2,rep2...'.
+    def pathmap_replace(patterns, &block)
+      result = self
+      patterns.split(';').each do |pair|
+        pattern, replacement = pair.split(',')
+        pattern = Regexp.new(pattern)
+        if replacement == '*' && block_given?
+          result = result.sub(pattern, &block)
+        elsif replacement
+          result = result.sub(pattern, replacement)
+        else
+          result = result.sub(pattern, '')
+        end
+      end
+      result
+    end
+    protected :pathmap_replace
+
+    # Map the path according to the given specification.  The specification
+    # 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.
+    #
+    # 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").
+    #
+    # 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
+    # excluded from both the pattern and replacement text (let's keep parsing
+    # reasonable).
+    #
+    # For example:
+    #
+    #    "src/org/onestepback/proj/A.java".pathmap("%{^src,bin}X.class")
+    #
+    # returns:
+    #
+    #    "bin/org/onestepback/proj/A.class"
+    #
+    # If the replacement text is '*', then a block may be provided to perform
+    # some arbitrary calculation for the replacement.
+    #
+    # For example:
+    #
+    #   "/path/to/file.TXT".pathmap("%X%{.*,*}x") { |ext|
+    #      ext.downcase
+    #   }
+    #
+    # Returns:
+    #
+    #  "/path/to/file.txt"
+    #
+    def pathmap(spec=nil, &block)
+      return self if spec.nil?
+      result = ''
+      spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
+        case frag
+        when '%f'
+          result << File.basename(self)
+        when '%n'
+          result << File.basename(self).ext
+        when '%d'
+          result << File.dirname(self)
+        when '%x'
+          result << File.extname(self)
+        when '%X'
+          result << self.ext
+        when '%p'
+          result << self
+        when '%s'
+          result << (File::ALT_SEPARATOR || File::SEPARATOR)
+        when '%-'
+          # do nothing
+        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)
+        when /^%/
+          fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
+        else
+          result << frag
+        end
+      end
+      result
+    end
+  end
+end # class String
+

data/lib/rake/ext/time.rb

@@ -0,0 +1,14 @@
+# ###########################################################################
+# Extensions to time to allow comparisons with an early time class.
+#
+class Time
+  alias rake_original_time_compare :<=>
+  def <=>(other)
+    if Rake::EarlyTime === other
+      - other.<=>(self)
+    else
+      rake_original_time_compare(other)
+    end
+  end
+end # class Time
+

data/lib/rake/file_creation_task.rb

@@ -0,0 +1,24 @@
+require 'rake/file_task'
+require 'rake/early_time'
+
+module Rake
+
+  # A FileCreationTask is a file task that when used as a dependency will be
+  # needed if and only if the file has not been created.  Once created, it is
+  # not re-triggered if any of its dependencies are newer, nor does trigger
+  # any rebuilds of tasks that depend on it whenever it is updated.
+  #
+  class FileCreationTask < FileTask
+    # Is this file task needed?  Yes if it doesn't exist.
+    def needed?
+      ! File.exist?(name)
+    end
+
+    # Time stamp for file creation task.  This time stamp is earlier
+    # than any other time stamp.
+    def timestamp
+      Rake::EARLY
+    end
+  end
+
+end