jimweirich-rake 0.8.1.5

data/lib/rake/contrib/sys.rb

@@ -0,0 +1,209 @@
+#!/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.
+#++
+#
+begin
+  require 'ftools'
+rescue LoadError
+end
+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

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+# Define a package task library to aid in the definition of GEM
+# packages.
+
+require 'rubygems'
+require 'rake'
+require 'rake/packagetask'
+require 'rubygems/user_interaction'
+require 'rubygems/builder'
+
+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]
+      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
+end

data/lib/rake/loaders/makefile.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+module Rake
+
+  # Makefile loader to be used with the import file loader.
+  class MakefileLoader
+
+    # Load the makefile dependencies in +fn+.
+    def load(fn)
+      buffer = ''
+      open(fn) do |mf|
+        mf.each do |line|
+          next if line =~ /^\s*#/
+          buffer << line
+          if buffer =~ /\\$/
+            buffer.sub!(/\\\n/, ' ')
+            state = :append
+          else
+            process_line(buffer)
+            buffer = ''
+          end
+        end
+      end
+      process_line(buffer) if buffer != ''
+    end
+
+    private
+
+    # Process one logical line of makefile data.
+    def process_line(line)
+      file_task, args = line.split(':')
+      return if args.nil?
+      dependents = args.split
+      file file_task => dependents
+    end
+  end
+
+  # Install the handler
+  Rake.application.add_loader('mf', MakefileLoader.new)
+end

data/lib/rake/packagetask.rb

