sprout 0.7.219-i686-darwin10

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'

data/lib/sprout/generator.rb

@@ -0,0 +1,7 @@
+# gem 'activesupport', '>= 2.0.2'
+gem 'rubigen'
+require 'rubigen'
+require 'sprout/generator/base_mixins'
+require 'sprout/generator/named_base'
+
+# This is the entry point for sprout generator features

data/lib/sprout/generator/base_mixins.rb

@@ -0,0 +1,186 @@
+
+class Gem::SourceIndex
+  
+  # This feature seems to be getting deprecated from the latest
+  # gems releases (1.3.x). 
+  # We actually need it and don't want the nagging - so,
+  # copied sources from RubyGems SVN trunk, and mixing in...
+  # :-(
+  # There should be a more stable integration point with RubyGems
+  # Any ideas or contributions are welcome!
+  def sprout_search(gem_pattern, platform_only = false)
+    version_requirement = nil
+    only_platform = false
+
+    # unless Gem::Dependency === gem_pattern
+    #   warn "#{Gem.location_of_caller.join ':'}:Warning: Gem::SourceIndex#search support for #{gem_pattern.class} patterns is deprecated"
+    # end
+
+    case gem_pattern
+    when Regexp then
+      version_requirement = platform_only || Gem::Requirement.default
+    when Gem::Dependency then
+      only_platform = platform_only
+      version_requirement = gem_pattern.version_requirements
+      gem_pattern = if Regexp === gem_pattern.name then
+                      gem_pattern.name
+                    elsif gem_pattern.name.empty? then
+                      //
+                    else
+                      /^#{Regexp.escape gem_pattern.name}$/
+                    end
+    else
+      version_requirement = platform_only || Gem::Requirement.default
+      gem_pattern = /#{gem_pattern}/i
+    end
+
+    unless Gem::Requirement === version_requirement then
+      version_requirement = Gem::Requirement.create version_requirement
+    end
+
+    specs = @gems.values.select do |spec|
+      spec.name =~ gem_pattern and
+        version_requirement.satisfied_by? spec.version
+    end
+
+    if only_platform then
+      specs = specs.select do |spec|
+        Gem::Platform.match spec.platform
+      end
+    end
+    
+    begin
+      specs.sort_by { |s| s.sort_obj }
+    rescue NoMethodError => e
+      puts "It looks like your RubyGems installation is not compatible with this version of Sprouts.\n\nTo update, run:\ngem update --system\n\n"
+      raise e
+    end
+  end
+end
+
+module RubiGen # :nodoc:[all]
+
+  class Base # :nodoc:[all]
+
+    def initialize(runtime_args, runtime_options = {})
+      @args = runtime_args
+      parse!(@args, runtime_options)
+
+      # Derive source and destination paths.
+      @source_root = options[:source] || File.join(spec.path, 'templates')
+      
+      if options[:destination]
+        @destination_root = options[:destination]
+      elsif defined? Sprout::Sprout.project_path
+        @destination_root = Sprout::Sprout.project_path
+      else
+        @destination_root = Dir.pwd
+      end
+
+      # Silence the logger if requested.
+      logger.quiet = options[:quiet]
+
+      # Raise usage error if help is requested.
+      usage if options[:help]
+    end
+
+  end
+
+  # GemGeneratorSource hits the mines to quarry for generators.  The latest versions
+  # of gems named sprout-#{sprout_name}-bundle are selected.
+  class GemGeneratorSource < AbstractGemSource # :nodoc:[all]
+    
+    def initialize(name=nil)
+      super()
+      @sprout_name = name
+    end
+
+    # Yield latest versions of generator gems.
+    def each
+      Gem::cache.sprout_search(/sprout-*#{@sprout_name}-bundle$/).inject({}) do |latest, gem|
+        hem = latest[gem.name]
+        latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+        latest
+      end.values.each do |gem|
+        yield Spec.new(gem.name.sub(/sprout-*#{@sprout_name}-bundle$/, ''), gem.full_gem_path, label)
+      end
+    end
+
+    def each_sprout
+      Gem::cache.sprout_search(/^sprout-.*/).inject({}) do |latest, gem|
+        hem = latest[gem.name]
+        latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+        latest
+      end.values.each do |gem|
+        yield Spec.new(gem.name, gem.full_gem_path, label)
+      end
+    end
+  end
+
+  # GemPathSource looks for generators within any RubyGem's 
+  # /sprout/generators/<generator_name>/<generator_name>_generator.rb file.
+  # It will only include generators from sprouts whose name includes
+  # #{sprout_name}-bundle
+  class GemPathSource < AbstractGemSource # :nodoc:[all]
+    
+    def initialize(name=nil)
+      super()
+      @sprout_name = name
+    end
+
+    # Yield each generator within generator subdirectories.
+    def each
+      generator_full_paths.each do |generator|
+        yield Spec.new(File.basename(generator).sub(/_generator.rb$/, ''), File.dirname(generator), label)
+      end
+    end
+
+    private
+      def generator_full_paths
+        @generator_full_paths ||=
+          Gem::cache.inject({}) do |latest, name_gem|
+            name, gem = name_gem
+            hem = latest[gem.name]
+            latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+            latest
+          end.values.inject([]) do |mem, gem|
+            Dir[gem.full_gem_path + '/lib/sprout/**/generators/**/*_generator.rb'].each do |generator|
+              if(@sprout_name && gem.name.match(/sprout-#{@sprout_name}-bundle/))
+                mem << generator
+              end
+            end
+            mem
+          end
+      end
+  end
+
+  module Lookup # :nodoc:[all]
+    module ClassMethods # :nodoc:[all]
+      
+      def use_sprout_sources!(sprout_name, project_path=nil)
+        reset_sources
+
+        # Project-specific generator paths
+        if project_path
+          sources << PathSource.new(:project, "#{project_path}/generators")
+          sources << PathSource.new(:script, "#{project_path}/script/generators")
+          sources << PathSource.new(:vendor, "#{project_path}/vendor/generators")
+        end
+
+        # System-wide generator paths
+        system_path = "#{Sprout::Sprout.sprout_cache}/generators/#{sprout_name}"
+        if(File.exists?(system_path))
+          sources << PathSource.new(:system, system_path)
+        end
+
+        # Gem generators will collect all
+        # rubygems that end with -bundle or -generators
+        if(Object.const_defined?(:Gem))
+          sources << GemGeneratorSource.new(sprout_name)
+          sources << GemPathSource.new(sprout_name)
+        end
+      end
+    end
+  end
+
+end