rwdtorrent 0.01

data/extras/rubytorrent/util.rb

@@ -0,0 +1,186 @@
+## util.rb -- miscellaneous RubyTorrent utility modules.
+## Copyright 2005 William Morgan.
+##
+## This file is part of RubyTorrent. RubyTorrent is free software;
+## you can redistribute it and/or modify it under the terms of version
+## 2 of the GNU General Public License as published by the Free
+## Software Foundation.
+##
+## RubyTorrent is distributed in the hope that it will be useful, but
+## WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+## General Public License (in the file COPYING) for more details.
+
+def rt_debug(*args)
+  if $DEBUG || RubyTorrent.log
+    stream = RubyTorrent.log || $stdout
+    stream << args.join << "\n" 
+    stream.flush
+  end
+end
+
+def rt_warning(*args)
+  if $DEBUG || RubyTorrent.log
+    stream = RubyTorrent.log || $stderr
+    stream << "warning: " << args.join << "\n" 
+    stream.flush
+  end
+end
+
+module RubyTorrent
+
+@log = nil
+def log_output_to(fn)
+  @log = File.open(fn, "w")
+end
+attr_reader :log
+module_function :log_output_to, :log
+
+
+## parse final hash of pseudo-keyword arguments
+def get_args(rest, *names)
+  hash = rest.find { |x| x.is_a? Hash }
+  if hash
+    rest.delete hash
+    hash.each { |k, v| raise ArgumentError, %{unknown argument "#{k}"} unless names.include?(k) }
+  end
+
+  [hash || {}, rest]
+end
+module_function :get_args
+
+## "events": very similar to Observable, but cleaner, IMO. events are
+## listened to and sent in instance space, but registered in class
+## space. example:
+##
+## class C
+##   include EventSource
+##   event :goat, :boat
+##
+##   def send_events
+##     send_event :goat
+##     send_event(:boat, 3)
+##   end
+## end
+##
+## c = C.new
+## c.on_event(:goat) { puts "got goat!" }
+## c.on_event(:boat) { |x| puts "got boat: #{x}" }
+##
+## Defining them in class space is not really necessary, except as an
+## error-checking mechanism.
+module EventSource
+  def on_event(who, *events, &b)
+    @event_handlers ||= Hash.new { [] }
+    events.each do |e|
+      raise ArgumentError, "unknown event #{e} for #{self.class}" unless (self.class.class_eval "@@event_has")[e]
+      @event_handlers[e] <<= [who, b]
+    end
+    nil
+  end
+
+  def send_event(e, *args)
+    raise ArgumentError, "unknown event #{e} for #{self.class}" unless (self.class.class_eval "@@event_has")[e]
+    @event_handlers ||= Hash.new { [] }
+    @event_handlers[e].each { |who, proc| proc[self, *args] }
+    nil
+  end
+
+  def unregister_events(who, *events)
+    @event_handlers.each do |event, handlers|
+      handlers.each do |ewho, proc|
+        if (ewho == who) && (events.empty? || events.member?(event))
+          @event_handlers[event].delete [who, proc]
+        end
+      end
+    end
+    nil
+  end
+
+  def relay_event(who, *events)
+    @event_handlers ||= Hash.new { [] }
+    events.each do |e|
+      raise "unknown event #{e} for #{self.class}" unless (self.class.class_eval "@@event_has")[e]
+      raise "unknown event #{e} for #{who.class}" unless (who.class.class_eval "@@event_has")[e]
+      @event_handlers[e] <<= [who, lambda { |s, *a| who.send_event e, *a }]
+    end
+    nil
+  end
+
+  def self.append_features(mod)
+    super(mod)
+    mod.class_eval %q{
+      @@event_has ||= Hash.new(false)
+      def self.event(*args)
+        args.each { |a| @@event_has[a] = true }
+      end
+    }
+  end
+end
+
+## ensure that a method doesn't execute more frequently than some
+## number of seconds. e.g.:
+##
+## def meth
+##   ...
+## end
+## min_iterval :meth, 10
+##
+## ensures that "meth" won't be executed more than once every 10
+## seconds.
+module MinIntervalMethods
+  def min_interval(meth, int)
+    class_eval %{
+      @@min_interval ||= {}
+      @@min_interval[:#{meth}] = [nil, #{int.to_i}]
+      alias :min_interval_#{meth} :#{meth}
+      def #{meth}(*a, &b)
+        last, int = @@min_interval[:#{meth}]
+        unless last && ((Time.now - last) < int)
+          min_interval_#{meth}(*a, &b) 
+          @@min_interval[:#{meth}][0] = Time.now
+        end
+      end
+    }
+  end
+end
+
+## boolean attributes now get question marks in their accessors
+## don't forget to 'extend' rather than 'include' this one
+module AttrReaderQ
+  def attr_reader_q(*args)
+    args.each { |v| class_eval "def #{v}?; @#{v}; end" }
+  end
+  
+  def attr_writer_q(*args)
+    args.each { |v| attr_writer v }
+  end
+  
+  def attr_accessor_q(*args)
+    attr_reader_q args
+    attr_writer_q args
+  end
+end
+
+module ArrayShuffle
+  def shuffle!
+    each_index do |i|
+      j = i + rand(self.size - i);
+      self[i], self[j] = self[j], self[i]
+    end
+  end
+
+  def shuffle
+    self.clone.shuffle! # dup doesn't preserve shuffle! method
+  end
+end
+
+module StringMapBytes
+  def map_bytes
+    ret = []
+    each_byte { |x| ret.push(yield(x)) }
+    ret
+  end
+end
+
+end

data/extras/zip/ioextras.rb

@@ -0,0 +1,114 @@
+module IOExtras
+  module FakeIO
+    def kind_of?(object)
+      object == IO || super
+    end
+  end
+
+  # Implements many of the convenience methods of IO
+  # such as gets, getc, readline and readlines 
+  # depends on: input_finished?, produce_input and read
+  module AbstractInputStream  
+    include Enumerable
+    include FakeIO
+
+    def initialize
+      super
+      @lineno = 0
+      @outputBuffer = ""
+    end
+
+    attr_accessor :lineno
+
+    def readlines(aSepString = $/)
+      retVal = []
+      each_line(aSepString) { |line| retVal << line }
+      return retVal
+    end
+    
+    def gets(aSepString=$/)
+      @lineno = @lineno.next
+      return read if aSepString == nil
+      aSepString="#{$/}#{$/}" if aSepString == ""
+      
+      bufferIndex=0
+      while ((matchIndex = @outputBuffer.index(aSepString, bufferIndex)) == nil)
+	bufferIndex=@outputBuffer.length
+	if input_finished?
+	  return @outputBuffer.empty? ? nil : flush 
+	end
+	@outputBuffer << produce_input
+      end
+      sepIndex=matchIndex + aSepString.length
+      return @outputBuffer.slice!(0...sepIndex)
+    end
+    
+    def flush
+      retVal=@outputBuffer
+      @outputBuffer=""
+      return retVal
+    end
+    
+    def readline(aSepString = $/)
+      retVal = gets(aSepString)
+      raise EOFError if retVal == nil
+      return retVal
+    end
+    
+    def each_line(aSepString = $/)
+      while true
+	yield readline(aSepString)
+      end
+    rescue EOFError
+    end
+    
+    alias_method :each, :each_line
+  end
+
+
+  #relies on <<
+  module AbstractOutputStream 
+    include FakeIO
+
+    def write(data)
+      self << data
+      data.to_s.length
+    end
+
+
+    def print(*params)
+      self << params.to_s << $\.to_s
+    end
+
+    def printf(aFormatString, *params)
+      self << sprintf(aFormatString, *params)
+    end
+
+    def putc(anObject)
+      self << case anObject
+	      when Fixnum then anObject.chr
+	      when String then anObject
+	      else raise TypeError, "putc: Only Fixnum and String supported"
+	      end
+      anObject
+    end
+    
+    def puts(*params)
+      params << "\n" if params.empty?
+      params.flatten.each {
+	|element|
+	val = element.to_s
+	self << val
+	self << "\n" unless val[-1,1] == "\n"
+      }
+    end
+
+  end
+
+end # IOExtras namespace module
+
+
+
+# Copyright (C) 2002-2004 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/extras/zip/stdrubyext.rb

@@ -0,0 +1,111 @@
+unless Enumerable.method_defined?(:inject)
+  module Enumerable  #:nodoc:all
+    def inject(n = 0)
+      each { |value| n = yield(n, value) }
+      n
+    end
+  end
+end
+
+module Enumerable #:nodoc:all
+  # returns a new array of all the return values not equal to nil
+  # This implementation could be faster
+  def select_map(&aProc)
+    map(&aProc).reject { |e| e.nil? }
+  end
+end
+
+unless Object.method_defined?(:object_id)
+  class Object
+    # Using object_id which is the new thing, so we need
+    # to make that work in versions prior to 1.8.0
+    alias object_id id
+  end
+end
+
+unless File.respond_to?(:read)
+  class File
+    # singleton method read does not exist in 1.6.x
+    def self.read(fileName)
+      open(fileName) { |f| f.read }
+    end
+  end
+end
+
+class String
+  def starts_with(aString)
+    rindex(aString, 0) == 0
+  end
+
+  def ends_with(aString)
+    index(aString, -aString.size)
+  end
+
+  def ensure_end(aString)
+    ends_with(aString) ? self : self + aString
+  end
+
+  def lchop
+    slice(1, length)
+  end
+end
+
+class Time
+  
+  #MS-DOS File Date and Time format as used in Interrupt 21H Function 57H:
+  # 
+  # Register CX, the Time:
+  # Bits 0-4  2 second increments (0-29)
+  # Bits 5-10 minutes (0-59)
+  # bits 11-15 hours (0-24)
+  # 
+  # Register DX, the Date:
+  # Bits 0-4 day (1-31)
+  # bits 5-8 month (1-12)
+  # bits 9-15 year (four digit year minus 1980)
+  
+  
+  def to_binary_dos_time
+    (sec/2) +
+      (min  << 5) +
+      (hour << 11)
+  end
+
+  def to_binary_dos_date
+    (day) +
+      (month << 5) +
+      ((year - 1980) << 9)
+  end
+
+  # Dos time is only stored with two seconds accuracy
+  def dos_equals(other)
+    to_i/2 == other.to_i/2
+  end
+
+  def self.parse_binary_dos_format(binaryDosDate, binaryDosTime)
+    second = 2 * (       0b11111 & binaryDosTime)
+    minute = (     0b11111100000 & binaryDosTime) >> 5 
+    hour   = (0b1111100000000000 & binaryDosTime) >> 11
+    day    = (           0b11111 & binaryDosDate) 
+    month  = (       0b111100000 & binaryDosDate) >> 5
+    year   = ((0b1111111000000000 & binaryDosDate) >> 9) + 1980
+    begin
+      return Time.local(year, month, day, hour, minute, second)
+    end
+  end
+end
+
+class Module
+  def forward_message(forwarder, *messagesToForward)
+    methodDefs = messagesToForward.map { 
+      |msg| 
+      "def #{msg}; #{forwarder}(:#{msg}); end"
+    }
+    module_eval(methodDefs.join("\n"))
+  end
+end
+
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/extras/zip/tempfile_bugfixed.rb

@@ -0,0 +1,195 @@
+#
+# tempfile - manipulates temporary files
+#
+# $Id: tempfile_bugfixed.rb,v 1.2 2004/03/28 12:46:36 thomas Exp $
+#
+
+require 'delegate'
+require 'tmpdir'
+
+module BugFix
+
+# A class for managing temporary files.  This library is written to be
+# thread safe.
+class Tempfile < DelegateClass(File)
+  MAX_TRY = 10
+  @@cleanlist = []
+
+  # Creates a temporary file of mode 0600 in the temporary directory
+  # whose name is basename.pid.n and opens with mode "w+".  A Tempfile
+  # object works just like a File object.
+  #
+  # If tmpdir is omitted, the temporary directory is determined by
+  # Dir::tmpdir provided by 'tmpdir.rb'.
+  # When $SAFE > 0 and the given tmpdir is tainted, it uses
+  # /tmp. (Note that ENV values are tainted by default)
+  def initialize(basename, tmpdir=Dir::tmpdir)
+    if $SAFE > 0 and tmpdir.tainted?
+      tmpdir = '/tmp'
+    end
+
+    lock = nil
+    n = failure = 0
+    
+    begin
+      Thread.critical = true
+
+      begin
+	tmpname = sprintf('%s/%s%d.%d', tmpdir, basename, $$, n)
+	lock = tmpname + '.lock'
+	n += 1
+      end while @@cleanlist.include?(tmpname) or
+	File.exist?(lock) or File.exist?(tmpname)
+
+      Dir.mkdir(lock)
+    rescue
+      failure += 1
+      retry if failure < MAX_TRY
+      raise "cannot generate tempfile `%s'" % tmpname
+    ensure
+      Thread.critical = false
+    end
+
+    @data = [tmpname]
+    @clean_proc = Tempfile.callback(@data)
+    ObjectSpace.define_finalizer(self, @clean_proc)
+
+    @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)
+    @tmpname = tmpname
+    @@cleanlist << @tmpname
+    @data[1] = @tmpfile
+    @data[2] = @@cleanlist
+
+    super(@tmpfile)
+
+    # Now we have all the File/IO methods defined, you must not
+    # carelessly put bare puts(), etc. after this.
+
+    Dir.rmdir(lock)
+  end
+
+  # Opens or reopens the file with mode "r+".
+  def open
+    @tmpfile.close if @tmpfile
+    @tmpfile = File.open(@tmpname, 'r+')
+    @data[1] = @tmpfile
+    __setobj__(@tmpfile)
+  end
+
+  def _close	# :nodoc:
+    @tmpfile.close if @tmpfile
+    @data[1] = @tmpfile = nil
+  end    
+  protected :_close
+
+  # Closes the file.  If the optional flag is true, unlinks the file
+  # after closing.
+  #
+  # If you don't explicitly unlink the temporary file, the removal
+  # will be delayed until the object is finalized.
+  def close(unlink_now=false)
+    if unlink_now
+      close!
+    else
+      _close
+    end
+  end
+
+  # Closes and unlinks the file.
+  def close!
+    _close
+    @clean_proc.call
+    ObjectSpace.undefine_finalizer(self)
+  end
+
+  # Unlinks the file.  On UNIX-like systems, it is often a good idea
+  # to unlink a temporary file immediately after creating and opening
+  # it, because it leaves other programs zero chance to access the
+  # file.
+  def unlink
+    # keep this order for thread safeness
+    File.unlink(@tmpname) if File.exist?(@tmpname)
+    @@cleanlist.delete(@tmpname) if @@cleanlist
+  end
+  alias delete unlink
+
+  if RUBY_VERSION > '1.8.0'
+    def __setobj__(obj)
+      @_dc_obj = obj
+    end
+  else
+    def __setobj__(obj)
+      @obj = obj
+    end
+  end
+
+  # Returns the full path name of the temporary file.
+  def path
+    @tmpname
+  end
+
+  # Returns the size of the temporary file.  As a side effect, the IO
+  # buffer is flushed before determining the size.
+  def size
+    if @tmpfile
+      @tmpfile.flush
+      @tmpfile.stat.size
+    else
+      0
+    end
+  end
+  alias length size
+
+  class << self
+    def callback(data)	# :nodoc:
+      pid = $$
+      lambda{
+	if pid == $$ 
+	  path, tmpfile, cleanlist = *data
+
+	  print "removing ", path, "..." if $DEBUG
+
+	  tmpfile.close if tmpfile
+
+	  # keep this order for thread safeness
+	  File.unlink(path) if File.exist?(path)
+	  cleanlist.delete(path) if cleanlist
+
+	  print "done\n" if $DEBUG
+	end
+      }
+    end
+
+    # If no block is given, this is a synonym for new().
+    #
+    # If a block is given, it will be passed tempfile as an argument,
+    # and the tempfile will automatically be closed when the block
+    # terminates.  In this case, open() returns nil.
+    def open(*args)
+      tempfile = new(*args)
+
+      if block_given?
+	begin
+	  yield(tempfile)
+	ensure
+	  tempfile.close
+	end
+
+	nil
+      else
+	tempfile
+      end
+    end
+  end
+end
+
+end # module BugFix
+if __FILE__ == $0
+#  $DEBUG = true
+  f = Tempfile.new("foo")
+  f.print("foo\n")
+  f.close
+  f.open
+  p f.gets # => "foo\n"
+  f.close!
+end