sprout 0.7.246 → 1.0.0.pre

data/lib/sprout/generators/tool/templates/tool.rb

@@ -0,0 +1,38 @@
+require 'sprout'
+
+class <%= input.camel_case %> 
+  NAME = '<%= input.snake_case %>'
+
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
+  end
+
+  Sprout::Specification.new do |s|
+    s.name    = <%= input.camel_case %>::NAME
+    s.version = <%= input.camel_case %>::VERSION::STRING
+
+    # Create an independent remote_file_target for each
+    # platform that must be supported independently.
+    #
+    # If the archive includes support for all platforms (:windows, :osx, :unix)
+    # then set platform = :universal
+    #
+    s.add_remote_file_target do |t|
+      t.platform = :universal
+      t.archive_type = :zip
+      t.url          = "<%= url %>"
+      t.md5          = "<%= md5 %>"
+
+      # List all executables with their relative path within the
+      # unpacked archive here:
+      t.add_executable :<%= exe %>, "bin/<%= exe %>"
+    end
+
+  end
+end
+
+

data/lib/sprout/generators/tool/tool_generator.rb

@@ -0,0 +1,36 @@
+
+module Sprout
+  class ToolGenerator < Generator::Base
+
+    add_param :author, String, { :default => 'Unknown' }
+    
+    add_param :description, String, { :default => 'This is an unconfigured Sprout Tool' }
+
+    add_param :email, String, { :default => 'projectsprout@googlegroups.com' }
+
+    add_param :exe, String, { :default => 'executable_name' }
+
+    add_param :homepage, String, { :default => 'http://projectsprouts.org' }
+
+    add_param :md5, String, { :default => 'd6939117f1df58e216f365a12fec64f9' }
+
+    add_param :summary, String, { :default => 'Sprout Tool' }
+    
+    add_param :url, String, { :default => 'http://github.com/downloads/lukebayes/project-sprouts/echochamber-test.zip' }
+
+    def manifest
+      directory snake_input do
+        template 'Gemfile'
+        template "#{snake_input}.gemspec", 'tool.gemspec'
+        template "#{snake_input}.rb", 'tool.rb'
+      end
+    end
+
+    protected
+
+    def snake_input
+      input.snake_case
+    end
+  end
+end
+

data/lib/sprout/library.rb

@@ -0,0 +1,111 @@
+
+module Sprout
+  module Library
+    TASK_NAME = :resolve_sprout_libraries
+
+    include RubyFeature
+
+    class << self
+
+      ##
+      # Set the path within a project
+      # where libraries should be loaded.
+      def project_path=(path)
+        @project_path = path
+      end
+
+      ##
+      # The path within a project where 
+      # libraries should be added.
+      #
+      # Defaults to 'lib'
+      def project_path
+        @project_path ||= 'lib'
+      end
+
+      ##
+      # Create Rake tasks that will load and install
+      # a particular library.
+      def define_task pkg_name, type=nil, version=nil
+        library = Sprout::Library.load type, pkg_name, version
+        library.installation_task = task pkg_name
+
+        define_lib_dir_task_if_necessary
+        path_or_paths = library.path
+        if path_or_paths.is_a?(Array)
+          # TODO: Need to add support for merging these directories
+          # rather than simply clobbering...
+          path_or_paths.each { |p| define_path_task pkg_name, library, p }
+        else
+          define_path_task pkg_name, library, path_or_paths
+        end
+        library
+      end
+
+      protected
+
+      def define_lib_dir_task_if_necessary
+        if !File.exists?(project_path)
+          define_file_task project_path do
+            FileUtils.mkdir_p project_path
+            Sprout::Log.puts ">> Created directory at: #{project_path}"
+          end
+        end
+      end
+
+      def define_path_task pkg_name, library, path
+        installation_path = "#{project_path}/#{pkg_name}"
+        if File.directory?(path)
+          define_directory_copy_task path, installation_path
+        else
+          define_file_copy_task path, installation_path
+        end
+      end
+
+      def define_directory_copy_task path, installation_path
+        define_file_task installation_path do
+          FileUtils.cp_r path, installation_path
+          Sprout::Log.puts ">> Copied files from: (#{path}) to: (#{installation_path})"
+        end
+      end
+
+      def define_file_copy_task path, installation_path
+        task_name = "#{installation_path}/#{File.basename(path)}"
+        define_file_task task_name do
+          FileUtils.mkdir_p installation_path
+          FileUtils.cp path, "#{installation_path}/"
+          Sprout::Log.puts ">> Copied file from: (#{path}) to: (#{task_name})"
+        end
+      end
+
+      def define_file_task name
+        file name do |t|
+          yield if block_given?
+        end
+        task Sprout::Library::TASK_NAME => name
+      end
+
+    end
+
+  end
+end
+
+# From within a Rakefile, you can load libraries
+# by calling this shortcut:
+#
+#   library :asunit4
+#
+# Or, if you would like to specify which registered
+# library to pull from the identified package:
+#
+#   library :asunit4, :src
+#
+# Or, if you'd like to specify version requirements:
+#
+#   library :asunit4, :swc, '>= 4.2.pre'
+#
+def library pkg_name, type=nil, version=nil
+  puts ">> Library loaded!"
+  Sprout::Library.define_task pkg_name, type, version
+end
+

