torquebox-console 0.2.3 → 0.2.4

data/vendor/bundle/ruby/1.8/gems/rake-10.0.3/lib/rake/thread_history_display.rb

@@ -0,0 +1,48 @@
+require 'rake/private_reader'
+
+module Rake
+
+  class ThreadHistoryDisplay    # :nodoc: all
+    include Rake::PrivateReader
+
+    private_reader :stats, :items, :threads
+
+    def initialize(stats)
+      @stats   = stats
+      @items   = { :_seq_ =>  1  }
+      @threads = { :_seq_ => "A" }
+    end
+
+    def show
+      puts "Job History:"
+      stats.each do |stat|
+        stat[:data] ||= {}
+        rename(stat, :thread, threads)
+        rename(stat[:data], :item_id, items)
+        rename(stat[:data], :new_thread, threads)
+        rename(stat[:data], :deleted_thread, threads)
+        printf("%8d %2s %-20s %s\n",
+          (stat[:time] * 1_000_000).round,
+          stat[:thread],
+          stat[:event],
+          stat[:data].map { |k,v| "#{k}:#{v}" }.join(" "))
+      end
+    end
+
+    private
+
+    def rename(hash, key, renames)
+      if hash && hash[key]
+        original = hash[key]
+        value = renames[original]
+        unless value
+          value = renames[:_seq_]
+          renames[:_seq_] = renames[:_seq_].succ
+          renames[original] = value
+        end
+        hash[key] = value
+      end
+    end
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/rake-10.0.3/lib/rake/thread_pool.rb

@@ -0,0 +1,155 @@
+require 'thread'
+require 'set'
+
+require 'rake/promise'
+
+module Rake
+
+  class ThreadPool              # :nodoc: all
+
+    # Creates a ThreadPool object.
+    # The parameter is the size of the pool.
+    def initialize(thread_count)
+      @max_active_threads = [thread_count, 0].max
+      @threads = Set.new
+      @threads_mon = Monitor.new
+      @queue = Queue.new
+      @join_cond = @threads_mon.new_cond
+
+      @history_start_time = nil
+      @history = []
+      @history_mon = Monitor.new
+      @total_threads_in_play = 0
+    end
+
+    # Creates a future executed by the +ThreadPool+.
+    #
+    # The args are passed to the block when executing (similarly to
+    # <tt>Thread#new</tt>) The return value is an object representing
+    # a future which has been created and added to the queue in the
+    # pool. Sending <tt>#value</tt> to the object will sleep the
+    # current thread until the future is finished and will return the
+    # result (or raise an exception thrown from the future)
+    def future(*args, &block)
+      promise = Promise.new(args, &block)
+      promise.recorder = lambda { |*stats| stat(*stats) }
+
+      @queue.enq promise
+      stat :queued, :item_id => promise.object_id
+      start_thread
+      promise
+    end
+
+    # Waits until the queue of futures is empty and all threads have exited.
+    def join
+      @threads_mon.synchronize do
+        begin
+          stat :joining
+          @join_cond.wait unless @threads.empty?
+          stat :joined
+        rescue Exception => e
+          stat :joined
+          $stderr.puts e
+          $stderr.print "Queue contains #{@queue.size} items. Thread pool contains #{@threads.count} threads\n"
+          $stderr.print "Current Thread #{Thread.current} status = #{Thread.current.status}\n"
+          $stderr.puts e.backtrace.join("\n")
+          @threads.each do |t|
+            $stderr.print "Thread #{t} status = #{t.status}\n"
+            # 1.8 doesn't support Thread#backtrace
+            $stderr.puts t.backtrace.join("\n") if t.respond_to? :backtrace
+          end
+          raise e
+        end
+      end
+    end
+
+    # Enable the gathering of history events.
+    def gather_history          #:nodoc:
+      @history_start_time = Time.now if @history_start_time.nil?
+    end
+
+    # Return a array of history events for the thread pool.
+    #
+    # History gathering must be enabled to be able to see the events
+    # (see #gather_history). Best to call this when the job is
+    # complete (i.e. after ThreadPool#join is called).
+    def history                 # :nodoc:
+      @history_mon.synchronize { @history.dup }.
+        sort_by { |i| i[:time] }.
+        each { |i| i[:time] -= @history_start_time }
+    end
+
+    # Return a hash of always collected statistics for the thread pool.
+    def statistics              #  :nodoc:
+      {
+        :total_threads_in_play => @total_threads_in_play,
+        :max_active_threads => @max_active_threads,
+      }
+    end
+
+    private
+
+    # processes one item on the queue. Returns true if there was an
+    # item to process, false if there was no item
+    def process_queue_item      #:nodoc:
+      return false if @queue.empty?
+
+      # Even though we just asked if the queue was empty, it
+      # still could have had an item which by this statement
+      # is now gone. For this reason we pass true to Queue#deq
+      # because we will sleep indefinitely if it is empty.
+      promise = @queue.deq(true)
+      stat :dequeued, :item_id => promise.object_id
+      promise.work
+      return true
+
+      rescue ThreadError # this means the queue is empty
+      false
+    end
+
+    def start_thread # :nodoc:
+      @threads_mon.synchronize do
+        next unless @threads.count < @max_active_threads
+
+        t = Thread.new do
+          begin
+            while @threads.count <= @max_active_threads
+              break unless process_queue_item
+            end
+          ensure
+            @threads_mon.synchronize do
+              @threads.delete Thread.current
+              stat :ended, :thread_count => @threads.count
+              @join_cond.broadcast if @threads.empty?
+            end
+          end
+        end
+        @threads << t
+        stat :spawned, :new_thread => t.object_id, :thread_count => @threads.count
+        @total_threads_in_play = @threads.count if @threads.count > @total_threads_in_play
+      end
+    end
+
+    def stat(event, data=nil) # :nodoc:
+      return if @history_start_time.nil?
+      info = {
+        :event  => event,
+        :data   => data,
+        :time   => Time.now,
+        :thread => Thread.current.object_id,
+      }
+      @history_mon.synchronize { @history << info }
+    end
+
+    # for testing only
+
+    def __queue__ # :nodoc:
+      @queue
+    end
+
+    def __threads__ # :nodoc:
+      @threads.dup
+    end
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/rake-10.0.3/lib/rake/trace_output.rb

