rake 0.8.7 → 0.9.0.beta.0

data/lib/rake/file_task.rb

@@ -0,0 +1,47 @@
+require 'rake/task.rb'
+require 'rake/early_time'
+
+module Rake
+  # #########################################################################
+  # A FileTask is a task that includes time based dependencies.  If any of a
+  # FileTask's prerequisites have a timestamp that is later than the file
+  # represented by this task, then the file must be rebuilt (using the
+  # supplied actions).
+  #
+  class FileTask < Task
+
+    # Is this file task needed?  Yes if it doesn't exist, or if its time stamp
+    # is out of date.
+    def needed?
+      ! File.exist?(name) || out_of_date?(timestamp)
+    end
+
+    # Time stamp for file task.
+    def timestamp
+      if File.exist?(name)
+        File.mtime(name.to_s)
+      else
+        Rake::EARLY
+      end
+    end
+
+    private
+
+    # Are there any prerequisites with a later time than the given time stamp?
+    def out_of_date?(stamp)
+      @prerequisites.any? { |n| application[n, @scope].timestamp > stamp}
+    end
+
+    # ----------------------------------------------------------------
+    # Task class methods.
+    #
+    class << self
+      # Apply the scope to the task name according to the rules for this kind
+      # of task.  File based tasks ignore the scope when creating the name.
+      def scope_name(scope, task_name)
+        task_name
+      end
+    end
+  end
+end
+

data/lib/rake/file_utils.rb