data/lib/sprout/log.rb

@@ -44,3 +44,4 @@ module Sprout #:nodoc:
     end
   end
 end
+

data/lib/sprout/platform.rb

@@ -0,0 +1,71 @@
+
+module Sprout
+
+  ##
+  # Determine what environment we're in so that we
+  # can play nice with libraries, processes, executables, etc.
+  #
+  class Platform
+
+    ##
+    # Returns +true+ if the current platform is some flavor of Windows.
+    #
+    def windows?
+      (/cygwin|mswin|mingw|bccwin|wince|emx|vista/ =~ ruby_platform) != nil
+    end
+
+    ##
+    # Returns +true+ if the current platform is Vista.
+    #
+    def vista?
+      (/vista/ =~ ruby_platform) != nil
+    end
+
+    ##
+    # Returns +true+ if the current platform is some flavor of Unix on
+    # Windows. Recognized nix-ish systems are: Cygwin, Mingw and BCCWin.
+    #
+    def windows_nix?
+      (/cygwin|mingw|bccwin/ =~ ruby_platform) != nil
+    end
+
+    ##
+    # Returns +true+ if the current platform is some flash of OS X.
+    #
+    def mac?
+      (/darwin/ =~ ruby_platform) != nil
+    end
+
+    ##
+    # Returns +true+ if the current platform is not +windows?+ or +java?+.
+    #
+    def unix?
+      not windows? and not java?
+    end
+
+    ##
+    # Returns +true+ if the current platform is +unix?+ and not +mac?+.
+    #
+    def linux?
+      unix? and not mac?
+    end
+
+    ##
+    # Returns +true+ if the current platform is running in the JVM (JRuby).
+    #
+    def java?
+      (/java/ =~ ruby_platform) != nil
+    end
+
+    ##
+    # Instance wrapper for the global Ruby Constant, +RUBY_PLATFORM+.
+    #
+    # wrapping this global allows for much easier testing and environment simulation.
+    #
+    def ruby_platform
+      RUBY_PLATFORM
+    end
+
+  end
+end
+

data/lib/sprout/process_runner.rb

@@ -1,55 +1,42 @@
 
 module Sprout #:nodoc:
-  class ProcessRunnerError < StandardError # :nodoc:
-  end
-  
-  class ProcessRunner #:nodoc:
+
+  # The ProcessRunner is a cross-platform wrapper for executing
+  # external executable processes.
+  #
+  # As it turns out, Ruby handle differences very well, and 
+  # other process libraries (like win32-open3 and open4.popen4),
+  # do make the experience more consistent on a given platform,
+  # but they don't hide the differences introduced by the 
+  # continuing beligerence of Windows or *nix (depending on 
+  # which side of the fence you're on).
+  class ProcessRunner
     attr_reader :pid,
                 :r,
                 :w,
                 :e
     
