gemrage 0.3.2 → 0.4.0

data/vendor/ruby/1.8/gems/rake-0.8.7/lib/rake/rdoctask.rb

@@ -0,0 +1,209 @@
+#!/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
+  #
+  # 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

data/vendor/ruby/1.8/gems/rake-0.8.7/lib/rake/ruby182_test_unit_fix.rb

@@ -0,0 +1,23 @@
+module Test
+  module Unit
+    module Collector
+      class Dir
+        undef collect_file
+        def collect_file(name, suites, already_gathered)
+          # loadpath = $:.dup
+          dir = File.dirname(File.expand_path(name))
+          $:.unshift(dir) unless $:.first == dir
+          if(@req)
+            @req.require(name)
+          else
+            require(name)
+          end
+          find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
+        ensure
+          # $:.replace(loadpath)
+          $:.delete_at $:.rindex(dir)
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rake-0.8.7/lib/rake/runtest.rb

@@ -0,0 +1,23 @@
+#!/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/vendor/ruby/1.8/gems/rake-0.8.7/lib/rake/tasklib.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+
+module Rake
+
+  # Base class for Task Libraries.
+  class TaskLib
+    include Cloneable
+
+    # Make a symbol by pasting two strings together.
+    #
+    # NOTE: DEPRECATED! This method is kinda stupid. I don't know why
+    # I didn't just use string interpolation. But now other task
+    # libraries depend on this so I can't remove it without breaking
+    # other people's code. So for now it stays for backwards
+    # compatibility. BUT DON'T USE IT.
+    def paste(a,b)              # :nodoc:
+      (a.to_s + b.to_s).intern
+    end
+  end
+
+end

data/vendor/ruby/1.8/gems/rake-0.8.7/lib/rake/testtask.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+
+# Define a task library for running unit tests.
+
+require 'rake'
+require 'rake/tasklib'
+
+module Rake
+
+  # Create a task that runs a set of tests.
+  #
+  # Example:
+  #  
+  #   Rake::TestTask.new do |t|
+  #     t.libs << "test"
+  #     t.test_files = FileList['test/test*.rb']
+  #     t.verbose = true
+  #   end
+  #
+  # If rake is invoked with a "TEST=filename" command line option,
+  # then the list of test files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one test.
+  #
+  # If rake is invoked with a "TESTOPTS=options" command line option,
+  # then the given options are passed to the test process after a
+  # '--'.  This allows Test::Unit options to be passed to the test
+  # suite.
+  #
+  # Examples:
+  #
+  #   rake test                           # run tests normally
+  #   rake test TEST=just_one_file.rb     # run just one test file.
+  #   rake test TESTOPTS="-v"             # run in verbose mode
+  #   rake test TESTOPTS="--runner=fox"   # use the fox test runner
+  #
+  class TestTask < TaskLib
+
+    # Name of test task. (default is :test)
+    attr_accessor :name
+
+    # List of directories to added to $LOAD_PATH before running the
+    # tests. (default is 'lib')
+    attr_accessor :libs
+
+    # True if verbose test output desired. (default is false)
+    attr_accessor :verbose
+
+    # Test options passed to the test suite.  An explicit
+    # TESTOPTS=opts on the command line will override this. (default
+    # is NONE)
+    attr_accessor :options
+
+    # Request that the tests be run with the warning flag set.
+    # E.g. warning=true implies "ruby -w" used to run the tests.
+    attr_accessor :warning
+
+    # Glob pattern to match test files. (default is 'test/test*.rb')
+    attr_accessor :pattern
+
+    # Style of test loader to use.  Options are:
+    #
+    # * :rake -- Rake provided test loading script (default).
+    # * :testrb -- Ruby provided test loading script.
+    # * :direct -- Load tests using command line loader.
+    # 
+    attr_accessor :loader
+
+    # Array of commandline options to pass to ruby when running test loader.
+    attr_accessor :ruby_opts
+
+    # Explicitly define the list of test files to be included in a
+    # test.  +list+ is expected to be an array of file names (a
+    # FileList is acceptable).  If both +pattern+ and +test_files+ are
+    # used, then the list of test files is the union of the two.
+    def test_files=(list)
+      @test_files = list
+    end
+
+    # Create a testing task.
+    def initialize(name=:test)
+      @name = name
+      @libs = ["lib"]
+      @pattern = nil
+      @options = nil
+      @test_files = nil
+      @verbose = false
+      @warning = false
+      @loader = :rake
+      @ruby_opts = []
+      yield self if block_given?
+      @pattern = 'test/test*.rb' if @pattern.nil? && @test_files.nil?
+      define
+    end
+
+    # Create the tasks defined by this task lib.
+    def define
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      desc "Run tests" + (@name==:test ? "" : " for #{@name}")
+      task @name do
+        run_code = ''
+        RakeFileUtils.verbose(@verbose) do
+          run_code =
+            case @loader
+            when :direct
+              "-e 'ARGV.each{|f| load f}'"
+            when :testrb
+              "-S testrb #{fix}"
+            when :rake
+              rake_loader
+            end
+          @ruby_opts.unshift( "-I\"#{lib_path}\"" )
+          @ruby_opts.unshift( "-w" ) if @warning
+          ruby @ruby_opts.join(" ") +
+            " \"#{run_code}\" " +
+            file_list.collect { |fn| "\"#{fn}\"" }.join(' ') +
+            " #{option_list}"
+        end
+      end
+      self
+    end
+
+    def option_list # :nodoc:
+      ENV['TESTOPTS'] || @options || ""
+    end
+
+    def file_list # :nodoc:
+      if ENV['TEST']
+        FileList[ ENV['TEST'] ]
+      else
+        result = []
+        result += @test_files.to_a if @test_files
+        result += FileList[ @pattern ].to_a if @pattern
+        FileList[result]
+      end
+    end
+
+    def fix # :nodoc:
+      case RUBY_VERSION
+      when '1.8.2'
+        find_file 'rake/ruby182_test_unit_fix'
+      else
+        nil
+      end || ''
+    end
+
+    def rake_loader # :nodoc:
+      find_file('rake/rake_test_loader') or
+        fail "unable to find rake test loader"
+    end
+
+    def find_file(fn) # :nodoc:
+      $LOAD_PATH.each do |path|
+        file_path = File.join(path, "#{fn}.rb")
+        return file_path if File.exist? file_path
+      end
+      nil
+    end
+
+  end
+end

