rake 0.4.11 → 13.4.2

data/lib/rake/contrib/sys.rb

@@ -1,207 +0,0 @@
-#!/usr/bin/env ruby
-
-#--
-# Copyright (c) 2003, 2004 Jim Weirich
-#
-# 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.
-#++
-#
-require 'ftools'
-require 'rbconfig'
-
-######################################################################
-# Sys provides a number of file manipulation tools for the convenience
-# of writing Rakefiles.  All commands in this module will announce
-# their activity on standard output if the $verbose flag is set
-# ($verbose = true is the default).  You can control this by globally
-# setting $verbose or by using the +verbose+ and +quiet+ methods.
-#
-# Sys has been deprecated in favor of the FileUtils module available
-# in Ruby 1.8.
-#
-module Sys
-  RUBY = Config::CONFIG['ruby_install_name']
-
-  # Install all the files matching +wildcard+ into the +dest_dir+
-  # directory.  The permission mode is set to +mode+.
-  def install(wildcard, dest_dir, mode)
-    Dir[wildcard].each do |fn|
-      File.install(fn, dest_dir, mode, $verbose)
-    end
-  end
-
-  # Run the system command +cmd+.
-  def run(cmd)
-    log cmd
-    system(cmd) or fail "Command Failed: [#{cmd}]"
-  end
-
-  # Run a Ruby interpreter with the given arguments.
-  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}"
-    File.copy(file_name, dest_file)
-  end
-
-  # Copy all files matching +wildcard+ into the directory +dest_dir+.
-  def copy_files(wildcard, dest_dir)
-    for_matching_files(wildcard, dest_dir) { |from, to| copy(from, to) }
-  end
-
-  # Link +file_name+ to +dest_file+.
-  def link(file_name, dest_file)
-    log "Linking file #{file_name} to #{dest_file}"
-    File.link(file_name, dest_file)
-  end
-
-  # Link all files matching +wildcard+ into the directory +dest_dir+.
-  def link_files(wildcard, dest_dir)
-    for_matching_files(wildcard, dest_dir) { |from, to| link(from, to) }
-  end
-
-  # Symlink +file_name+ to +dest_file+.
-  def symlink(file_name, dest_file)
-    log "Symlinking file #{file_name} to #{dest_file}"
-    File.symlink(file_name, dest_file)
-  end
-
-  # Symlink all files matching +wildcard+ into the directory +dest_dir+.
-  def symlink_files(wildcard, dest_dir)
-    for_matching_files(wildcard, dest_dir) { |from, to| link(from, to) }
-  end
-
-  # Remove all files matching +wildcard+.  If a matching file is a
-  # directory, it must be empty to be removed.  used +delete_all+ to
-  # recursively delete directories.
-  def delete(*wildcards)
-    wildcards.each do |wildcard|
-      Dir[wildcard].each do |fn|
-	if File.directory?(fn)
-	  log "Deleting directory #{fn}"
-	  Dir.delete(fn)
-	else
-	  log "Deleting file #{fn}"
-	  File.delete(fn)
-	end
-      end
-    end
-  end
-
-  # Recursively delete all files and directories matching +wildcard+.
-  def delete_all(*wildcards)
-    wildcards.each do |wildcard|
-      Dir[wildcard].each do |fn|
-	next if ! File.exist?(fn)
-	if File.directory?(fn)
-	  Dir["#{fn}/*"].each do |subfn|
-	    next if subfn=='.' || subfn=='..'
-	    delete_all(subfn)
-	  end
-	  log "Deleting directory #{fn}"
-	  Dir.delete(fn)
-	else
-	  log "Deleting file #{fn}"
-	  File.delete(fn)
-	end
-      end
-    end
-  end
-
-  # Make the directories given in +dirs+.
-  def makedirs(*dirs)
-    dirs.each do |fn|
-      log "Making directory #{fn}"
-      File.makedirs(fn)
-    end
-  end
-
-  # Make +dir+ the current working directory for the duration of
-  # executing the given block.
-  def indir(dir)
-    olddir = Dir.pwd
-    Dir.chdir(dir)
-    yield
-  ensure
-    Dir.chdir(olddir)
-  end
-
-  # Split a file path into individual directory names.
-  #
-  # For 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
-
-  # Write a message to standard out if $verbose is enabled.
-  def log(msg)
-    print "  " if $trace && $verbose
-    puts msg if $verbose
-  end
-
-  # Perform a block with $verbose disabled.
-  def quiet(&block)
-    with_verbose(false, &block)
-  end
-
-  # Perform a block with $verbose enabled.
-  def verbose(&block)
-    with_verbose(true, &block)
-  end
-
-  # Perform a block with each file matching a set of wildcards.
-  def for_files(*wildcards)
-    wildcards.each do |wildcard|
-      Dir[wildcard].each do |fn|
-	yield(fn)
-      end
-    end
-  end
-
-  extend(self)
-
-  private # ----------------------------------------------------------
-
-  def for_matching_files(wildcard, dest_dir)
-    Dir[wildcard].each do |fn|
-      dest_file = File.join(dest_dir, fn)
-      parent = File.dirname(dest_file)
-      makedirs(parent) if ! File.directory?(parent)
-      yield(fn, dest_file)
-    end
-  end
-
-  def with_verbose(v)
-    oldverbose = $verbose
-    $verbose = v
-    yield
-  ensure
-    $verbose = oldverbose
-  end
-
-end
-