-    def initialize(*command)
-      @command = command
-      begin
-        @alive = true
-        usr = User.new()
-        if(usr.is_a?(WinUser) && !usr.is_a?(CygwinUser))
-          gem 'win32-open3'
-          require 'win32/open3'
-          Open3.popen3(*@command) do |w, r, e, pid|
-          	@w = w
-          	@r = r
-          	@e = e
-          	@pid = pid
-          end
-        else
-          require 'open4'
-          @pid, @w, @r, @e = open4.popen4(*@command)
-        end
-      rescue Errno::EACCES => e
-        update_executable_mode(*@command)
-        @pid, @w, @r, @e = open4.popen4(*@command)
-      rescue Errno::ENOENT => e
-        @alive = false
-        part = command[0].split(' ').shift
-        raise ProcessRunnerError.new("The expected executable was not found for command [#{part}], please check your system path and/or sprout definition")
+    # Execute the provided command using the open4.popen4
+    # library. This is generally only used by Cygwin and
+    # *nix variants (including OS X).
+    def execute_open4 *command
+      execute_with_block *command do
+        # Not sure about the join - with the 1.0 push, we're
+        # sending in 2 args - the exe path, and options as a string.
+        # This was new and was causing problems...
+        @pid, @w, @r, @e = open4_popen4_block *command.join(' ')
       end
     end
     
-    def update_executable_mode(*command)
-      parts = command.join(' ').split(' ')
-      str = parts.shift
-      while(parts.size > 0)
-        if(File.exists?(str))
-          FileUtils.chmod(744, str)
-          return
-        else
-          str << " #{parts.shift}"
-        end
+    # Execute the provided command using the win32-open3
+    # library. This is generally used even by 64-bit
+    # Windows installations.
+    def execute_win32(*command)
+      execute_with_block *command do
+        @pid, @w, @r, @e = io_popen_block *command.join(' ')
       end
     end
-    
+
     def alive?
       @alive = update_status
     end
@@ -107,5 +94,58 @@ module Sprout #:nodoc:
     def read_err
       return @e.read
     end
+
+    private
+
+    def open4_popen4_block *command
+      require 'open4'
+      open4.popen4(*command)
+    end
+
+    def io_popen_block *command
+      if(RUBY_VERSION == '1.8.6' || RUBY_VERSION == '1.8.7')
+        win32_open3_block *command
+      else
+        require 'open3'
+        write, read, error, wait_thread = Open3.popen3(*command)
+        [wait_thread[:pid], write, read, error]
+      end
+    end
+
+    def win32_open3_block *command
+      write, read, error, pid = nil
+      gem 'win32-open3', '0.2.5'
+      require 'win32/open3'
+      Open3.popen3(*command) do |w, r, e, p|
+            pid   = p
+            write = w
+            read  = r
+            error = e
+      end
+      [pid, write, read, error]
+    end
+
+    def execute_with_block *command
+      begin
+        @alive = true
+        yield 
+      rescue Errno::EACCES => eacces
+        update_executable_mode(*command)
+        yield
+      rescue Errno::ENOENT => enoent
+        @alive = false
+        part = command[0]
+        raise Sprout::Errors::ProcessRunnerError.new("The expected executable was not found for command [#{part}], please check your system path and/or sprout definition")
+      end
+    end
+
+    def update_executable_mode(*command)
+      str = command.shift
+      if(File.exists?(str))
+        FileUtils.chmod(0744, str)
+      end
+    end
+    
   end
 end
+

data/lib/sprout/progress_bar.rb

@@ -0,0 +1,341 @@
+# 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, and to silence output
+# during test runs.
+require 'singleton'
+
+module Sprout
+  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
+
+  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
+end
+