lgrgic_palindrome_detector 0.1.0

data/vendor/cache/gems/rake-10.5.0/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 do |k, v| "#{k}:#{v}" end.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/cache/gems/rake-10.5.0/lib/rake/thread_pool.rb

@@ -0,0 +1,164 @@
+require 'thread'
+require 'set'
+
+require 'rake/promise'
+
+module Rake
+
+  class ThreadPool # :nodoc: all
+
+    # Creates a ThreadPool object.  The +thread_count+ 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
+    # Thread#new) The return value is an object representing
+    # a future which has been created and added to the queue in the
+    # pool. Sending #value 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 safe_thread_count
+      @threads_mon.synchronize do
+        @threads.count
+      end
+    end
+
+    def start_thread # :nodoc:
+      @threads_mon.synchronize do
+        next unless @threads.count < @max_active_threads
+
+        t = Thread.new do
+          begin
+            while safe_thread_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
+  end
+
+end

data/vendor/cache/gems/rake-10.5.0/lib/rake/trace_output.rb

@@ -0,0 +1,22 @@
+module Rake
+  module TraceOutput # :nodoc: all
+
+    # 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|
+          next if s.nil?
+          s =~ /#{sep}$/ ? s : s + sep
+        }.join
+      end
+      out.print(output)
+    end
+  end
+end

data/vendor/cache/gems/rake-10.5.0/lib/rake/version.rb

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

data/vendor/cache/gems/rake-10.5.0/lib/rake/win32.rb

@@ -0,0 +1,56 @@
+
+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 # :nodoc: all
+
+    # 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/cache/gems/rake-10.5.0/rakelib/publish.rake

@@ -0,0 +1,20 @@
+# Optional publish task for Rake
+
+begin
+  require 'rake/contrib/sshpublisher'
+  require 'rake/contrib/rubyforgepublisher'
+
+  publisher = Rake::SshDirPublisher.new(
+    'linode',
+    'htdocs/software/rake',
+    'html')
+
+  desc "Publish the Documentation to RubyForge."
+  task :publish => [:rdoc] do
+    publisher.upload
+  end
+
+rescue LoadError => ex
+  puts "#{ex.message} (#{ex.class})"
+  puts "No Publisher Task Available"
+end

data/vendor/cache/gems/rake-10.5.0/rakelib/test_times.rake

@@ -0,0 +1,25 @@
+module TestTimes
+  def self.run(test_results, limit=0)
+    limit = limit.nonzero? || 10
+    tests = []
+    test_results.split(/\n/).each do |line|
+      if line =~ /^(.+?#[^:]+): ([0-9.]+) s: \.$/
+        tests << [$1, $2.to_f, line]
+      end
+    end
+
+    puts "#{limit} Slowest tests"
+    puts tests.sort_by { |item|
+      item[1]
+    }.reverse[0...limit].map { |item|
+      "%6.3f: %-s\n" % [item[1], item[0]]
+    }
+  end
+end
+
+namespace :test do
+  desc "Find the slowest unit tests"
+  task :times, [:limit] do |t, args|
+    TestTimes.run `rake test:units TESTOPTS='--verbose'`, args.limit.to_i
+  end
+end

data/vendor/cache/gems/rake-10.5.0/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/cache/gems/rake-10.5.0/test/helper.rb

@@ -0,0 +1,129 @@
+require 'rubygems'
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+begin
+  gem 'minitest', '~> 5'
+rescue Gem::LoadError
+end
+
+require 'minitest/autorun'
+require 'rake'
+require 'tmpdir'
+require File.expand_path('../file_creation', __FILE__)
+
+
+begin
+  require_relative 'support/ruby_runner'
+  require_relative 'support/rakefile_definitions'
+rescue NoMethodError, LoadError
+  # ruby 1.8
+  require 'test/support/ruby_runner'
+  require 'test/support/rakefile_definitions'
+end
+
+class Rake::TestCase < Minitest::Test
+  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'
+        # rake repository
+        File.expand_path '../../', __FILE__
+      else
+        # ruby repository
+        File.expand_path '../../../', __FILE__
+      end
+
+    @verbose = ENV['VERBOSE']
+
+    @rake_exec = File.join @rake_root, 'bin', 'rake'
+    @rake_lib  = File.join @rake_root, 'lib'
+    @ruby_options = ["-I#{@rake_lib}", "-I."]
+
+    @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
+      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
+
+  include RakefileDefinitions
+end