remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/rake-10.0.3/lib/rake/file_utils.rb

@@ -0,0 +1,114 @@
+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 = ENV['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) # :nodoc:
+    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) # :nodoc:
+    unless options.key? :verbose
+      options[:verbose] =
+        Rake::FileUtilsExt.verbose_flag == Rake::FileUtilsExt::DEFAULT ||
+        Rake::FileUtilsExt.verbose_flag
+    end
+  end
+  private :set_verbose_option
+
+  def rake_system(*cmd) # :nodoc:
+    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/vendor/bundle/gems/rake-10.0.3/lib/rake/file_utils_ext.rb

@@ -0,0 +1,146 @@
+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
+
+    DEFAULT = Object.new
+
+    FileUtilsExt.verbose_flag = DEFAULT
+    FileUtilsExt.nowrite_flag = false
+
+    $fileutils_verbose = true
+    $fileutils_nowrite = false
+
+    FileUtils.commands.each do |name|
+      opts = FileUtils.options_of name
+      default_options = []
+      if opts.include?("verbose")
+        default_options << ':verbose => FileUtilsExt.verbose_flag'
+      end
+      if 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/vendor/bundle/gems/rake-10.0.3/lib/rake/gempackagetask.rb

@@ -0,0 +1 @@
+fail "ERROR: 'rake/gempackagetask' is obsolete and no longer supported. Use 'rubygems/package_task' instead."

data/vendor/bundle/gems/rake-10.0.3/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

data/vendor/bundle/gems/rake-10.0.3/lib/rake/invocation_exception_mixin.rb

@@ -0,0 +1,16 @@
+module Rake
+  module InvocationExceptionMixin
+    # Return the invocation chain (list of Rake tasks) that were in
+    # effect when this exception was detected by rake.  May be null if
+    # no tasks were active.
+    def chain
+      @rake_invocation_chain ||= nil
+    end
+
+    # Set the invocation chain in effect when this exception was
+    # detected.
+    def chain=(value)
+      @rake_invocation_chain = value
+    end
+  end
+end

data/vendor/bundle/gems/rake-10.0.3/lib/rake/loaders/makefile.rb

@@ -0,0 +1,40 @@
+module Rake
+
+  # Makefile loader to be used with the import file loader.
+  class MakefileLoader
+    include Rake::DSL
+
+    SPACE_MARK = "\0"
+
+    # Load the makefile dependencies in +fn+.
+    def load(fn)
+      lines = File.read fn
+      lines.gsub!(/\\ /, SPACE_MARK)
+      lines.gsub!(/#[^\n]*\n/m, "")
+      lines.gsub!(/\\\n/, ' ')
+      lines.each_line do |line|
+        process_line(line)
+      end
+    end
+
+    private
+
+    # Process one logical line of makefile data.
+    def process_line(line)
+      file_tasks, args = line.split(':', 2)
+      return if args.nil?
+      dependents = args.split.map { |d| respace(d) }
+      file_tasks.scan(/\S+/) do |file_task|
+        file_task = respace(file_task)
+        file file_task => dependents
+      end
+    end
+
+    def respace(str)
+      str.tr SPACE_MARK, ' '
+    end
+  end
+
+  # Install the handler
+  Rake.application.add_loader('mf', MakefileLoader.new)
+end

data/vendor/bundle/gems/rake-10.0.3/lib/rake/multi_task.rb

@@ -0,0 +1,13 @@
+module Rake
+
+  # Same as a regular task, but the immediate prerequisites are done in
+  # parallel using Ruby threads.
+  #
+  class MultiTask < Task
+    private
+    def invoke_prerequisites(task_args, invocation_chain) # :nodoc:
+      invoke_prerequisites_concurrently(task_args, invocation_chain)
+    end
+  end
+
+end

data/vendor/bundle/gems/rake-10.0.3/lib/rake/name_space.rb

@@ -0,0 +1,25 @@
+module Rake
+
+  # The NameSpace class will lookup task names in the the scope
+  # defined by a +namespace+ command.
+  #
+  class NameSpace
+
+    # Create a namespace lookup object using the given task manager
+    # and the list of scopes.
+    def initialize(task_manager, scope_list)
+      @task_manager = task_manager
+      @scope = scope_list.dup
+    end
+
+    # Lookup a task named +name+ in the namespace.
+    def [](name)
+      @task_manager.lookup(name, @scope)
+    end
+
+    # Return the list of tasks defined in this and nested namespaces.
+    def tasks
+      @task_manager.tasks_in_scope(@scope)
+    end
+  end
+end

data/vendor/bundle/gems/rake-10.0.3/lib/rake/packagetask.rb

@@ -0,0 +1,185 @@
+# Define a package task library 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.  Use +:noversion+
+    # as the version to build a package without a version or to provide a
+    # fully-versioned package name.
+
+    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/vendor/bundle/gems/rake-10.0.3/lib/rake/pathmap.rb

@@ -0,0 +1 @@
+require 'rake/ext/string'

data/vendor/bundle/gems/rake-10.0.3/lib/rake/phony.rb

@@ -0,0 +1,15 @@
+# Defines a :phony task that you can use as a dependency. This allows
+# file-based tasks to use non-file-based tasks as prerequisites
+# without forcing them to rebuild.
+#
+# See FileTask#out_of_date? and Task#timestamp for more info.
+
+require 'rake'
+
+task :phony
+
+Rake::Task[:phony].tap do |task|
+  def task.timestamp # :nodoc:
+    Time.at 0
+  end
+end

data/vendor/bundle/gems/rake-10.0.3/lib/rake/private_reader.rb

@@ -0,0 +1,20 @@
+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