sprout 0.7.220-x86-darwin-10

data/lib/progress_bar.rb

@@ -0,0 +1,354 @@
+#
+# Ruby/ProgressBar - a text progress bar library
+#
+# Copyright (C) 2001-2005 Satoru Takabayashi <satoru@namazu.org>
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms
+# of Ruby's license.
+#
+# Modified by Luke Bayes to support progress display on 
+# multiple simultaneous connections
+
+require 'singleton'
+
+class ProgressBar # :nodoc:[all]
+  VERSION = "0.9"
+  @@debug = false
+  @@outio = $stderr
+  
+  def self.new(title, total)
+    return ProgressBarManager.instance.add(title, total)
+  end
+
+  def self.debug?
+    @@debug
+  end
+  
+  def self.debug=(debug)
+    @@debug = debug
+    if(debug)
+      @@outio = StringIO.new
+    else
+      @@outio = $stderr
+    end
+  end
+  
+  def self.outio
+    @@outio
+  end
+
+end
+
+class ProgressBarImpl # :nodoc:[all]
+  
+  def initialize (title, total, out = STDERR)
+    @title = title
+    @total = total
+    @out = out
+    @terminal_width = 80
+    @bar_mark = "."
+    @current = 0
+    @previous = 0
+    @finished_p = false
+    @start_time = Time.now
+    @previous_time = @start_time
+    @title_width = 18
+    @format = "%-#{@title_width}s %3d%% %s %s"
+    @format_arguments = [:title, :percentage, :bar, :stat]
+    clear
+    show
+  end
+  attr_reader   :title
+  attr_reader   :current
+  attr_reader   :total
+  attr_accessor :start_time,
+                :title_width,
+                :bar_mark
+                
+  def fmt_bar
+    bar_width = do_percentage * @terminal_width / 100
+    sprintf("|%s%s|", 
+            @bar_mark * bar_width, 
+            " " *  (@terminal_width - bar_width))
+  end
+
+  def fmt_percentage
+    do_percentage
+  end
+
+  def fmt_stat
+    if @finished_p then elapsed else eta end
+  end
+
+  def fmt_stat_for_file_transfer
+    if @finished_p then 
+      sprintf("%s %s %s", bytes, transfer_rate, elapsed)
+    else 
+      sprintf("%s %s %s", bytes, transfer_rate, eta)
+    end
+  end
+
+  def fmt_title
+    @title[0,(@title_width - 1)] + ":"
+  end
+
+  def convert_bytes (bytes)
+    if bytes < 1024
+      sprintf("%6dB", bytes)
+    elsif bytes < 1024 * 1000 # 1000kb
+      sprintf("%5.1fKB", bytes.to_f / 1024)
+    elsif bytes < 1024 * 1024 * 1000  # 1000mb
+      sprintf("%5.1fMB", bytes.to_f / 1024 / 1024)
+    else
+      sprintf("%5.1fGB", bytes.to_f / 1024 / 1024 / 1024)
+    end
+  end
+
+  def transfer_rate
+    bytes_per_second = @current.to_f / (Time.now - @start_time)
+    sprintf("%s/s", convert_bytes(bytes_per_second))
+  end
+
+  def bytes
+    convert_bytes(@current)
+  end
+
+  def format_time (t)
+    t = t.to_i
+    sec = t % 60
+    min  = (t / 60) % 60
+    hour = t / 3600
+    sprintf("%02d:%02d:%02d", hour, min, sec)
+  end
+  
+  # ETA stands for Estimated Time of Arrival.
+  def eta
+    if @current == 0
+      "ETA:  --:--:--"
+    else
+      elapsed_time = Time.now - @start_time
+      estimated_time = elapsed_time * @total / @current - elapsed_time
+      sprintf("ETA:  %s", format_time(estimated_time))
+    end
+  end
+
+  def elapsed
+    elapsed_time = Time.now - @start_time
+    sprintf("Time: %s", format_time(elapsed_time))
+  end
+  
+  def eol
+    if @finished_p then "\n" else "\r" end
+  end
+
+  def do_percentage
+    if @total.zero?
+      100
+    else
+      @current  * 100 / @total
+    end
+  end
+
+  def get_width
+#    return 80
+    # FIXME: I don't know how portable it is.
+    default_width = 80
+    begin
+      tiocgwinsz = 0x5413
+      data = [0, 0, 0, 0].pack("SSSS")
+      if @out.ioctl(tiocgwinsz, data) >= 0 then
+        unpacked = data.unpack("SSSS")
+        cols = unpacked[1]
+        # Commented this because Aptana was complaining about
+        # The unused variables
+        # rows, cols, xpixels, ypixels = data.unpack("SSSS")
+        if cols >= 0 then cols else default_width end
+      else
+        default_width
+      end
+    rescue Exception
+      default_width
+    end
+  end
+
+  def show
+    arguments = @format_arguments.map do |method|
+      method = sprintf("fmt_%s", method)
+      send(method)
+    end
+    line = sprintf(@format, *arguments)
+
+    width = get_width
+    if(line.length == width - 1)
+      @out.print(line + eol)
+      @out.flush
+    elsif(line.length >= width)
+      @terminal_width = [@terminal_width - (line.length - width + 1), 0].max
+      if @terminal_width == 0 then @out.print(line + eol) else show end
+    else # line.length < width - 1
+      @terminal_width += width - line.length + 1
+      show
+    end
+    @previous_time = Time.now
+  end
+
+  def show_if_needed
+    if @total.zero?
+      cur_percentage = 100
+      prev_percentage = 0
+    else
+      cur_percentage  = (@current  * 100 / @total).to_i
+      prev_percentage = (@previous * 100 / @total).to_i
+    end
+
+    # Use "!=" instead of ">" to support negative changes
+    if cur_percentage != prev_percentage || 
+        Time.now - @previous_time >= 1 || @finished_p
+      show
+    end
+  end
+
+  public
+  def clear
+    @out.print "\r"
+    @out.print(" " * (get_width - 1))
+    @out.print "\r"
+  end
+
+  def finish
+    @current = @total
+    @finished_p = true
+    show
+  end
+
+  def finished?
+    @finished_p
+  end
+
+  def file_transfer_mode
+    @format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+  end
+
+  def format= (format)
+    @format = format
+  end
+
+  def format_arguments= (arguments)
+    @format_arguments = arguments
+  end
+
+  def halt
+    @finished_p = true
+    show
+  end
+
+  def inc (step = 1)
+    @current += step
+    @current = @total if @current > @total
+    show_if_needed
+    @previous = @current
+  end
+
+  def set (count)
+    if count < 0 || count > @total
+      @total = count
+    end
+    @current = count
+    show_if_needed
+    @previous = @current
+  end
+
+  def inspect
+    "#<ProgressBar:#{@current}/#{@total}>"
+  end
+end
+
+# Used instead of $stderr when Log.debug == true
+# This helps keep us from junking up unit test
+# output with download status messages
+class MockOutput  # :nodoc:[all]
+  def print(str)
+  end
+  
+  def puts(str)
+  end
+
+  def flush
+  end
+end
+
+class ReversedProgressBar < ProgressBar  # :nodoc:[all]
+  def do_percentage
+    100 - super
+  end
+end
+
+class ProgressBarOutputStream  # :nodoc:[all]
+  attr_reader :title
+  
+  def initialize(mgr)
+    @mgr = mgr
+    @msg = ''
+  end
+  
+  def print(msg)
+    @msg = msg
+  end
+  
+  def flush
+    @mgr.flush
+  end
+  
+  def to_s
+    return @msg.clone.split("\n").join("").split("\r").join("")
+  end
+  
+end
+
+class ProgressBarManager # :nodoc:[all]
+  include Singleton
+  
+  def initialize
+    @finished = {}
+    @bars = {}
+    @outs = {}
+  end
+  
+  def add(title, total1)
+#    if(@bars[title])
+#      raise StandardError.new
+#    end
+    @outs[title] = ProgressBarOutputStream.new(self)
+    @bars[title] = ProgressBarImpl.new(title, total1, @outs[title])
+  end
+  
+  def print(title)
+    str = ''
+    str += @outs[title].to_s
+    str += "\r"
+    outio.print "\r"
+    outio.print str
+  end
+  
+  def outio
+    ProgressBar.outio
+  end
+  
+  def flush
+    @bars.keys.each do |title|
+      print(title)
+    end
+    
+    @bars.values.each do |bar|
+      if(bar.finished?)
+        print(bar.title)
+        outio.print "\n"
+        @outs.delete(bar.title)
+        @bars.delete(bar.title)
+      end
+    end
+  end
+  
+end

