rake 0.9.6 → 10.0.0.beta.1

data/lib/rake/gempackagetask.rb

@@ -1,15 +0,0 @@
-# rake/gempackagetask is deprecated in favor of rubygems/package_task
-
-warn 'rake/gempackagetask is deprecated.  Use rubygems/package_task instead'
-
-require 'rubygems'
-require 'rubygems/package_task'
-
-require 'rake'
-
-# :stopdoc:
-
-module Rake
-  GemPackageTask = Gem::PackageTask
-end
-

data/lib/rake/private_reader.rb

@@ -1,20 +0,0 @@
-module Rake
-
-  # Include PrivateReader to use +private_reader+.
-  module PrivateReader           # :nodoc: all
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-
-      # Declare a list of private accessors
-      def private_reader(*names)
-        attr_reader(*names)
-        private(*names)
-      end
-    end
-
-  end
-end

data/lib/rake/promise.rb

@@ -1,99 +0,0 @@
-module Rake
-
-  # A Promise object represents a promise to do work (a chore) in the
-  # future. The promise is created with a block and a list of
-  # arguments for the block. Calling value will return the value of
-  # the promised chore.
-  #
-  # Used by ThreadPool.
-  #
-  class Promise               # :nodoc: all
-    NOT_SET = Object.new.freeze # :nodoc:
-
-    attr_accessor :recorder
-
-    # Create a promise to do the chore specified by the block.
-    def initialize(args, &block)
-      @mutex = Mutex.new
-      @result = NOT_SET
-      @error = NOT_SET
-      @args = args.collect { |a| begin; a.dup; rescue; a; end }
-      @block = block
-    end
-
-    # Return the value of this promise.
-    #
-    # If the promised chore is not yet complete, then do the work
-    # synchronously. We will wait.
-    def value
-      unless complete?
-        stat :sleeping_on, :item_id => object_id
-        @mutex.synchronize do
-          stat :has_lock_on, :item_id => object_id
-          chore
-          stat :releasing_lock_on, :item_id => object_id
-        end
-      end
-      error? ? raise(@error) : @result
-    end
-
-    # If no one else is working this promise, go ahead and do the chore.
-    def work
-      stat :attempting_lock_on, :item_id => object_id
-      if @mutex.try_lock
-        stat :has_lock_on, :item_id => object_id
-        chore
-        stat :releasing_lock_on, :item_id => object_id
-        @mutex.unlock
-      else
-        stat :bailed_on, :item_id => object_id
-      end
-    end
-
-    private
-
-    # Perform the chore promised
-    def chore
-      if complete?
-        stat :found_completed, :item_id => object_id
-        return
-      end
-      stat :will_execute, :item_id => object_id
-      begin
-        @result = @block.call(*@args)
-      rescue Exception => e
-        @error = e
-      end
-      stat :did_execute, :item_id => object_id
-      discard
-    end
-
-    # Do we have a result for the promise
-    def result?
-      ! @result.equal?(NOT_SET)
-    end
-
-    # Did the promise throw an error
-    def error?
-      ! @error.equal?(NOT_SET)
-    end
-
-    # Are we done with the promise
-    def complete?
-      result? || error?
-    end
-
-    # free up these items for the GC
-    def discard
-      @args = nil
-      @block = nil
-    end
-
-    # Record execution statistics if there is a recorder
-    def stat(*args)
-      @recorder.call(*args) if @recorder
-    end
-
-  end
-
-end

data/lib/rake/rdoctask.rb

