sprout 0.7.153-x86-linux

data/lib/sprout/process_runner.rb

@@ -0,0 +1,46 @@
+
+module Sprout #:nodoc:
+  class ProcessRunnerError < StandardError # :nodoc:
+  end
+  
+  class ProcessRunner #:nodoc:
+    attr_reader :pid,
+                :r,
+                :w,
+                :e
+    
+    def initialize(*command)
+      @command = command
+      begin
+        usr = User.new()
+        if(usr.is_a?(WinUser) && !usr.is_a?(CygwinUser))
+          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::ENOENT => e
+        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")
+      end
+    end
+    
+    def puts(msg)
+      @w.puts(msg)
+    end
+
+    def read
+      return r.read
+    end
+    
+    def read_err
+      return e.read
+    end
+  end
+end

data/lib/sprout/project_model.rb

@@ -0,0 +1,114 @@
+
+module Sprout
+  
+  # The ProjectModel gives you a place to describe your project so that you
+  # don't need to repeat yourself throughout a rakefile.
+  #
+  # The default set of properties are also used from code generators, library tasks and sometimes tools.
+  #
+  # This class should have some reasonable default values, but can be modified from any rakefile.
+  # If you don't find some properties that you'd like on the ProjectModel, you can simply add 
+  # new properties and use them however you wish!
+  class ProjectModel < Hash
+  
+    # The real name of the project, usually capitalized like a class name 'SomeProject'
+    attr_accessor :project_name
+    # The relative path to your main source directory. Defaults to 'src'
+    attr_accessor :src_dir
+    # The relative path to your library directory. Defaults to 'lib'
+    #
+    # Any remote .SWC and source libraries that are referenced in your rakefile will be installed
+    # into this directory. Source libraries will be placed in a folder that matches the library name,
+    # while SWCs will be simply placed directly into the lib_dir.
+    attr_accessor :lib_dir
+    # The folder where binary files will be created. Usually this is where any build artifacts like SWF files get placed.
+    attr_accessor :bin_dir
+    # Relative path to the folder that contains your test cases
+    attr_accessor :test_dir
+    # Relative path to the folder where compile time assets will be stored
+    attr_accessor :asset_dir
+    # The folder where compile time skins can be loaded from
+    attr_accessor :skin_dir
+    # The technology language that is being used, right now this is either 'as2' or 'as3'.
+    # Code generators take advantage of this setting to determine which templates to use.
+    attr_accessor :language
+
+    # TODO: Add clean hash interface so that users
+    # can simply add to this object's properties like:
+    # model.foo = 'bar'
+    # model.junk = true
+    # and then just as easily reference those vars from
+    # external generators...  
+    def self.instance
+      @@instance ||= ProjectModel.new
+    end
+    
+    def self.destroy # :nodoc:
+      @@instance = nil
+    end
+  
+    def initialize
+      super
+      @project_name   = ''
+      @src_dir        = 'src'
+      @lib_dir        = 'lib'
+      @bin_dir        = 'bin'
+      @test_dir       = 'test'
+      @asset_dir      = 'assets'
+      @skin_dir       = File.join(@asset_dir, 'skins')
+
+      @language       = 'as3'
+
+      @model_dir      = nil
+      @view_dir       = nil
+      @controller_dir = nil
+    end
+    
+    # Path to the project directory from which all other paths are created
+    def project_path
+      return Sprout.project_path
+    end
+    
+    def model_dir=(dir)
+      @model_dir = dir
+    end
+
+    # Simple MVC helper for project-wide models if your project is called 'SomeProject'
+    # this will default to:
+    #   SomeProject/src/someproject/models
+    def model_dir
+      if(@model_dir.nil?)
+        @model_dir = File.join(src_dir, project_name.downcase, 'models')
+      end
+      return @model_dir
+    end
+    
+    def view_dir=(dir)
+      @view_dir = dir
+    end
+
+    # Simple MVC helper for project-wide views if your project is called 'SomeProject'
+    # this will default to:
+    #   SomeProject/src/someproject/views
+    def view_dir
+      if(@view_dir.nil?)
+        @view_dir = File.join(src_dir, project_name.downcase, 'views')
+      end
+      return @view_dir
+    end
+    
+    def controller_dir=(dir)
+      @controller_dir = dir
+    end
+
+    # Simple MVC helper for project-wide views if your project is called 'SomeProject'
+    # this will default to:
+    #   SomeProject/src/someproject/controllers
+    def controller_dir
+      if(@controller_dir.nil?)
+        @controller_dir = File.join(src_dir, project_name.downcase, 'controllers')
+      end
+      return @controller_dir
+    end
+  end
+end