@@ -0,0 +1,19 @@
+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/vendor/bundle/ruby/1.8/gems/rake-10.0.3/lib/rake/version.rb

@@ -0,0 +1,13 @@
+module Rake
+  VERSION = '10.0.3'
+
+  module Version # :nodoc: all
+    MAJOR, MINOR, BUILD, = Rake::VERSION.split '.'
+
+    NUMBERS = [
+      MAJOR,
+      MINOR,
+      BUILD,
+    ]
+  end
+end

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

data/vendor/bundle/ruby/1.8/gems/rake-10.0.3/test/file_creation.rb

@@ -0,0 +1,34 @@
+module FileCreation
+  OLDFILE = "old"
+  NEWFILE = "new"
+
+  def create_timed_files(oldfile, *newfiles)
+    return if (File.exist?(oldfile) &&
+      newfiles.all? { |newfile|
+        File.exist?(newfile) && File.stat(newfile).mtime > File.stat(oldfile).mtime
+      })
+    now = Time.now
+
+    create_file(oldfile, now - 60)
+
+    newfiles.each do |newfile|
+      create_file(newfile, now)
+    end
+  end
+
+  def create_dir(dirname)
+    FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
+    File.stat(dirname).mtime
+  end
+
+  def create_file(name, file_time=nil)
+    create_dir(File.dirname(name))
+    FileUtils.touch(name) unless File.exist?(name)
+    File.utime(file_time, file_time, name) unless file_time.nil?
+    File.stat(name).mtime
+  end
+
+  def delete_file(name)
+    File.delete(name) rescue nil
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rake-10.0.3/test/helper.rb