data/vendor/ruby/1.8/gems/rake-0.8.7/lib/rake/win32.rb

@@ -0,0 +1,55 @@
+
+module Rake
+  require 'rake/alt_system'
+
+  # Win 32 interface methods for Rake. Windows specific functionality
+  # will be placed here to collect that knowledge in one spot.
+  module Win32
+    
+    # Error indicating a problem in locating the home directory on a
+    # Win32 system.
+    class Win32HomeError < RuntimeError
+    end
+    
+    class << self
+      # True if running on a windows system.
+      def windows?
+        AltSystem::WINDOWS
+      end
+
+      # Run a command line on windows.
+      def rake_system(*cmd)
+        AltSystem.system(*cmd)
+      end
+      
+      # The standard directory containing system wide rake files on
+      # Win 32 systems. Try the following environment variables (in
+      # order):
+      #
+      # * HOME
+      # * HOMEDRIVE + HOMEPATH
+      # * APPDATA
+      # * USERPROFILE
+      #
+      # If the above are not defined, the return nil.
+      def win32_system_dir #:nodoc:
+        win32_shared_path = ENV['HOME']
+        if win32_shared_path.nil? && ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+          win32_shared_path = ENV['HOMEDRIVE'] + ENV['HOMEPATH']
+        end
+
+        win32_shared_path ||= ENV['APPDATA']
+        win32_shared_path ||= ENV['USERPROFILE']
+        raise Win32HomeError, "Unable to determine home path environment variable." if
+          win32_shared_path.nil? or win32_shared_path.empty?
+        normalize(File.join(win32_shared_path, 'Rake'))
+      end
+
+      # Normalize a win32 path so that the slashes are all forward slashes.
+      def normalize(path)
+        path.gsub(/\\/, '/')
+      end
+      
+    end
+  end
+end