data/lib/sprout/remote_file_loader.rb

@@ -0,0 +1,233 @@
+
+module Sprout
+  class RemoteFileLoaderError < StandardError #:nodoc:
+  end
+  
+  class RemoteFileLoader #:nodoc:
+    include Archive::Tar
+    
+    def get_remote_file(uri, target, force=false, md5=nil)
+      if(force || !File.exists?(target))
+        response = fetch(uri.to_s)
+        if(response_is_valid?(response, md5))
+          write(response, target, force)
+        end
+      end
+    end
+    
+    def response_is_valid?(response, expected_md5sum=nil)
+      if(expected_md5sum)
+        md5 = Digest::MD5.new
+        md5 << response
+        raise BadCheckSum if (expected_md5sum != md5.hexdigest)
+      end
+      return true
+    end
+    
+    def write(response, target, force=false)
+      FileUtils.makedirs(File.dirname(target))
+      if(force && File.exists?(target))
+        File.delete(target)
+      end
+      File.open(target, 'wb') do |f|
+        f.write(response)
+      end
+    end
+    
+    def fetch(uri)
+      uri = URI.parse(uri)
+      # Download the file now to the downloads dir
+      # If the file is an archive (zip, gz, tar, tar.gz, dmg), extract to
+      # Sprouts/cache/@type/@name
+      # Check the location again...
+      progress = nil
+      response = nil
+      name = uri.path.split("/").pop
+      
+      raise RemoteFileLoaderError.new("The RemoteFileTask failed for #{name}. We can only handle HTTP requests at this time, it seems you were trying: '#{uri.scheme}'") if uri.scheme != 'http'
+      begin
+        open(uri.to_s, :content_length_proc => lambda {|t|
+          if t && t > 0
+            progress = ProgressBar.new(name, t)
+            progress.file_transfer_mode
+            progress.set(0)
+          else
+            progress = ProgressBar.new(name, 0)
+            progress.file_transfer_mode
+            progress.set(0)
+          end
+        },
+        :progress_proc => lambda {|s|
+          progress.set s if progress
+        }) {|f|
+          response = f.read
+          progress.finish
+        }
+      rescue SocketError => e
+        raise RemoteFileLoaderError.new("[ERROR] #{e.to_s}")
+      rescue OpenURI::HTTPError => e
+        raise RemoteFileLoaderError.new("[ERROR] Failed to load file from: '#{uri.to_s}'\n[REMOTE ERROR] #{e.io.read.strip}")
+      rescue Errno::ECONNREFUSED => e
+        raise Errno::ECONNREFUSED.new("[ERROR] Connection refused at: '#{uri.to_s}'")
+      end
+
+      return response
+    end
+    
+    def unpack_downloaded_file(file_name, dir)
+      if(!File.exists?(dir))
+        if(is_zip?(file_name))
+          unpack_zip(file_name, dir)
+        elsif(is_targz?(file_name))
+          unpack_targz(file_name, dir)
+        elsif(is_dmg?(file_name))
+          unpack_dmg(file_name, dir)
+        elsif(is_swc?(file_name))
+          # just copy the swc...
+        elsif(is_rb?(file_name))
+          return
+        elsif(is_exe?(file_name))
+          FileUtils.mkdir_p(dir)
+          File.mv(file_name, dir)
+        else
+          raise UsageError.new("RemoteFileTask does not know how to unpack files of type: #{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...
+              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
+            end
+          end
+        rescue StandardError => e
+          if(retries < 3)
+            puts ">> [ZIP ERROR ENCOUNTERED] trying again with: #{dir}"
+            FileUtils.rm_rf(dir)
+            FileUtils.makedirs(dir)
+            retry
+          end
+          raise e
+        end
+      end
+    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 it's 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
+        if(File.exists?(full_mounted_path))
+          system("hdiutil unmount -force \"#{full_mounted_path}\"")
+        end
+      end
+    end
+    
+    def is_exe?(file)
+      return (file.split('.').pop == 'exe')
+    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
+  end
+end

data/lib/sprout/remote_file_target.rb

@@ -0,0 +1,96 @@
+
+module Sprout
+  class RemoteFileTargetError < StandardError #:nodoc:
+  end
+
+  class RemoteFileTarget # :nodoc:
+
+    attr_writer   :archive_path
+    
+    # The user path where this gem will download and install files
+    # This value is set by the Sprout::Builder that creates this RemoteFileTarget
+    attr_accessor :install_path
+
+    # Optional md5 hash, usually set in the sprout.spec for each RemoteFileTarget
+    # If this value is set, the downloaded archive will be hashed, the hashes will
+    # be compared and if they differ, the installation process will break.
+    attr_accessor :md5
+
+    # Used for dmg archives. Absolute path to the mounted dmg (essentially it's name)
+    attr_accessor :mount_path
+
+    # Which platform will this RemoteFileTarget support.
+    # Supported options are:
+    #  * universal
+    #  * macosx
+    #  * win32
+    #  * linux
+    attr_accessor :platform
+
+    # URL where Sprouts can go to download the RemoteFileTarget archive
+    attr_accessor :url
+
+    # Relative path within the archive to the executable or binary of interest
+    def archive_path
+      @archive_path ||= ''
+    end
+
+    # Resolve this RemoteFileTarget now. This method is called by the Sprout::Builder
+    # and will download, install and unpack the described archive
+    def resolve(update=false)
+      if(url)
+        @loader = RemoteFileLoader.new
+        if(url && (update || !File.exists?(downloaded_path)))
+          download(url, downloaded_path, update)
+        end
+
+        if(!File.exists?(installed_path) || !File.exists?(File.join(installed_path, archive_path) ))
+          archive_root = File.join(install_path, 'archive')
+          install(downloaded_path, archive_root)
+        end
+      end
+    end
+    
+    # Return the basename of the executable that this RemoteFileTarget refers to
+    def executable
+      return File.basename(archive_path)
+    end
+    
+    # The root path to the unpacked archive files. This is the base path that will be added to any
+    # +archive_path+ relative paths
+    def installed_path
+      @installed_path ||= File.join(install_path, 'archive')
+      return @installed_path
+    end
+    
+    # Parent directory where archives are downloaded
+    # can be something like: ~/Library/Sprouts/cache/0.7/sprout-somesprout-tool.x.x.x/
+    def downloaded_path
+      @downloaded_path ||= File.join(install_path, file_name)
+      return @downloaded_path
+    end
+    
+    # Base file name represented by the provided +url+
+    # Will strip off any ? arguments and trailing slashes. May not play nice with Rails URLS,
+    # We expect archive file name suffixes like, zip, gzip, tar.gz, dmg, etc.
+    def file_name
+      if(url.split('').last == '/')
+        return name
+      end
+      file = url.split('/').pop
+      file = file.split('?').shift
+      return file
+    end
+    
+    private
+    def download(url, path, update=false)
+      @loader = RemoteFileLoader.new
+      @loader.get_remote_file(url, path, update, md5)
+    end
+    
+    def install(from, to)
+      @loader.unpack_downloaded_file(from, to)
+    end
+    
+  end
+end