data/lib/rake/gempackagetask.rb

@@ -1,98 +0,0 @@
-#!/usr/bin/env ruby
-
-# Define a package task library to aid in the definition of GEM
-# packages.
-
-require 'rubygems'
-require 'rake'
-require 'rake/packagetask'
-
-begin
-  Gem.manage_gems
-rescue NoMethodError => ex
-  # Using rubygems prior to 0.6.1
-end
-
-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]
-      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
-    
-    private
-    
-    def gem_file
-      "#{package_name}.gem"
-    end
-    
-  end
-end

data/lib/rake/rdoctask.rb

@@ -1,128 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rake'
-require 'rake/tasklib'
-
-module Rake
-
-  # Create a documentation task that will generate the RDoc files for
-  # a project.
-  #
-  # The PackageTask will create the following targets:
-  #
-  # [<b><em>rdoc</em></b>]
-  #   Main task for this RDOC task.  
-  #
-  # [<b>:clobber_<em>rdoc</em></b>]
-  #   Delete all the package files.  This target is automatically
-  #   added to the main clobber target.
-  #
-  # [<b>:re<em>rdoc</em></b>]
-  #   Rebuild the package files from scratch, even if they are not out
-  #   of date.
-  #
-  # Simple Example:
-  #
-  #   RDocTask.new do |rd|
-  #     rd.main = "README.rdoc"
-  #     rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
-  #   end
-  #
-  # You may wish to give the task a different name, such as if you are
-  # generating two sets of documentation.  For instance, if you want to have a
-  # development set of documentation including private methods:
-  #
-  #   RDocTask.new(:rdoc_dev) do |rd|
-  #     rd.main = "README.doc"
-  #     rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
-  #     rd.options << "--all"
-  #   end
-  #
-  # The tasks would then be named :<em>rdoc_dev</em>, :clobber_<em>rdoc_dev</em>, and
-  # :re<em>rdoc_dev</em>.
-  #
-  class RDocTask < TaskLib
-    # Name of the main, top level task.  (default is :rdoc)
-    attr_accessor :name
-
-    # Name of directory to receive the html output files. (default is "html")
-    attr_accessor :rdoc_dir
-
-    # Title of RDoc documentation. (default is none)
-    attr_accessor :title
-
-    # Name of file to be used as the main, top level file of the
-    # RDoc. (default is none)
-    attr_accessor :main
-
-    # Name of template to be used by rdoc. (default is 'html')
-    attr_accessor :template
-
-    # List of files to be included in the rdoc generation. (default is [])
-    attr_accessor :rdoc_files
-
-    # List of options to be passed rdoc.  (default is [])
-    attr_accessor :options
-
-    # Create an RDoc task named <em>rdoc</em>.  Default task name is +rdoc+.
-    def initialize(name=:rdoc)	# :yield: self
-      @name = name
-      @rdoc_files = Rake::FileList.new
-      @rdoc_dir = 'html'
-      @main = nil
-      @title = nil
-      @template = 'html'
-      @options = []
-      yield self if block_given?
-      define
-    end
-    
-    # Create the tasks defined by this task lib.
-    def define
-      if name.to_s != "rdoc"
-	desc "Build the RDOC HTML Files"
-      end
-
-      desc "Build the #{name} HTML Files"
-      task name
-      
-      desc "Force a rebuild of the RDOC files"
-      task paste("re", name) => [paste("clobber_", name), name]
-      
-      desc "Remove rdoc products" 
-      task paste("clobber_", name) do
-	rm_r rdoc_dir rescue nil
-      end
-
-      task :clobber => [paste("clobber_", name)]
-      
-      directory @rdoc_dir
-      task name => [rdoc_target]
-      file rdoc_target => @rdoc_files + [$rakefile] do
-	rm_r @rdoc_dir rescue nil
-	opts = option_list.join(' ')
-	sh %{rdoc -o #{@rdoc_dir} #{opts} #{@rdoc_files}}
-      end
-      self
-    end
-
-    def option_list
-      result = @options.dup
-      result << "--main" << "'#{main}'" if main
-      result << "--title" << "'#{title}'" if title
-      result << "-T" << "'#{template}'" if template
-      result
-    end
-
-    def option_string
-      option_list.join(' ')
-    end
-
-    private
-
-    def rdoc_target
-      "#{rdoc_dir}/index.html"
-    end
-
-  end
-end

data/lib/rake/runtest.rb

@@ -1,23 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'test/unit/assertions'
-
-module Rake
-  include Test::Unit::Assertions
-
-  def run_tests(pattern='test/test*.rb', log_enabled=false)
-    Dir["#{pattern}"].each { |fn|
-      puts fn if log_enabled
-      begin
-	load fn
-      rescue Exception => ex
-	puts "Error in #{fn}: #{ex.message}"
-	puts ex.backtrace
-	assert false
-      end
-    }
-  end
-
-  extend self
-end

data/test/contrib/testsys.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'test/filecreation'
-require 'rake/contrib/sys'
-
-class TestSys < Test::Unit::TestCase
-  include FileCreation
-
-#   def test_delete
-#     create_file("testdata/a")
-#     Sys.delete_all("testdata/a")
-#     assert ! File.exist?("testdata/a")
-#   end
-
-#   def test_copy
-#     create_file("testdata/a")
-#     Sys.copy("testdata/a", "testdata/b")
-#     assert File.exist?("testdata/b")
-#   end
-
-#   def test_for_files
-#     test_files = ["testdata/a.pl", "testdata/c.pl", "testdata/b.rb"]
-#     test_files.each { |fn| create_file(fn) }
-#     list = []
-#     Sys.for_files("testdata/*.pl", "testdata/*.rb") { |fn|
-#       list << fn
-#     }
-#     assert_equal test_files.sort, list.sort
-#   end
-
-#   def test_indir
-#     here = Dir.pwd
-#     Sys.makedirs("testdata/dir")
-#     assert_equal "#{here}/testdata/dir", Sys.indir("testdata/dir") { Dir.pwd }
-#     assert_equal here, Dir.pwd
-#   end
-
-  def test_split_all
-    assert_equal ['a'], Sys.split_all('a')
-    assert_equal ['..'], Sys.split_all('..')
-    assert_equal ['/'], Sys.split_all('/')
-    assert_equal ['a', 'b'], Sys.split_all('a/b')
-    assert_equal ['/', 'a', 'b'], Sys.split_all('/a/b')
-    assert_equal ['..', 'a', 'b'], Sys.split_all('../a/b')
-  end
-end

data/test/data/rbext/rakefile.rb

@@ -1,3 +0,0 @@
-task :default do
-  puts "OK"
-end

data/test/filecreation.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'ftools'
-
-module FileCreation
-  def create_timed_files(oldfile, newfile)
-    return if File.exist?(oldfile) && File.exist?(newfile)
-    old_time = create_file(oldfile)
-    while create_file(newfile) <= old_time
-      sleep(0.1)
-      File.delete(newfile) rescue nil
-    end
-  end
-
-  def create_file(name)
-    dirname = File.dirname(name)
-    FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
-    open(name, "w") {|f| f.puts "HI" } unless File.exist?(name)
-    File.new(name).mtime
-  end
-
-  def delete_file(name)
-    File.delete(name) rescue nil
-  end
-end
-

data/test/functional.rb

@@ -1,82 +0,0 @@
-#!/usr/bin/env ruby
-
-begin
-  require 'rubygems'
-  require_gem 'session'
-rescue LoadError
-  puts "UNABLE TO RUN FUNCTIONAL TESTS"
-  puts "No Session Found"
-end
-
-require 'test/unit'
-require 'fileutils'
-
-class FunctionalTest < Test::Unit::TestCase
-  def setup
-    @rake_path = File.expand_path("bin/rake")
-    lib_path = File.expand_path("lib")
-    @ruby_options = "-I#{lib_path} -I."
-    @verbose = true if ENV['VERBOSE']
-  end
-
-  def test_rake_default
-    Dir.chdir("test/data/default") do rake end
-    assert_match /^DEFAULT$/, @out
-    assert_status
-  end
-
-  def test_rake_error_on_bad_task
-    Dir.chdir("test/data/default") do rake "xyz" end
-    assert_match /rake aborted/, @out
-    assert_status(1)
-  end
-
-  def test_env_availabe_at_top_scope
-    Dir.chdir("test/data/default") do rake "TESTTOPSCOPE=1" end
-    assert_match /^TOPSCOPE$/, @out
-    assert_status
-  end
-
-  def test_env_availabe_at_task_scope
-    Dir.chdir("test/data/default") do rake "TESTTASKSCOPE=1 task_scope" end
-    assert_match /^TASKSCOPE$/, @out
-    assert_status
-  end
-
-  def test_multi_desc
-    Dir.chdir("test/data/multidesc") do rake "-T" end
-    assert_match %r{^rake a *# A / A2 *$}, @out
-    assert_match %r{^rake b *# B *$}, @out
-    assert_no_match %r{^rake c}, @out
-  end
-
-  def test_rbext
-    Dir.chdir("test/data/rbext") do rake "-N" end
-    assert_match %r{^OK$}, @out
-  end
-
-  def test_nosearch
-    Dir.chdir("test/data/nosearch") do rake "-N" end
-    assert_match %r{^No Rakefile found}, @out
-  end
-
-  private
-
-  def rake(options="")
-    shell = Session::Shell.new
-    command = "ruby #{@ruby_options} #{@rake_path} #{options}"
-    puts "COMMAND: [#{command}]" if @verbose
-    @out, @err = shell.execute command
-    @status = shell.exit_status
-    puts "STATUS:  [#{@status}]" if @verbose
-    puts "OUTPUT:  [#{@out}]" if @verbose
-    puts "ERROR:   [#{@err}]" if @verbose
-    puts "PWD:     [#{Dir.pwd}]" if @verbose
-    shell.close
-  end
-
-  def assert_status(expected_status=0)
-    assert_equal expected_status, @status
-  end
-
-end

data/test/shellcommand.rb

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-
-exit((ARGV[0] || "0").to_i)

data/test/testclean.rb

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'rake/clean'
-
-class TestClean < Test::Unit::TestCase
-  def test_clean
-    assert Task['clean'], "Should define clean"
-    assert Task['clobber'], "Should define clobber"
-    assert Task['clobber'].prerequisites.include?("clean"),
-      "Clobber should require clean"
-  end
-end