@@ -0,0 +1,184 @@
+#!/usr/bin/env ruby
+
+# Define a package task libarary to aid in the definition of
+# redistributable package files.
+
+require 'rake'
+require 'rake/tasklib'
+
+module Rake
+
+  # Create a packaging task that will package the project into
+  # distributable files (e.g zip archive or tar files).
+  #
+  # The PackageTask will create the following targets:
+  #
+  # [<b>:package</b>]
+  #   Create all the requested package files.
+  #
+  # [<b>:clobber_package</b>]
+  #   Delete all the package files.  This target is automatically
+  #   added to the main clobber target.
+  #
+  # [<b>:repackage</b>]
+  #   Rebuild the package files from scratch, even if they are not out
+  #   of date.
+  #
+  # [<b>"<em>package_dir</em>/<em>name</em>-<em>version</em>.tgz"</b>]
+  #   Create a gzipped tar package (if <em>need_tar</em> is true).  
+  #
+  # [<b>"<em>package_dir</em>/<em>name</em>-<em>version</em>.tar.gz"</b>]
+  #   Create a gzipped tar package (if <em>need_tar_gz</em> is true).  
+  #
+  # [<b>"<em>package_dir</em>/<em>name</em>-<em>version</em>.tar.bz2"</b>]
+  #   Create a bzip2'd tar package (if <em>need_tar_bz2</em> is true).  
+  #
+  # [<b>"<em>package_dir</em>/<em>name</em>-<em>version</em>.zip"</b>]
+  #   Create a zip package archive (if <em>need_zip</em> is true).
+  #
+  # Example:
+  #
+  #   Rake::PackageTask.new("rake", "1.2.3") do |p|
+  #     p.need_tar = true
+  #     p.package_files.include("lib/**/*.rb")
+  #   end
+  #
+  class PackageTask < TaskLib
+    # Name of the package (from the GEM Spec).
+    attr_accessor :name
+
+    # Version of the package (e.g. '1.3.2').
+    attr_accessor :version
+
+    # Directory used to store the package files (default is 'pkg').
+    attr_accessor :package_dir
+
+    # True if a gzipped tar file (tgz) should be produced (default is false).
+    attr_accessor :need_tar
+
+    # True if a gzipped tar file (tar.gz) should be produced (default is false).
+    attr_accessor :need_tar_gz
+
+    # True if a bzip2'd tar file (tar.bz2) should be produced (default is false).
+    attr_accessor :need_tar_bz2
+
+    # True if a zip file should be produced (default is false)
+    attr_accessor :need_zip
+
+    # List of files to be included in the package.
+    attr_accessor :package_files
+
+    # Tar command for gzipped or bzip2ed archives.  The default is 'tar'.
+    attr_accessor :tar_command
+
+    # Zip command for zipped archives.  The default is 'zip'.
+    attr_accessor :zip_command
+
+    # Create a Package Task with the given name and version. 
+    def initialize(name=nil, version=nil)
+      init(name, version)
+      yield self if block_given?
+      define unless name.nil?
+    end
+
+    # Initialization that bypasses the "yield self" and "define" step.
+    def init(name, version)
+      @name = name
+      @version = version
+      @package_files = Rake::FileList.new
+      @package_dir = 'pkg'
+      @need_tar = false
+      @need_tar_gz = false
+      @need_tar_bz2 = false
+      @need_zip = false
+      @tar_command = 'tar'
+      @zip_command = 'zip'
+    end
+
+    # Create the tasks defined by this task library.
+    def define
+      fail "Version required (or :noversion)" if @version.nil?
+      @version = nil if :noversion == @version
+
+      desc "Build all the packages"
+      task :package
+      
+      desc "Force a rebuild of the package files"
+      task :repackage => [:clobber_package, :package]
+      
+      desc "Remove package products" 
+      task :clobber_package do
+        rm_r package_dir rescue nil
+      end
+
+      task :clobber => [:clobber_package]
+
+      [
+        [need_tar, tgz_file, "z"],
+        [need_tar_gz, tar_gz_file, "z"],
+        [need_tar_bz2, tar_bz2_file, "j"]
+      ].each do |(need, file, flag)|
+        if need
+          task :package => ["#{package_dir}/#{file}"]
+          file "#{package_dir}/#{file}" => [package_dir_path] + package_files do
+            chdir(package_dir) do
+              sh %{#{@tar_command} #{flag}cvf #{file} #{package_name}}
+            end
+          end
+        end
+      end
+      
+      if need_zip
+        task :package => ["#{package_dir}/#{zip_file}"]
+        file "#{package_dir}/#{zip_file}" => [package_dir_path] + package_files do
+          chdir(package_dir) do
+            sh %{#{@zip_command} -r #{zip_file} #{package_name}}
+          end
+        end
+      end
+
+      directory package_dir
+
+      file package_dir_path => @package_files do
+        mkdir_p package_dir rescue nil
+        @package_files.each do |fn|
+          f = File.join(package_dir_path, fn)
+          fdir = File.dirname(f)
+          mkdir_p(fdir) if !File.exist?(fdir)
+          if File.directory?(fn)
+            mkdir_p(f)
+          else
+            rm_f f
+            safe_ln(fn, f)
+          end
+        end
+      end
+      self
+    end
+
+    def package_name
+      @version ? "#{@name}-#{@version}" : @name
+    end
+      
+    def package_dir_path
+      "#{package_dir}/#{package_name}"
+    end
+
+    def tgz_file
+      "#{package_name}.tgz"
+    end
+
+    def tar_gz_file
+      "#{package_name}.tar.gz"
+    end
+
+    def tar_bz2_file
+      "#{package_name}.tar.bz2"
+    end
+
+    def zip_file
+      "#{package_name}.zip"
+    end
+  end
+
+end

data/lib/rake/rake_test_loader.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+# Load the test files from the command line.
+
+ARGV.each { |f| load f unless f =~ /^-/  }

data/lib/rake/rdoctask.rb

@@ -0,0 +1,147 @@
+#!/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 RDocTask 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 rdoc files.  This target is automatically
+  #   added to the main clobber target.
+  #
+  # [<b>:re<em>rdoc</em></b>]
+  #   Rebuild the rdoc files from scratch, even if they are not out
+  #   of date.
+  #
+  # Simple Example:
+  #
+  #   Rake::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:
+  #
+  #   Rake::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
+
+    # Run the rdoc process as an external shell (default is false)
+    attr_accessor :external
+
+    # 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'
+      @external = false
+      @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
+        args = option_list + @rdoc_files
+        if @external
+          argstring = args.join(' ')
+          sh %{ruby -Ivendor vender/rd #{argstring}}
+        else
+          require 'rdoc/rdoc'
+          RDoc::RDoc.new.document(args)
+        end
+      end
+      self
+    end
+
+    def option_list
+      result = @options.dup
+      result << "-o" << @rdoc_dir
+      result << "--main" << quote(main) if main
+      result << "--title" << quote(title) if title
+      result << "-T" << quote(template) if template
+      result
+    end
+
+    def quote(str)
+      if @external
+        "'#{str}'"
+      else
+        str
+      end
+    end
+
+    def option_string
+      option_list.join(' ')
+    end
+
+    private
+
+    def rdoc_target
+      "#{rdoc_dir}/index.html"
+    end
+
+  end
+end