@@ -1,234 +0,0 @@
-# rake/rdoctask is deprecated in favor of rdoc/task
-
-if Rake.application
-  Rake.application.deprecate('require \'rake/rdoctask\'', 'require \'rdoc/task\' (in RDoc 2.4.2+)', caller.first)
-end
-
-require 'rubygems'
-
-begin
-  gem 'rdoc'
-  require 'rdoc'
-  require 'rdoc/task'
-rescue LoadError, Gem::LoadError
-end
-
-# :stopdoc:
-
-if defined?(RDoc::Task) then
-  module Rake
-    RDocTask = RDoc::Task unless const_defined? :RDocTask
-  end
-else
-  require 'rake'
-  require 'rake/tasklib'
-
-  module Rake
-
-    # NOTE: Rake::RDocTask is deprecated in favor of RDoc:Task which is included
-    # in RDoc 2.4.2+.  Use require 'rdoc/task' to require it.
-    #
-    # 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
-    #
-    # The +rd+ object passed to the block is an RDocTask object. See the
-    # attributes list for the RDocTask class for available customization options.
-    #
-    # == Specifying different task names
-    #
-    # 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>.
-    #
-    # If you wish to have completely different task names, then pass a Hash as
-    # first argument. With the <tt>:rdoc</tt>, <tt>:clobber_rdoc</tt> and
-    # <tt>:rerdoc</tt> options, you can customize the task names to your liking.
-    # For example:
-    #
-    #   Rake::RDocTask.new(:rdoc => "rdoc", :clobber_rdoc => "rdoc:clean", :rerdoc => "rdoc:force")
-    #
-    # This will create the tasks <tt>:rdoc</tt>, <tt>:rdoc_clean</tt> and
-    # <tt>:rdoc:force</tt>.
-    #
-    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. (defaults to rdoc's default)
-      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. (defaults to rdoc's default)
-      attr_accessor :template
-
-      # List of files to be included in the rdoc generation. (default is [])
-      attr_accessor :rdoc_files
-
-      # Additional list of options to be passed rdoc.  (default is [])
-      attr_accessor :options
-
-      # Whether to run the rdoc process as an external shell (default is false)
-      attr_accessor :external
-
-      attr_accessor :inline_source
-
-      # Create an RDoc task with the given name. See the RDocTask class overview
-      # for documentation.
-      def initialize(name = :rdoc)  # :yield: self
-        if name.is_a?(Hash)
-          invalid_options = name.keys.map { |k| k.to_sym } - [:rdoc, :clobber_rdoc, :rerdoc]
-          if !invalid_options.empty?
-            raise ArgumentError, "Invalid option(s) passed to RDocTask.new: #{invalid_options.join(", ")}"
-          end
-        end
-
-        @name = name
-        @rdoc_files = Rake::FileList.new
-        @rdoc_dir = 'html'
-        @main = nil
-        @title = nil
-        @template = nil
-        @external = false
-        @inline_source = true
-        @options = []
-        yield self if block_given?
-        define
-      end
-
-      # Create the tasks defined by this task lib.
-      def define
-        if rdoc_task_name != "rdoc"
-          desc "Build the RDOC HTML Files"
-        else
-          desc "Build the #{rdoc_task_name} HTML Files"
-        end
-        task rdoc_task_name
-
-        desc "Force a rebuild of the RDOC files"
-        task rerdoc_task_name => [clobber_task_name, rdoc_task_name]
-
-        desc "Remove rdoc products"
-        task clobber_task_name do
-          rm_r rdoc_dir rescue nil
-        end
-
-        task :clobber => [clobber_task_name]
-
-        directory @rdoc_dir
-        task rdoc_task_name => [rdoc_target]
-        file rdoc_target => @rdoc_files + [Rake.application.rakefile] do
-          rm_r @rdoc_dir rescue nil
-          @before_running_rdoc.call if @before_running_rdoc
-          args = option_list + @rdoc_files
-          if @external
-            argstring = args.join(' ')
-            sh %{ruby -Ivendor vendor/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 << "--inline-source" if inline_source && !@options.include?("--inline-source") && !@options.include?("-S")
-        result
-      end
-
-      def quote(str)
-        if @external
-          "'#{str}'"
-        else
-          str
-        end
-      end
-
-      def option_string
-        option_list.join(' ')
-      end
-
-      # The block passed to this method will be called just before running the
-      # RDoc generator. It is allowed to modify RDocTask attributes inside the
-      # block.
-      def before_running_rdoc(&block)
-        @before_running_rdoc = block
-      end
-
-      private
-
-      def rdoc_target
-        "#{rdoc_dir}/index.html"
-      end
-
-      def rdoc_task_name
-        case name
-        when Hash
-          (name[:rdoc] || "rdoc").to_s
-        else
-          name.to_s
-        end
-      end
-
-      def clobber_task_name
-        case name
-        when Hash
-          (name[:clobber_rdoc] || "clobber_rdoc").to_s
-        else
-          "clobber_#{name}"
-        end
-      end
-
-      def rerdoc_task_name
-        case name
-        when Hash
-          (name[:rerdoc] || "rerdoc").to_s
-        else
-          "re#{name}"
-        end
-      end
-
-    end
-  end
-end
-

data/lib/rake/trace_output.rb

@@ -1,19 +0,0 @@
-module Rake
-  module TraceOutput
-
-    # Write trace output to output stream +out+.
-    #
-    # The write is done as a single IO call (to print) to lessen the
-    # chance that the trace output is interrupted by other tasks also
-    # producing output.
-    def trace_on(out, *strings)
-      sep = $\ || "\n"
-      if strings.empty?
-        output = sep
-      else
-        output = strings.map { |s| s.end_with?(sep) ? s : s + sep }.join
-      end
-      out.print(output)
-    end
-  end
-end

data/test/test_private_reader.rb

@@ -1,42 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'rake/private_reader'
-
-class TestPrivateAttrs < Rake::TestCase
-
-  class Sample
-    include Rake::PrivateReader
-
-    private_reader :reader, :a
-
-    def initialize
-      @reader = :RVALUE
-    end
-
-    def get_reader
-      reader
-    end
-
-  end
-
-  def setup
-    super
-    @sample = Sample.new
-  end
-
-  def test_private_reader_is_private
-    assert_private do @sample.reader end
-    assert_private do @sample.a end
-  end
-
-  def test_private_reader_returns_data
-    assert_equal :RVALUE, @sample.get_reader
-  end
-
-  private
-
-  def assert_private
-    ex = assert_raises(NoMethodError) do yield end
-    assert_match(/private/, ex.message)
-  end
-
-end

data/test/test_rake_rdoc_task.rb

@@ -1,83 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-begin
-  old_stderr = $stderr
-  dev_null = File.exist?('/dev/null') ? '/dev/null' : 'NUL'
-  $stderr = open dev_null, 'w'
-  require 'rake/rdoctask'
-ensure
-  $stderr.close
-  $stderr = old_stderr
-end
-
-class TestRakeRDocTask < Rake::TestCase
-  include Rake
-
-  def setup
-    super
-
-    Task.clear
-  end
-
-  def test_tasks_creation
-    Rake::RDocTask.new
-    assert Task[:rdoc]
-    assert Task[:clobber_rdoc]
-    assert Task[:rerdoc]
-  end
-
-  def test_tasks_creation_with_custom_name_symbol
-    rd = Rake::RDocTask.new(:rdoc_dev)
-    assert Task[:rdoc_dev]
-    assert Task[:clobber_rdoc_dev]
-    assert Task[:rerdoc_dev]
-    assert_equal :rdoc_dev, rd.name
-  end
-
-  def test_tasks_creation_with_custom_name_string
-    rd = Rake::RDocTask.new("rdoc_dev")
-    assert Task[:rdoc_dev]
-    assert Task[:clobber_rdoc_dev]
-    assert Task[:rerdoc_dev]
-    assert_equal "rdoc_dev", rd.name
-  end
-
-  def test_tasks_creation_with_custom_name_hash
-    options = { :rdoc => "rdoc", :clobber_rdoc => "rdoc:clean", :rerdoc => "rdoc:force" }
-    rd = Rake::RDocTask.new(options)
-    assert Task[:"rdoc"]
-    assert Task[:"rdoc:clean"]
-    assert Task[:"rdoc:force"]
-    assert_raises(RuntimeError) { Task[:clobber_rdoc] }
-    assert_equal options, rd.name
-  end
-
-  def test_tasks_creation_with_custom_name_hash_will_use_default_if_an_option_isnt_given
-    Rake::RDocTask.new(:clobber_rdoc => "rdoc:clean")
-    assert Task[:rdoc]
-    assert Task[:"rdoc:clean"]
-    assert Task[:rerdoc]
-  end
-
-  def test_tasks_creation_with_custom_name_hash_raises_exception_if_invalid_option_given
-    assert_raises(ArgumentError) do
-      Rake::RDocTask.new(:foo => "bar")
-    end
-
-    begin
-      Rake::RDocTask.new(:foo => "bar")
-    rescue ArgumentError => e
-      assert_match(/foo/, e.message)
-    end
-  end
-
-  def test_inline_source_option_is_only_appended_if_option_not_already_given
-    rd = Rake::RDocTask.new
-    rd.options << '--inline-source'
-    assert_equal 1, rd.option_list.grep('--inline-source').size
-
-    rd = Rake::RDocTask.new
-    rd.options << '-S'
-    assert_equal 1, rd.option_list.grep('-S').size
-    assert_equal 0, rd.option_list.grep('--inline-source').size
-  end
-end