@@ -0,0 +1,112 @@
+require 'rbconfig'
+require 'fileutils'
+
+# ###########################################################################
+# This a FileUtils extension that defines several additional commands to be
+# added to the FileUtils utility functions.
+#
+module FileUtils
+  # Path to the currently running Ruby program
+  RUBY = File.join(
+    RbConfig::CONFIG['bindir'],
+    RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT']).
+    sub(/.*\s.*/m, '"\&"')
+
+  OPT_TABLE['sh']  = %w(noop verbose)
+  OPT_TABLE['ruby'] = %w(noop verbose)
+
+  # Run the system command +cmd+. If multiple arguments are given the command
+  # is not run with the shell (same semantics as Kernel::exec and
+  # Kernel::system).
+  #
+  # Example:
+  #   sh %{ls -ltr}
+  #
+  #   sh 'ls', 'file with spaces'
+  #
+  #   # check exit status after command runs
+  #   sh %{grep pattern file} do |ok, res|
+  #     if ! ok
+  #       puts "pattern not found (status = #{res.exitstatus})"
+  #     end
+  #   end
+  #
+  def sh(*cmd, &block)
+    options = (Hash === cmd.last) ? cmd.pop : {}
+    shell_runner = block_given? ? block : create_shell_runner(cmd)
+    set_verbose_option(options)
+    options[:noop] ||= Rake::FileUtilsExt.nowrite_flag
+    Rake.rake_check_options options, :noop, :verbose
+    Rake.rake_output_message cmd.join(" ") if options[:verbose]
+    unless options[:noop]
+      res = rake_system(*cmd)
+      status = $?
+      status = PseudoStatus.new(1) if !res && status.nil?
+      shell_runner.call(res, status)
+    end
+  end
+
+  def create_shell_runner(cmd)
+    show_command = cmd.join(" ")
+    show_command = show_command[0,42] + "..." unless $trace
+    lambda { |ok, status|
+      ok or fail "Command failed with status (#{status.exitstatus}): [#{show_command}]"
+    }
+  end
+  private :create_shell_runner
+
+  def set_verbose_option(options)
+    if options[:verbose].nil?
+      options[:verbose] = Rake::FileUtilsExt.verbose_flag.nil? || Rake::FileUtilsExt.verbose_flag
+    end
+  end
+  private :set_verbose_option
+
+  def rake_system(*cmd)
+    Rake::AltSystem.system(*cmd)
+  end
+  private :rake_system
+
+  # Run a Ruby interpreter with the given arguments.
+  #
+  # Example:
+  #   ruby %{-pe '$_.upcase!' <README}
+  #
+  def ruby(*args,&block)
+    options = (Hash === args.last) ? args.pop : {}
+    if args.length > 1 then
+      sh(*([RUBY] + args + [options]), &block)
+    else
+      sh("#{RUBY} #{args.first}", options, &block)
+    end
+  end
+
+  LN_SUPPORTED = [true]
+
+  #  Attempt to do a normal file link, but fall back to a copy if the link
+  #  fails.
+  def safe_ln(*args)
+    unless LN_SUPPORTED[0]
+      cp(*args)
+    else
+      begin
+        ln(*args)
+      rescue StandardError, NotImplementedError
+        LN_SUPPORTED[0] = false
+        cp(*args)
+      end
+    end
+  end
+
+  # Split a file path into individual directory names.
+  #
+  # Example:
+  #   split_all("a/b/c") =>  ['a', 'b', 'c']
+  #
+  def split_all(path)
+    head, tail = File.split(path)
+    return [tail] if head == '.' || tail == '/'
+    return [head, tail] if head == '/'
+    return split_all(head) + [tail]
+  end
+end

data/lib/rake/file_utils_ext.rb

@@ -0,0 +1,132 @@
+require 'rake/file_utils'
+
+module Rake
+  # ###########################################################################
+  # FileUtilsExt provides a custom version of the FileUtils methods that
+  # respond to the <tt>verbose</tt> and <tt>nowrite</tt> commands.
+  #
+  module FileUtilsExt
+    include FileUtils
+
+    class << self
+      attr_accessor :verbose_flag, :nowrite_flag
+    end
+    FileUtilsExt.verbose_flag = nil
+    FileUtilsExt.nowrite_flag = false
+
+    $fileutils_verbose = true
+    $fileutils_nowrite = false
+
+    FileUtils::OPT_TABLE.each do |name, opts|
+      default_options = []
+      if opts.include?(:verbose) || opts.include?("verbose")
+        default_options << ':verbose => FileUtilsExt.verbose_flag'
+      end
+      if opts.include?(:noop) || opts.include?("noop")
+        default_options << ':noop => FileUtilsExt.nowrite_flag'
+      end
+
+      next if default_options.empty?
+      module_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def #{name}( *args, &block )
+        super(
+          *rake_merge_option(args,
+            #{default_options.join(', ')}
+            ), &block)
+      end
+      EOS
+    end
+
+    # Get/set the verbose flag controlling output from the FileUtils utilities.
+    # If verbose is true, then the utility method is echoed to standard output.
+    #
+    # Examples:
+    #    verbose              # return the current value of the verbose flag
+    #    verbose(v)           # set the verbose flag to _v_.
+    #    verbose(v) { code }  # Execute code with the verbose flag set temporarily to _v_.
+    #                         # Return to the original value when code is done.
+    def verbose(value=nil)
+      oldvalue = FileUtilsExt.verbose_flag
+      FileUtilsExt.verbose_flag = value unless value.nil?
+      if block_given?
+        begin
+          yield
+        ensure
+          FileUtilsExt.verbose_flag = oldvalue
+        end
+      end
+      FileUtilsExt.verbose_flag
+    end
+
+    # Get/set the nowrite flag controlling output from the FileUtils utilities.
+    # If verbose is true, then the utility method is echoed to standard output.
+    #
+    # Examples:
+    #    nowrite              # return the current value of the nowrite flag
+    #    nowrite(v)           # set the nowrite flag to _v_.
+    #    nowrite(v) { code }  # Execute code with the nowrite flag set temporarily to _v_.
+    #                         # Return to the original value when code is done.
+    def nowrite(value=nil)
+      oldvalue = FileUtilsExt.nowrite_flag
+      FileUtilsExt.nowrite_flag = value unless value.nil?
+      if block_given?
+        begin
+          yield
+        ensure
+          FileUtilsExt.nowrite_flag = oldvalue
+        end
+      end
+      oldvalue
+    end
+
+    # Use this function to prevent potentially destructive ruby code from
+    # running when the :nowrite flag is set.
+    #
+    # Example:
+    #
+    #   when_writing("Building Project") do
+    #     project.build
+    #   end
+    #
+    # The following code will build the project under normal conditions. If the
+    # nowrite(true) flag is set, then the example will print:
+    #      DRYRUN: Building Project
+    # instead of actually building the project.
+    #
+    def when_writing(msg=nil)
+      if FileUtilsExt.nowrite_flag
+        $stderr.puts "DRYRUN: #{msg}" if msg
+      else
+        yield
+      end
+    end
+
+    # Merge the given options with the default values.
+    def rake_merge_option(args, defaults)
+      if Hash === args.last
+        defaults.update(args.last)
+        args.pop
+      end
+      args.push defaults
+      args
+    end
+
+    # Send the message to the default rake output (which is $stderr).
+    def rake_output_message(message)
+      $stderr.puts(message)
+    end
+
+    # Check that the options do not contain options not listed in +optdecl+.  An
+    # ArgumentError exception is thrown if non-declared options are found.
+    def rake_check_options(options, *optdecl)
+      h = options.dup
+      optdecl.each do |name|
+        h.delete name
+      end
+      raise ArgumentError, "no such option: #{h.keys.join(' ')}" unless h.empty?
+    end
+
+    extend self
+  end
+
+end

data/lib/rake/gempackagetask.rb

@@ -1,97 +1,13 @@
-#!/usr/bin/env ruby
+# rake/gempackagetask is deprecated in favor of rubygems/package_task
 
-# Define a package task library to aid in the definition of GEM
-# packages.
+warn 'rake/gempackagetask is deprecated.  Use rubygems/package_task instead'
 
 require 'rubygems'
+require 'rubygems/package_task'
+
 require 'rake'
-require 'rake/packagetask'
-require 'rubygems/user_interaction'
-require 'rubygems/builder'
 
 module Rake
-
-  # Create a package based upon a Gem spec.  Gem packages, as well as
-  # zip files and tar/gzipped packages can be produced by this task.
-  #
-  # In addition to the Rake targets generated by PackageTask, a
-  # GemPackageTask will also generate the following tasks:
-  #
-  # [<b>"<em>package_dir</em>/<em>name</em>-<em>version</em>.gem"</b>]
-  #   Create a Ruby GEM package with the given name and version.
-  #
-  # Example using a Ruby GEM spec:
-  #
-  #   require 'rubygems'
-  #
-  #   spec = Gem::Specification.new do |s|
-  #     s.platform = Gem::Platform::RUBY
-  #     s.summary = "Ruby based make-like utility."
-  #     s.name = 'rake'
-  #     s.version = PKG_VERSION
-  #     s.requirements << 'none'
-  #     s.require_path = 'lib'
-  #     s.autorequire = 'rake'
-  #     s.files = PKG_FILES
-  #     s.description = <<EOF
-  #   Rake is a Make-like program implemented in Ruby. Tasks
-  #   and dependencies are specified in standard Ruby syntax. 
-  #   EOF
-  #   end
-  #   
-  #   Rake::GemPackageTask.new(spec) do |pkg|
-  #     pkg.need_zip = true
-  #     pkg.need_tar = true
-  #   end
-  #
-  class GemPackageTask < PackageTask
-    # Ruby GEM spec containing the metadata for this package.  The
-    # name, version and package_files are automatically determined
-    # from the GEM spec and don't need to be explicitly provided.
-    attr_accessor :gem_spec
-
-    # Create a GEM Package task library.  Automatically define the gem
-    # if a block is given.  If no block is supplied, then +define+
-    # needs to be called to define the task.
-    def initialize(gem_spec)
-      init(gem_spec)
-      yield self if block_given?
-      define if block_given?
-    end
-
-    # Initialization tasks without the "yield self" or define
-    # operations.
-    def init(gem)
-      super(gem.name, gem.version)
-      @gem_spec = gem
-      @package_files += gem_spec.files if gem_spec.files
-    end
-
-    # Create the Rake tasks and actions specified by this
-    # GemPackageTask.  (+define+ is automatically called if a block is
-    # given to +new+).
-    def define
-      super
-      task :package => [:gem]
-      desc "Build the gem file #{gem_file}"
-      task :gem => ["#{package_dir}/#{gem_file}"]
-      file "#{package_dir}/#{gem_file}" => [package_dir] + @gem_spec.files do
-        when_writing("Creating GEM") {
-          Gem::Builder.new(gem_spec).build
-          verbose(true) {
-            mv gem_file, "#{package_dir}/#{gem_file}"
-          }
-        }
-      end
-    end
-    
-    def gem_file
-      if @gem_spec.platform == Gem::Platform::RUBY
-        "#{package_name}.gem"
-      else
-        "#{package_name}-#{@gem_spec.platform}.gem"
-      end
-    end
-    
-  end
+  GemPackageTask = Gem::PackageTask
 end
+

data/lib/rake/invocation_chain.rb

@@ -0,0 +1,51 @@
+module Rake
+
+  ####################################################################
+  # InvocationChain tracks the chain of task invocations to detect
+  # circular dependencies.
+  class InvocationChain
+    def initialize(value, tail)
+      @value = value
+      @tail = tail
+    end
+
+    def member?(obj)
+      @value == obj || @tail.member?(obj)
+    end
+
+    def append(value)
+      if member?(value)
+        fail RuntimeError, "Circular dependency detected: #{to_s} => #{value}"
+      end
+      self.class.new(value, self)
+    end
+
+    def to_s
+      "#{prefix}#{@value}"
+    end
+
+    def self.append(value, chain)
+      chain.append(value)
+    end
+
+    private
+
+    def prefix
+      "#{@tail.to_s} => "
+    end
+
+    class EmptyInvocationChain
+      def member?(obj)
+        false
+      end
+      def append(value)
+        InvocationChain.new(value, self)
+      end
+      def to_s
+        "TOP"
+      end
+    end
+
+    EMPTY = EmptyInvocationChain.new
+  end
+end