pik 0.1.1 → 0.2.0

data/lib/pik/contrib/unzip.rb

@@ -0,0 +1,14 @@
+$: << File.dirname(__FILE__)
+require 'zip/zip'
+
+module Zip
+  def self.fake_unzip(zipfilename, regexp, target_dir)
+    Zip::ZipFile.open(zipfilename) do |zipfile|
+      Zip::ZipFile.foreach(zipfilename) do |entry|
+        if regexp =~ entry.name
+          zipfile.extract(entry, File.join(target_dir, File.basename(entry.name))) { true }
+        end
+      end
+    end
+  end
+end

data/lib/pik/contrib/uri_ext.rb

@@ -0,0 +1,296 @@
+#
+# I've striped down dependencies on Net::SSH and Facets to
+# stay as simple as possible.
+#
+# Original code from Assaf Arkin, released under Apache License
+# (http://buildr.rubyforge.org/license.html)
+#
+require 'cgi'
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'tempfile'
+require 'fileutils'
+
+# show progress of download
+# require File.join(File.dirname(__FILE__), 'progressbar')
+
+# Not quite open-uri, but similar. Provides read and write methods for the resource represented by the URI.
+# Currently supports reads for URI::HTTP and writes for URI::SFTP. Also provides convenience methods for
+# downloads and uploads.
+module URI
+  # Raised when trying to read/download a resource that doesn't exist.
+  class NotFoundError < RuntimeError; end
+
+  class << self
+  
+    # :call-seq:
+    #   read(uri, options?) => content
+    #   read(uri, options?) { |chunk| ... }
+    #
+    # Reads from the resource behind this URI. The first form returns the content of the resource,
+    # the second form yields to the block with each chunk of content (usually more than one).
+    #
+    # For example:
+    #   File.open "image.jpg", "w" do |file|
+    #     URI.read("http://example.com/image.jpg") { |chunk| file.write chunk }
+    #   end
+    # Shorter version:
+    #   File.open("image.jpg", "w") { |file| file.write URI.read("http://example.com/image.jpg") }
+    #
+    # Supported options:
+    # * :modified -- Only download if file modified since this timestamp. Returns nil if not modified.
+    # * :progress -- Show the progress bar while reading.
+    def read(uri, options = nil, &block)
+      uri = URI.parse(uri.to_s) unless URI === uri
+      uri.read(options, &block)
+    end
+
+    # :call-seq:
+    #   download(uri, target, options?)
+    #
+    # Downloads the resource to the target.
+    #
+    # The target may be a file name (string or task), in which case the file is created from the resource.
+    # The target may also be any object that responds to +write+, e.g. File, StringIO, Pipe.
+    #
+    # Use the progress bar when running in verbose mode.
+    def download(uri, target, options = nil)
+      uri = URI.parse(uri.to_s) unless URI === uri
+      uri.download(target, options)
+    end
+      
+    # :call-seq:
+    #   write(uri, content, options?)
+    #   write(uri, options?) { |bytes| .. }
+    #
+    # Writes to the resource behind the URI. The first form writes the content from a string or an object
+    # that responds to +read+ and optionally +size+. The second form writes the content by yielding to the
+    # block. Each yield should return up to the specified number of bytes, the last yield returns nil.
+    #
+    # For example:
+    #   File.open "killer-app.jar", "rb" do |file|
+    #     write("sftp://localhost/jars/killer-app.jar") { |chunk| file.read(chunk) }
+    #   end
+    # Or:
+    #   write "sftp://localhost/jars/killer-app.jar", File.read("killer-app.jar")
+    #
+    # Supported options:
+    # * :progress -- Show the progress bar while reading.
+    def write(uri, *args, &block)
+      uri = URI.parse(uri.to_s) unless URI === uri
+      uri.write(*args, &block)
+    end
+  end
+
+  class Generic
+
+    # :call-seq:
+    #   read(options?) => content
+    #   read(options?) { |chunk| ... }
+    #
+    # Reads from the resource behind this URI. The first form returns the content of the resource,
+    # the second form yields to the block with each chunk of content (usually more than one).
+    #
+    # For options, see URI::read.
+    def read(options = nil, &block)
+      fail "This protocol doesn't support reading (yet, how about helping by implementing it?)"
+    end
+  
+    # :call-seq:
+    #   download(target, options?)
+    #
+    # Downloads the resource to the target.
+    #
+    # The target may be a file name (string or task), in which case the file is created from the resource.
+    # The target may also be any object that responds to +write+, e.g. File, StringIO, Pipe.
+    #
+    # Use the progress bar when running in verbose mode.
+    def download(target, options = {})
+      case target
+      when String
+        # If download breaks we end up with a partial file which is
+        # worse than not having a file at all, so download to temporary
+        # file and then move over.
+        modified = File.stat(target).mtime if File.exist?(target)
+        temp = nil
+        result = nil
+        Tempfile.open(File.basename(target)) do |tf|
+          tf.binmode
+          result = read(options.merge(:modified => modified)) { |chunk| tf.write chunk }
+          temp = tf
+        end
+        FileUtils.mkpath(File.dirname(target))
+        FileUtils.move(temp.path, target) if result
+      when File
+        read(options.merge(:modified => target.mtime)) { |chunk| target.write chunk }
+        target.flush
+      else
+        raise ArgumentError, "Expecting a target that is either a file name (string, task) or object that responds to write (file, pipe)." unless target.respond_to?(:write)
+        read(options) { |chunk| target.write chunk }
+        target.flush
+      end
+    end
+
+    # :call-seq:
+    #   write(content, options?)
+    #   write(options?) { |bytes| .. }
+    #
+    # Writes to the resource behind the URI. The first form writes the content from a string or an object
+    # that responds to +read+ and optionally +size+. The second form writes the content by yielding to the
+    # block. Each yield should return up to the specified number of bytes, the last yield returns nil.
+    #
+    # For options, see URI::write.
+    def write(*args, &block)
+      options = args.pop if Hash === args.last
+      options ||= {}
+      if String === args.first
+        ios = StringIO.new(args.first, "r")
+        write(options.merge(:size => args.first.size)) { |bytes| ios.read(bytes) }
+      elsif args.first.respond_to?(:read)
+        size = args.first.size rescue nil
+        write({ :size => size }.merge(options)) { |bytes| args.first.read(bytes) }
+      elsif args.empty? && block
+        write_internal(options, &block)
+      else
+        raise ArgumentError, "Either give me the content, or pass me a block, otherwise what would I upload?"
+      end
+    end
+
+  protected
+
+    # :call-seq:
+    #   with_progress_bar(enable, file_name, size) { |progress| ... }
+    #
+    # Displays a progress bar while executing the block. The first argument must be true for the
+    # progress bar to show (TTY output also required), as a convenient for selectively using the
+    # progress bar from a single block.
+    #
+    # The second argument provides a filename to display, the third its size in bytes.
+    #
+    # The block is yielded with a progress object that implements a single method.
+    # Call << for each block of bytes down/uploaded.
+    def with_progress_bar(enable, file_name, size) #:nodoc:
+      if enable && $stdout.isatty
+        progress_bar = Console::ProgressBar.new(file_name, size)
+        # Extend the progress bar so we can display count/total.
+        class << progress_bar
+          def total()
+            convert_bytes(@total)
+          end
+        end
+        # Squeeze the filename into 30 characters.
+        if file_name.size > 30
+          base, ext = File.basename(file_name), File.extname(file_name)
+          truncated = "#{base[0..26-ext.to_s.size]}..#{ext}"
+        else
+          truncated = file_name
+        end
+        progress_bar.format = "#{CGI.unescape(truncated)}: %3d%% %s %s/%s %s"
+        progress_bar.format_arguments = [:percentage, :bar, :bytes, :total, :stat]
+        progress_bar.bar_mark = "o"
+
+        begin
+          class << progress_bar
+            def <<(bytes)
+              inc bytes.respond_to?(:size) ? bytes.size : bytes
+            end
+          end
+          yield progress_bar
+        ensure
+          progress_bar.finish
+        end
+      else
+        progress_bar = Object.new
+        class << progress_bar
+          def <<(bytes)
+          end
+        end
+        yield progress_bar
+      end
+    end
+
+    # :call-seq:
+    #   proxy_uri() => URI?
+    #
+    # Returns the proxy server to use. Obtains the proxy from the relevant environment variable (e.g. HTTP_PROXY).
+    # Supports exclusions based on host name and port number from environment variable NO_PROXY.
+    def proxy_uri()
+      proxy = ENV["#{scheme.upcase}_PROXY"]
+      proxy = URI.parse(proxy) if String === proxy
+      excludes = (ENV["NO_PROXY"] || "").split(/\s*,\s*/).compact
+      excludes = excludes.map { |exclude| exclude =~ /:\d+$/ ? exclude : "#{exclude}:*" }
+      return proxy unless excludes.any? { |exclude| File.fnmatch(exclude, "#{host}:#{port}") }
+    end
+
+    def write_internal(options, &block) #:nodoc:
+      fail "This protocol doesn't support writing (yet, how about helping by implementing it?)"
+    end
+  end
+
+  class HTTP #:nodoc:
+    
+    def verbose
+      false
+    end
+
+    # See URI::Generic#read
+    def read(options = nil, &block)
+      options ||= {}
+      connect do |http|
+        puts "Requesting #{self}" if verbose
+        headers = { 'If-Modified-Since' => CGI.rfc1123_date(options[:modified].utc) } if options[:modified]
+        request = Net::HTTP::Get.new(request_uri.empty? ? '/' : request_uri, headers)
+        request.basic_auth self.user, self.password if self.user
+        http.request request do |response|
+          case response
+          when Net::HTTPNotModified
+            # No modification, nothing to do.
+            puts 'Not modified since last download' if verbose
+            return nil
+          when Net::HTTPRedirection
+            # Try to download from the new URI, handle relative redirects.
+            puts "Redirected to #{response['Location']}" if verbose
+            return (self + URI.parse(response['location'])).read(options, &block)
+          when Net::HTTPOK
+            puts "Downloading #{self}" if verbose
+            result = nil
+            with_progress_bar options[:progress], path.split('/').last, response.content_length do |progress|
+              if block
+                response.read_body do |chunk|
+                  block.call chunk
+                  progress << chunk
+                end
+                return true
+              else
+                result = ''
+                response.read_body do |chunk|
+                  result << chunk
+                  progress << chunk
+                end
+                return result
+              end
+            end
+          when Net::HTTPNotFound
+            raise NotFoundError, "Looking for #{self} and all I got was a 404!"
+          else
+            raise RuntimeError, "Failed to download #{self}: #{response.message}"
+          end
+        end
+      end
+    end
+
+  private
+
+    def connect
+      if proxy = proxy_uri
+        proxy = URI.parse(proxy) if String === proxy
+        http = Net::HTTP.new(host, port, proxy.host, proxy.port, proxy.user, proxy.password)
+      else
+        http = Net::HTTP.new(host, port)
+      end
+      http.use_ssl = true if self.instance_of? URI::HTTPS
+      yield http
+    end
+  end  
+end

data/lib/pik/contrib/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.