amp-pure 0.5.0

data/lib/amp/dependencies/zip/ioextras.rb

@@ -0,0 +1,155 @@
+module IOExtras  #:nodoc:
+
+  CHUNK_SIZE = 32768
+
+  RANGE_ALL = 0 .. -1
+
+  def self.copy_stream(ostream, istream)
+    s = ''
+    ostream.write(istream.read(CHUNK_SIZE, s)) until istream.eof? 
+  end
+
+
+  # Implements kind_of? in order to pretend to be an IO object
+  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 read(numberOfBytes = nil, buf = nil)
+      tbuf = nil
+
+      if @outputBuffer.length > 0
+        if numberOfBytes <= @outputBuffer.length
+          tbuf = @outputBuffer.slice!(0, numberOfBytes)
+        else
+          numberOfBytes -= @outputBuffer.length if (numberOfBytes)
+          rbuf = sysread(numberOfBytes, buf)
+          tbuf = @outputBuffer
+          tbuf << rbuf if (rbuf)
+          @outputBuffer = ""
+        end
+      else
+        tbuf = sysread(numberOfBytes, buf)
+      end
+
+      return nil unless (tbuf)
+
+      if buf
+        buf.replace(tbuf)
+      else
+        buf = tbuf
+      end
+
+      buf
+    end
+
+    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
+
+
+  # Implements many of the output convenience methods of IO.
+  # 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/lib/amp/dependencies/zip/stdrubyext.rb

@@ -0,0 +1,111 @@
+unless Enumerable.method_defined?(:inject)
+  module Enumerable
+    def inject(n = 0)
+      each { |value| n = yield(n, value) }
+      n
+    end
+  end
+end
+
+module Enumerable
+  # 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/lib/amp/dependencies/zip/tempfile_bugfixed.rb

@@ -0,0 +1,186 @@
+#
+# tempfile - manipulates temporary files
+#
+# $Id: tempfile_bugfixed.rb,v 1.2 2005/02/19 20:30:33 thomas Exp $
+#
+
+require 'delegate'
+require 'tmpdir'
+
+module BugFix  #:nodoc:all
+
+# 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