@@ -0,0 +1,562 @@
+require 'rubygems'
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+begin
+  gem 'minitest'
+rescue Gem::LoadError
+end
+
+require 'minitest/autorun'
+require 'rake'
+require 'tmpdir'
+require File.expand_path('../file_creation', __FILE__)
+
+begin
+  require_relative '../ruby/envutil'
+rescue NoMethodError, LoadError
+  # for ruby trunk
+end
+
+class Rake::TestCase < MiniTest::Unit::TestCase
+  include FileCreation
+
+  include Rake::DSL
+
+  class TaskManager
+    include Rake::TaskManager
+  end
+
+  RUBY = defined?(EnvUtil) ? EnvUtil.rubybin : Gem.ruby
+
+  def setup
+    ARGV.clear
+
+    test_dir = File.basename File.dirname File.expand_path __FILE__
+
+    @rake_root = if test_dir == 'test' then
+                   # rake repository
+                   File.expand_path '../../', __FILE__
+                 else
+                   # ruby repository
+                   File.expand_path '../../../', __FILE__
+                 end
+
+    @rake_exec = File.join @rake_root, 'bin', 'rake'
+    @rake_lib  = File.join @rake_root, 'lib'
+
+    @orig_PWD = Dir.pwd
+    @orig_APPDATA      = ENV['APPDATA']
+    @orig_HOME         = ENV['HOME']
+    @orig_HOMEDRIVE    = ENV['HOMEDRIVE']
+    @orig_HOMEPATH     = ENV['HOMEPATH']
+    @orig_RAKE_COLUMNS = ENV['RAKE_COLUMNS']
+    @orig_RAKE_SYSTEM  = ENV['RAKE_SYSTEM']
+    @orig_RAKEOPT      = ENV['RAKEOPT']
+    @orig_USERPROFILE  = ENV['USERPROFILE']
+    ENV.delete 'RAKE_COLUMNS'
+    ENV.delete 'RAKE_SYSTEM'
+    ENV.delete 'RAKEOPT'
+
+    tmpdir = Dir.chdir Dir.tmpdir do Dir.pwd end
+    @tempdir = File.join tmpdir, "test_rake_#{$$}"
+
+    FileUtils.mkdir_p @tempdir
+
+    Dir.chdir @tempdir
+
+    Rake.application = Rake::Application.new
+    Rake::TaskManager.record_task_metadata = true
+    RakeFileUtils.verbose_flag = false
+  end
+
+  def teardown
+    Dir.chdir @orig_PWD
+    FileUtils.rm_rf @tempdir
+
+    if @orig_APPDATA then
+      ENV['APPDATA'] = @orig_APPDATA
+    else
+      ENV.delete 'APPDATA'
+    end
+
+    ENV['HOME']         = @orig_HOME
+    ENV['HOMEDRIVE']    = @orig_HOMEDRIVE
+    ENV['HOMEPATH']     = @orig_HOMEPATH
+    ENV['RAKE_COLUMNS'] = @orig_RAKE_COLUMNS
+    ENV['RAKE_SYSTEM']  = @orig_RAKE_SYSTEM
+    ENV['RAKEOPT']      = @orig_RAKEOPT
+    ENV['USERPROFILE']  = @orig_USERPROFILE
+  end
+
+  def ignore_deprecations
+    Rake.application.options.ignore_deprecate = true
+    yield
+  ensure
+    Rake.application.options.ignore_deprecate = false
+  end
+
+  def rake_system_dir
+    @system_dir = 'system'
+
+    FileUtils.mkdir_p @system_dir
+
+    open File.join(@system_dir, 'sys1.rake'), 'w' do |io|
+      io << <<-SYS
+task "sys1" do
+  puts "SYS1"
+end
+      SYS
+    end
+
+    ENV['RAKE_SYSTEM'] = @system_dir
+  end
+
+  def rakefile contents
+    open 'Rakefile', 'w' do |io|
+      io << contents
+    end
+  end
+
+  def rakefile_access
+    rakefile <<-ACCESS
+TOP_LEVEL_CONSTANT = 0
+
+def a_top_level_function
+end
+
+task :default => [:work, :obj, :const]
+
+task :work do
+  begin
+    a_top_level_function
+    puts "GOOD:M Top level methods can be called in tasks"
+  rescue NameError => ex
+    puts "BAD:M  Top level methods can not be called in tasks"
+  end
+end
+
+# TODO: remove `disabled_' when DeprecatedObjectDSL removed
+task :obj
+task :disabled_obj do
+  begin
+    Object.new.instance_eval { task :xyzzy }
+    puts "BAD:D  Rake DSL are polluting objects"
+  rescue StandardError => ex
+    puts "GOOD:D Rake DSL are not polluting objects"
+  end
+end
+
+task :const do
+  begin
+    TOP_LEVEL_CONSTANT
+    puts "GOOD:C Top level constants are available in tasks"
+  rescue StandardError => ex
+    puts "BAD:C  Top level constants are NOT available in tasks"
+  end
+end
+    ACCESS
+  end
+
+  def rakefile_chains
+    rakefile <<-DEFAULT
+task :default => "play.app"
+
+file "play.scpt" => "base" do |t|
+  cp t.prerequisites.first, t.name
+end
+
+rule ".app" => ".scpt" do |t|
+  cp t.source, t.name
+end
+
+file 'base' do
+  touch 'base'
+end
+    DEFAULT
+  end
+
+  def rakefile_comments
+    rakefile <<-COMMENTS
+# comment for t1
+task :t1 do
+end
+
+# no comment or task because there's a blank line
+
+task :t2 do
+end
+
+desc "override comment for t3"
+# this is not the description
+multitask :t3 do
+end
+
+# this is not the description
+desc "override comment for t4"
+file :t4 do
+end
+    COMMENTS
+  end
+
+  def rakefile_default
+    rakefile <<-DEFAULT
+if ENV['TESTTOPSCOPE']
+  puts "TOPSCOPE"
+end
+
+task :default do
+  puts "DEFAULT"
+end
+
+task :other => [:default] do
+  puts "OTHER"
+end
+
+task :task_scope do
+  if ENV['TESTTASKSCOPE']
+    puts "TASKSCOPE"
+  end
+end
+    DEFAULT
+  end
+
+  def rakefile_dryrun
+    rakefile <<-DRYRUN
+task :default => ["temp_main"]
+
+file "temp_main" => [:all_apps]  do touch "temp_main" end
+
+task :all_apps => [:one, :two]
+task :one => ["temp_one"]
+task :two => ["temp_two"]
+
+file "temp_one" do |t|
+  touch "temp_one"
+end
+file "temp_two" do |t|
+  touch "temp_two"
+end
+
+task :clean do
+  ["temp_one", "temp_two", "temp_main"].each do |file|
+    rm_f file
+  end
+end
+    DRYRUN
+
+    FileUtils.touch 'temp_main'
+    FileUtils.touch 'temp_two'
+  end
+
+  def rakefile_extra
+    rakefile 'task :default'
+
+    FileUtils.mkdir_p 'rakelib'
+
+    open File.join('rakelib', 'extra.rake'), 'w' do |io|
+      io << <<-EXTRA_RAKE
+# Added for testing
+
+namespace :extra do
+  desc "An Extra Task"
+  task :extra do
+    puts "Read all about it"
+  end
+end
+      EXTRA_RAKE
+    end
+  end
+
+  def rakefile_file_creation
+    rakefile <<-'FILE_CREATION'
+N = 2
+
+task :default => :run
+
+BUILD_DIR = 'build'
+task :clean do
+  rm_rf 'build'
+  rm_rf 'src'
+end
+
+task :run
+
+TARGET_DIR = 'build/copies'
+
+FileList['src/*'].each do |src|
+  directory TARGET_DIR
+  target = File.join TARGET_DIR, File.basename(src)
+  file target => [src, TARGET_DIR] do
+    cp src, target
+    # sleep 3 if src !~ /foo#{N-1}$/   # I'm commenting out this sleep, it doesn't seem to do anything.
+  end
+  task :run => target
+end
+
+task :prep => :clean do
+  mkdir_p 'src'
+  N.times do |n|
+    touch "src/foo#{n}"
+  end
+end
+    FILE_CREATION
+  end
+
+  def rakefile_imports
+    rakefile <<-IMPORTS
+require 'rake/loaders/makefile'
+
+task :default
+
+task :other do
+  puts "OTHER"
+end
+
+file "dynamic_deps" do |t|
+  open(t.name, "w") do |f| f.puts "puts 'DYNAMIC'" end
+end
+
+import "dynamic_deps"
+import "static_deps"
+import "static_deps"
+import "deps.mf"
+puts "FIRST"
+    IMPORTS
+
+    open 'deps.mf', 'w' do |io|
+      io << <<-DEPS
+default: other
+      DEPS
+    end
+
+    open "static_deps", "w" do |f|
+      f.puts 'puts "STATIC"'
+    end
+  end
+
+  def rakefile_multidesc
+    rakefile <<-MULTIDESC
+task :b
+
+desc "A"
+task :a
+
+desc "B"
+task :b
+
+desc "A2"
+task :a
+
+task :c
+
+desc "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+task :d
+    MULTIDESC
+  end
+
+  def rakefile_namespace
+    rakefile <<-NAMESPACE
+desc "copy"
+task :copy do
+  puts "COPY"
+end
+
+namespace "nest" do
+  desc "nest copy"
+  task :copy do
+    puts "NEST COPY"
+  end
+  task :xx => :copy
+end
+
+anon_ns = namespace do
+  desc "anonymous copy task"
+  task :copy do
+    puts "ANON COPY"
+  end
+end
+
+desc "Top level task to run the anonymous version of copy"
+task :anon => anon_ns[:copy]
+
+namespace "very" do
+  namespace "nested" do
+    task "run" => "rake:copy"
+  end
+end
+
+namespace "a" do
+  desc "Run task in the 'a' namespace"
+  task "run" do
+    puts "IN A"
+  end
+end
+
+namespace "b" do
+  desc "Run task in the 'b' namespace"
+  task "run" => "a:run" do
+    puts "IN B"
+  end
+end
+
+namespace "file1" do
+  file "xyz.rb" do
+    puts "XYZ1"
+  end
+end
+
+namespace "file2" do
+  file "xyz.rb" do
+    puts "XYZ2"
+  end
+end
+
+namespace "scopedep" do
+  task :prepare do
+    touch "scopedep.rb"
+    puts "PREPARE"
+  end
+  file "scopedep.rb" => [:prepare] do
+    puts "SCOPEDEP"
+  end
+end
+    NAMESPACE
+  end
+
+  def rakefile_nosearch
+    FileUtils.touch 'dummy'
+  end
+
+  def rakefile_rakelib
+    FileUtils.mkdir_p 'rakelib'
+
+    Dir.chdir 'rakelib' do
+      open 'test1.rb', 'w' do |io|
+        io << <<-TEST1
+task :default do
+  puts "TEST1"
+end
+        TEST1
+      end
+
+      open 'test2.rake', 'w' do |io|
+        io << <<-TEST1
+task :default do
+  puts "TEST2"
+end
+        TEST1
+      end
+    end
+  end
+
+  def rakefile_rbext
+    open 'rakefile.rb', 'w' do |io|
+      io << 'task :default do puts "OK" end'
+    end
+  end
+
+  def rakefile_unittest
+    rakefile '# Empty Rakefile for Unit Test'
+
+    readme = File.join 'subdir', 'README'
+    FileUtils.mkdir_p File.dirname readme
+
+    FileUtils.touch readme
+  end
+
+  def rakefile_verbose
+    rakefile <<-VERBOSE
+task :standalone_verbose_true do
+  verbose true
+  sh "#{RUBY} -e '0'"
+end
+
+task :standalone_verbose_false do
+  verbose false
+  sh "#{RUBY} -e '0'"
+end
+
+task :inline_verbose_default do
+  sh "#{RUBY} -e '0'"
+end
+
+task :inline_verbose_false do
+  sh "#{RUBY} -e '0'", :verbose => false
+end
+
+task :inline_verbose_true do
+  sh "#{RUBY} -e '0'", :verbose => true
+end
+
+task :block_verbose_true do
+  verbose(true) do
+    sh "#{RUBY} -e '0'"
+  end
+end
+
+task :block_verbose_false do
+  verbose(false) do
+    sh "#{RUBY} -e '0'"
+  end
+end
+    VERBOSE
+  end
+
+  def rakefile_test_signal
+    rakefile <<-TEST_SIGNAL
+require 'rake/testtask'
+
+Rake::TestTask.new(:a) do |t|
+  t.test_files = ['a_test.rb']
+end
+
+Rake::TestTask.new(:b) do |t|
+  t.test_files = ['b_test.rb']
+end
+
+task :test do
+  Rake::Task[:a].invoke
+  Rake::Task[:b].invoke
+end
+
+task :default => :test
+    TEST_SIGNAL
+    open 'a_test.rb', 'w' do |io|
+      io << 'puts "ATEST"' << "\n"
+      io << '$stdout.flush' << "\n"
+      io << 'Process.kill("TERM", $$)' << "\n"
+    end
+    open 'b_test.rb', 'w' do |io|
+      io << 'puts "BTEST"' << "\n"
+      io << '$stdout.flush' << "\n"
+    end
+  end
+
+  def rakefile_failing_test_task
+    rakefile <<-TEST_TASK
+require 'rake/testtask'
+
+task :default => :test
+Rake::TestTask.new(:test) do |t|
+  t.test_files = ['a_test.rb']
+end
+    TEST_TASK
+    open 'a_test.rb', 'w' do |io|
+      io << "require 'minitest/autorun'\n"
+      io << "class ExitTaskTest < MiniTest::Unit::TestCase\n"
+      io << "  def test_exit\n"
+      io << "    assert false, 'this should fail'\n"
+      io << "  end\n"
+      io << "end\n"
+    end
+  end
+
+  def rakefile_stand_alone_filelist
+    open 'stand_alone_filelist.rb', 'w' do |io|
+      io << "require 'rake/file_list'\n"
+      io << "FL = Rake::FileList['*.rb']\n"
+      io << "puts FL\n"
+    end
+  end
+
+end