data/lib/sprout/archive_unpacker.rb

@@ -0,0 +1,225 @@
+
+module Sprout
+  class ArchiveUnpackerError < StandardError #:nodoc:
+  end
+
+  # Unpack downloaded files from a variety of common archive types.
+  # This library should efficiently extract archived files
+  # on OS X, Win XP, Vista, DOS, Cygwin, and Linux.
+  # 
+  # It will attempt to infer the archive type by standard mime-type file
+  # extensions, but if there is a file with no extension, the unpack_archive
+  # method can be provided with an @archive_type symbol argument that is one
+  # of the following values:
+  #   :exe
+  #   :zip
+  #   :targz
+  #   :gzip
+  #   :swc
+  #   :rb
+  #   :dmg
+  class ArchiveUnpacker #:nodoc:
+    include Archive::Tar
+    
+    def unpack_archive(file_name, dir, force=false, archive_type=nil)
+      archive_type ||= inferred_archive_type(file_name)
+      suffix = suffix_for_archive_type(archive_type)
+      
+      unpacked = unpacked_file_name(file_name, dir, suffix)
+      if(File.exists?(unpacked) && force)
+        FileUtils.rm_rf(unpacked)
+      end
+      
+      if(!File.exists?(unpacked))
+        case archive_type.to_s
+          when 'zip'
+            unpack_zip(file_name, dir)
+          when 'targz'
+            unpack_targz(file_name, dir)
+          when 'dmg'
+            unpack_dmg(file_name, dir)
+          when 'exe'
+            FileUtils.mkdir_p(dir)
+            File.mv(file_name, dir)
+          when 'swc' || 'rb'
+            return
+          else
+            raise ArchiveUnpackerError.new("ArchiveUnpacker does not know how to unpack files of type: #{archive_type} for file_name: #{file_name}")
+        end
+      end
+    end
+    
+    def unpack_zip(zip_file, dir)
+      # Avoid the rubyzip Segmentation Fault bug
+      # at least on os x...
+      if(RUBY_PLATFORM =~ /darwin/)
+          # Unzipping on OS X
+          FileUtils.makedirs(dir)
+          zip_dir = File.expand_path(File.dirname(zip_file))
+          zip_name = File.basename(zip_file)
+          output = File.expand_path(dir)
+          # puts ">> zip_dir: #{zip_dir} zip_name: #{zip_name} output: #{output}"
+          %x(cd #{zip_dir};unzip #{zip_name} -d #{output})
+      else
+        retries = 0
+        begin
+          retries += 1
+          Zip::ZipFile::open(zip_file) do |zf|
+            zf.each do |e|
+              fpath = File.join(dir, e.name)
+              FileUtils.mkdir_p(File.dirname(fpath))
+              # Disgusting, Gross Hack to fix DOS/Ruby Bug
+              # That makes the zip library throw a ZipDestinationFileExistsError
+              # When the zip archive includes two files whose names 
+              # differ only by extension.
+              # This bug actually appears in the File.exists? implementation
+              # throwing false positives!
+              # If you're going to use this code, be sure you extract
+              # into a new, empty directory as existing files will be 
+              # clobbered...
+              begin
+                if(File.exists?(fpath) && !File.directory?(fpath))
+                  hackpath = fpath + 'hack'
+                  zf.extract(e, hackpath)
+                  File.copy(hackpath, fpath)
+                  File.delete(hackpath)
+                else
+                  zf.extract(e, fpath)
+                end
+              rescue NotImplementedError => ni_err
+                puts "[WARNING] #{ni_err} for: #{e}"
+              end
+            end
+          end
+        rescue StandardError => err
+          FileUtils.rm_rf(dir)
+          if(retries < 3)
+            FileUtils.makedirs(dir)
+            retry
+          end
+          raise err
+        end
+      end
+    end
+    
+    def unpacked_file_name(file, dir, suffix=nil)
+      basename = File.basename(file, suffix)
+      path = File.expand_path(dir)
+      return File.join(path, basename)
+    end
+    
+    def unpack_targz(tgz_file, dir)
+      if(!File.exists?(dir))
+        FileUtils.makedirs(dir)
+      end
+      tar = Zlib::GzipReader.new(File.open(tgz_file, 'rb'))
+      Minitar.unpack(tar, dir)
+      
+      # Recurse and unpack gzipped children (Adobe did this double 
+      # gzip with the Linux FlashPlayer for some reason)
+      Dir.glob("#{dir}/**/*.tar.gz").each do |child|
+        if(child != tgz_file)
+          unpack_targz(child, File.dirname(child))
+        end
+      end
+      
+    end
+    
+    # This is actually not unpacking the FlashPlayer
+    # Binary file as expected...
+    # OSX is treated the player binary as if it is
+    # a regular text file, but if it is copied manually,
+    # the command works fine!?
+    def unpack_dmg(dmg_file, dir)
+      # 1) Mount the dmg in place
+      # 2) Recursively Copy its contents to asproject_home
+      # 3) Unmount the dmg
+      if(mounted_path.nil?)
+        raise StandardError.new('DMG file downloaded, but the RemoteFileTask needs a mounted_path in order to mount it')
+      end
+
+      if(!File.exists?(full_mounted_path))
+        system("hdiutil mount #{dmg_file}")
+      end
+      
+      begin
+        mounted_target = File.join(full_mounted_path, extracted_file)
+  
+        # Copy the DMG contents using system copy rather than ruby utils
+        # Because OS X does something special with .app files that the
+        # Ruby FileUtils and File classes break...
+        from = mounted_target
+#        from = File.join(full_mounted_path, extracted_file)
+        to = File.join(@user.downloads, @name.to_s, extracted_file)
+        FileUtils.makedirs(File.dirname(to))
+        
+        if(File.exists?(from))
+          `ditto '#{from}' '#{to}'`
+        end
+      rescue StandardError => e
+        if(File.exists?(full_mounted_path))
+          system("hdiutil unmount -force \"#{full_mounted_path}\"")
+        end
+      end
+    end
+    
+    def suffix_for_archive_type(type)
+      if(type == :targz)
+        return '.tar.gz'
+      else
+        return ".#{type.to_s}"
+      end
+    end
+    
+    def inferred_archive_type(file_name)
+      if is_zip?(file_name)
+        return :zip
+      elsif is_targz?(file_name)
+        return :targz
+      elsif is_gzip?(file_name)
+        return :gz
+      elsif is_swc?(file_name)
+        return :swc
+      elsif is_rb?(file_name)
+        return :rb
+      elsif is_dmg?(file_name)
+        return :dmg
+      elsif is_exe?(file_name)
+        return :exe
+      else
+        return nil
+      end
+      
+    end
+    
+    def is_zip?(file)
+      return (file.split('.').pop == 'zip')
+    end
+    
+    def is_targz?(file)
+      parts = file.split('.')
+      part = parts.pop
+      return (part == 'tgz' || part == 'gz' && parts.pop == 'tar')
+    end
+    
+    def is_gzip?(file)
+      return (file.split('.').pop == 'gz')
+    end
+    
+    def is_swc?(file)
+      return (file.split('.').pop == 'swc')
+    end
+    
+    def is_rb?(file)
+      return (file.split('.').pop == 'rb')
+    end
+    
+    def is_dmg?(file)
+      return (file.split('.').pop == 'dmg')
+    end    
+
+    def is_exe?(file)
+      return (file.split('.').pop == 'exe')
+    end
+  end
+end

data/lib/sprout/builder.rb

@@ -0,0 +1,44 @@
+
+module Sprout
+
+  class BuilderError < StandardError #:nodoc:
+  end
+
+  # accepts a destination path and a sprout specification
+  # and will download and unpack the platform-specific
+  # archives that are identified in the spec
+  class Builder # :nodoc:
+    
+    def self.build(file_targets_yaml, destination)
+      data = nil
+      
+      File.open(file_targets_yaml, 'r') do |f|
+        data = f.read
+      end
+      
+      targets = YAML.load(data)
+      targets.each do |target|
+        # iterate over the provided RemoteFileTargets until we 
+        # encounter one that is appropriate for our platform,
+        # or one that claims to be universal.
+        # When authoring a sprout.spec for libraries or tools,
+        # put the most specific RemoteFileTargets first, then
+        # universals to catch unexpected platforms.
+        if(target.platform == platform || target.platform == 'universal')
+          target.install_path = FileUtils.mkdir_p(destination)
+          target.resolve
+          return target
+        end
+      end
+      raise BuilderError.new("Sprout::Builder.build failed, unsupported platform or unexpected yaml")
+    end
+    
+    private
+    
+    def self.platform
+      @@platform ||= User.new.platform.to_s
+    end
+    
+  end
+end
+

data/lib/sprout/commands/generate.rb

@@ -0,0 +1,9 @@
+=begin
+require 'rubygems'
+gem 'activesupport', '>= 2.0.2'
+require 'generator'
+require 'sprout'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Scripts::Generate.new.run(ARGV)
+=end

data/lib/sprout/dynamic_accessors.rb

@@ -0,0 +1,34 @@
+
+# DynamicAccessors provides support for
+# simply setting and getting values of any kind from
+# any object that includes it.
+#
+#   require 'dynamic_accessors'
+#
+#   class Foo
+#     include DynamicAccessors
+#   end
+#
+#   foo = Foo.new
+#   foo.bar = "Hello World"
+#   foo.friends = ['a', 'b', 'c']
+#   puts "foo.bar: #{foo.bar}"
+#   puts "foo.friends: #{foo.friends.join(', ')}"
+
+module DynamicAccessors
+  
+  def initialize(*params)
+    super
+    @missing_params_hash = Hash.new
+  end
+
+  def method_missing(method, *params, &block)
+    if(method.to_s.match(/=$/))
+      method = method.to_s.gsub('=', '').to_sym
+      return @missing_params_hash[method] = params.shift
+    else
+      return @missing_params_hash[method] if @missing_params_hash.keys.collect(&:to_sym).include?(method)
+    end
+    super
+  end
+end

data/lib/sprout/general_tasks.rb

@@ -0,0 +1,6 @@
+
+require 'sprout/tasks/sftp_task'
+require 'sprout/tasks/ssh_task'
+require 'sprout/tasks/zip_task'
+require 'sprout/tasks/gem_wrap_task'
+require 'sprout/tasks/library_task'