asproject 0.1.44 → 0.1.60

data/bin/asclass

@@ -12,6 +12,7 @@ if ARGV.size > 0 && ARGV[0][0]==95 && ARGV[0][-1]==95
 end
 
 require_gem 'asproject', version
+require 'asproject.rb'
 require 'asclass.rb'
 
 AsProject::AsClass.new

data/lib/asclass.rb

@@ -1,7 +1,5 @@
 $:.push(File.dirname(__FILE__))
 
-require 'asproject'
-
 module AsProject
   class AsClass < AsProjectBase
     @@TEMPLATE_TYPE               = 'asclass'

data/lib/asproject.rb

@@ -39,6 +39,7 @@ require 'tasks/swfmill_input'
 require 'tasks/swfmill'
 
 module AsProject
+
   class AsProject < AsProjectBase
     @@ASPROJECT_FILE_NAME               = 'AsProject'
     @@TEMPLATE_TYPE                     = 'asproject'
@@ -266,4 +267,40 @@ EOF
       return @context.project_path
     end
   end
+
+  class Logger
+    @@output = ''
+    @@debug = false
+    
+    def Logger.debug=(debug)
+      @@debug = debug
+    end
+    
+    def Logger.debug
+      return @@debug
+    end
+
+    def Logger.puts(line)
+      if(!Logger.debug)
+        $stdout.puts line
+      else
+        @@output << "#{line}\n"
+      end
+    end
+    
+    def Logger.printf(msg)
+      if(!Logger.debug)
+        $stdout.puts msg
+      else
+        @@output << msg
+      end
+    end
+    
+    def Logger.flush
+      if(!Logger.debug)
+        $stdout.puts @@output
+      end
+      @@output = ''
+    end
+  end
 end

data/lib/asproject/version.rb

@@ -2,7 +2,7 @@ module AsProject
   module VERSION
     MAJOR = 0
     MINOR = 1
-    TINY  = 44
+    TINY  = 61
         
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/tasks/flash_player.rb

@@ -1,11 +1,4 @@
 
-# Pull in the project-local config file
-# if it exists...
-if(File.exists?('script/asclass_config.rb'))
-#  require 'script/asclass_config'
-#  include Config
-end
-
 module AsProject
   class FlashPlayerError < StandardError; end
   
@@ -38,8 +31,8 @@ module AsProject
         @win_url = "http://download.macromedia.com/pub/flashplayer/updaters/8/flash_player_update3_flash8_win.zip"
         @win_extracted_file = "/Players/Debug/SAFlashPlayer.exe"
         @osx_url = "http://download.macromedia.com/pub/flashplayer/updaters/8/sa_flashplayer_8_all_debug.dmg"
-        @osx_mounted_path = "/Volumes/Adobe Flash Standalone Players"
-        @osx_extracted_file = "/en/SAFlashPlayer"
+        @osx_mounted_path = "Adobe Flash Standalone Players"
+        @osx_extracted_file = "en/SAFlashPlayer"
         @unix_url = nil
         @unix_extracted_file = nil
       elsif(version == 9)
@@ -70,15 +63,36 @@ module AsProject
         rescue
           puts 'Warning, was unable to update the FlashPlayerTrust file'
         end
-
-        index = 0
+        
         File.open(log_file, 'w') do |f|
           f.write('')
         end
 
+        thread = nil
+        if(Logger.debug)
+          thread = ThreadMock.new
+        elsif(@user_task.is_a?(OSXRemoteFileTask) && !Logger.debug)
+          thread = run_osx
+        else
+          thread = run_other
+        end
+
+        read_log(thread, log_file)
+      end
+      
+      def run_osx
+        system(%{open -a #{extracted_file_path} ./#{@swf}})
+        return OSXPlayerThread.new
+      end
+      
+      def run_other
         player_thread = Thread.new {
           execute("./#{@swf}")
         }
+      end
+      
+      def read_log(player_thread, log_file)
+        index = 0
 
         if(!File.exists?(log_file))
           raise UsageError.new('Unable to find the trace output log file in the expected location: ' + log_file)
@@ -88,16 +102,29 @@ module AsProject
           sleep(0.2)
           incr = 0
           
-          File.open(log_file, "r").readlines.each do |line|
-            incr = incr + 1
-            if(incr > index)
-              puts "[trace] #{line}"
-              index = index + 1
+          File.open(log_file, 'r') do |file|
+            file.readlines.each do |line|
+              incr = incr + 1
+              if(incr > index)
+                puts "[trace] #{line}"
+                index = index + 1
+              end
             end
           end
         end
       end
     end
   end
-end
 
+  class ThreadMock
+    def alive?
+      return false
+    end
+  end
+  
+  class OSXPlayerThread
+    def alive?
+      return true
+    end
+  end
+end

data/lib/tasks/flash_player_trust.rb

@@ -17,7 +17,7 @@ module AsProject
         File.open(trust_file, 'a') do |f|
           f.puts path
         end
-        puts ">> Added #{path} to Flash Player Trust file at: #{trust_file}"
+        Logger.puts ">> Added #{path} to Flash Player Trust file at: #{trust_file}"
       end
     end
     

data/lib/tasks/mtasc.rb

@@ -5,22 +5,33 @@ module AsProject
   class MTASC < RemoteFileTask
   
     attr_accessor :name,
-                  :version,
                   :compiler_version,
-                  :main,
-                  :header,
+                  :cp,
+                  :exclude,
                   :frame,
-                  :verbose,
+                  :group,
+                  :header,
+                  :infer,
+                  :keep,
+                  :main,
+                  :msvc,
                   :mx,
-                  :input,
-                  :input_swf,
-                  :class_path,
-                  :output
+                  :out,
+                  :pack,
+                  :strict,
+                  :swf,
+                  :trace,
+                  :verbose,
+                  :version,
+                  :wimp,
+                  :input
 
     def initialize(name=:compile, do_not_define=false)
       @compiler_version = '1.13'
       @options = []
-      @class_path = []
+      @cp = []
+      @pack = []
+
       @user_task = nil
       @win_url = "http://www.mtasc.org/zip/mtasc-#{compiler_version}.zip"
       @win_extracted_file = "/mtasc-#{compiler_version}/mtasc.exe"
@@ -43,27 +54,32 @@ module AsProject
     # Create the tasks defined by this task lib.
     def define
       super
-#      if(!input_swf && !header && pack_path.size == 0) 
-#        raise MTASCError.new('MTASC task must be provided with an input_swf, a header argument, or at least one pack_path')
+#      if(!swf && !header && pack_path.size == 0) 
+#        raise MTASCError.new('MTASC task must be provided with an swf, a header argument, or at least one pack_path')
 #      end
-#      if(header && !input_swf && output)
-#        raise MTASCError.new('It looks like you used the output parameter where you should have used the swf parameter')
+#      if(header && !swf && out)
+#        raise MTASCError.new('It looks like you used the out parameter where you should have used the swf parameter')
 #      end
+
       desc compile_task_desc
-      task name => [output]
-      CLEAN.add(output)
+      task name => [out]
+      CLEAN.add(out)
 
-      if(input_swf)
-        file input_swf
-        task name => [input_swf]
+      if(swf)
+        file swf
+        task name => [swf]
       end
        
       @cleaned_class_paths = []
-      class_path.each do |path|
+      cp.each do |path|
         add_path(path, @cleaned_class_paths)
       end
       
-      file output do |f|
+      file out do |f|
+#        if(input && !File.exists?(input))
+#          raise MTASCError.new('MTASC.input must be an existing file')
+#        end
+
         user_task.execute(option_list.join(' '))
       end
 
@@ -83,10 +99,10 @@ module AsProject
     def add_path(path, list)
       as_files = FileList[path + '/**/**/*.as']
       file as_files
-      file output => as_files
+      file out => as_files
       xml_files = FileList[path + '/**/**/*.xml']
       file xml_files
-      file output => xml_files
+      file out => xml_files
       
       list << clean_path(path)
     end
@@ -94,13 +110,23 @@ module AsProject
     def option_list
       result = @options.dup
       result << "-header" << header if header
-      result << "-mx" if mx
-      result << "-v" if verbose
+      result << "-cp " + @cleaned_class_paths.join(" -cp ") if cp.size > 0
+      result << "-exclude" << exclude if exclude
       result << "-frame" << frame if frame
-      result << "-cp " + @cleaned_class_paths.join(" -cp ") if class_path.size > 0
-      result << "-swf" << clean_path(input_swf) if input_swf
-      result << "-out" << clean_path(output) if output
+      result << "-group" if group
+      result << "-infer" if infer
+      result << "-keep" if keep
       result << "-main" if main
+      result << "-msvc" if msvc
+      result << "-strict" if strict
+      result << "-mx" if mx
+      result << "-trace" << trace if trace
+      result << "-v" if verbose
+      result << "-version" << version if version
+      result << "-wimp" if wimp
+      result << "-pack " + pack.join(" -pack ") if pack.size > 0
+      result << "-swf" << clean_path(swf) if swf
+      result << "-out" << clean_path(out) if out
       result << clean_path(input) if input
       return result
     end

data/lib/tasks/remote_file_task.rb

@@ -1,298 +1,338 @@
-
-# Tell Rake NOT to remove directory(ies) named 'core'
-CLEAN.exclude("core")
-
-module AsProject
-  # The RemoteFileTask was created to resolve
-  # external tool dependencies for relatively stable
-  # tools like mtasc, swfmill and mxmlc
-  # The intention is that common tools will have
-  # RemoteFileTasks deployed with AsProject and will 
-  # include mac/win/unix targets so that users on
-  # each platform will seamlessly download and 
-  # target these tools.
-  class RemoteFileTask < Rake::TaskLib
-
-    attr_accessor :name,
-                  :user_task,
-                  :remote_task_name,
-                  :win_url,
-                  :osx_url,
-                  :unix_url,
-                  :win_extracted_file,
-                  :osx_extracted_file,
-                  :unix_extracted_file,
-                  :osx_mounted_path
-
-    def initialize(name=:remote_file_task, do_not_define=false)
-      @name = name
-      @user_task = nil
-      @remote_task_name = name.to_s
-      yield self if block_given?
-      define unless do_not_define
-    end
-    
-    def define
-      define_user_task
-      self
-    end
-    
-    def user
-      return @user
-    end
-
-    def define_user_task
-      if(@user_task.nil?)
-        if(remote_task_name.nil?)
-          raise UsageError.new('RemoteFileTask created without a remote_task_name value...')
-        end
-        @user = PathFinder.new().user
-        @user_task = @user.remote_file_task(remote_task_name, self)
-        task name => remote_task_name
-      end
-      @user_task
-    end
-    
-    def execute(params)
-      user_task.execute(params)
-    end
-    
-    def clean_path(path)
-      define_user_task
-      return user_task.clean_path(path)
-    end
-  end
-  
-  ###################################
-  # Concrete instances returned from
-  # User objects
-  class AbstractRemoteFileTask
-    include Archive::Tar
-
-    attr_accessor :name,
-                  :url,
-                  :mounted_path,
-                  :extracted_file
-
-    def initialize(name, user)
-      @name = name
-      @user = user
-      yield self if block_given?
-      define
-    end
-    
-    def define
-      @uri = URI.parse(url)
-      downloaded_file = downloaded_file_path
-      file downloaded_file do |f|
-        get_remote_file(@uri, downloaded_file)
-      end
-      
-      if(extracted_file_path != downloaded_file)
-        if(!Rake::Task.task_defined?(extracted_file_path))
-          file extracted_file_path => downloaded_file do |f|
-            unpack_downloaded_file(downloaded_file, extracted_file_path)
-            File.chmod(0755, extracted_file_path)
-          end
-        end
-
-#      else
-#        File.chmod(0755, downloaded_file)
-#        task @name => url
-      end
-
-      task @name => [extracted_file_path]
-    end
-    
-    def extracted_file_path
-      return File.join(@user.downloads, @name.to_s, extracted_file)
-    end
-    
-    def downloaded_file_path
-      parts = @uri.path.split('/')
-      file = parts.pop
-      return File.join(@user.downloads, @name.to_s, file)
-    end
-    
-    def unpack_downloaded_file(file_name, expected_file)
-      dir = File.dirname(file_name)
-      if(!File.exists?(expected_file))
-        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_exe?(file_name))
-          raise UsageError.new("RemoteFileTask does not know how to unpack files of type: #{file_name}")
-        end
-      end
-    end
-    
-    def unpack_zip(zip_file, dir)
-      Zip::ZipFile::open(zip_file) do |zf|
-         zf.each do |e|
-           fpath = File.join(dir, e.name)
-           FileUtils.mkdir_p(File.dirname(fpath))
-           zf.extract(e, fpath)
-         end
-       end
-    end
-    
-    def unpack_targz(tgz_file, dir)
-      tar = Zlib::GzipReader.new(File.open(tgz_file, 'rb'))
-      Minitar.unpack(tar, dir)
-    end
-    
-    # This probably NOT the correct way to do this,
-    # But I don't know much about macs, osx or dmgs
-    # and it seems to work...
-    # IF you know a better way - PLEASE let me know
-    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
-      
-      puts "Creating mounted path task: #{File.exists?(mounted_path)}"
-      if(!File.exists?(mounted_path))
-        system(%{hdiutil mount #{dmg_file}})
-      end
-      resolver = TemplateResolver.new
-      resolver.copy_files(mounted_path, dir, false)
-      File.chmod(0755, extracted_file)
-      system(%{hdiutil unmount #{mounted_path}})
-    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('.')
-      return (parts.pop == 'gz' && parts.pop == 'tar')
-    end
-    
-    def is_gzip?(file)
-      return (file.split('.').pop == 'gz')
-    end
-    
-    def is_dmg?(file)
-      return (file.split('.').pop == 'dmg')
-    end
-    
-    def make_downloaded_dir(file)
-      dir = File.dirname(file)
-      File.makedirs(dir)
-    end
-    
-    def remote_file_dir
-      return File.join(@user.downloads, @name.to_s)
-    end
-    
-    def remote_location
-      return File.join(remote_file_dir, extracted_file)
-    end
-    
-    def fetch(location, limit = 10)
-      uri = URI.parse(location)
-
-      # Download the file now to the downloads dir
-      # If the file is an archive (zip, gz, tar, tar.gz, dmg), extract to
-      # AsProject/remote_files/@name/@location
-      # Check the location again...
-      raise UsageError.new("The RemoteFileTask can only handle HTTP requests at this time, it seems you were trying: #{uri.scheme}") if uri.scheme != 'http'
-      raise UsageError.new('HTTP redirect too deep') if limit == 0
-      
-      response = nil
-      t = Thread.new {
-        response = Net::HTTP.get_response(uri.host, uri.path)
-      }
-      # TODO: Add actual bytesLoaded vs bytesTotal
-      # To the output...
-      while t.alive?
-        print(".")
-        $stdout.flush
-        sleep(0.2)
-      end
-      
-      if(response.is_a? Net::HTTPSuccess)
-        return response
-      elsif(response.is_a? Net::HTTPRedirection)
-        return fetch(response['location'], limit - 1)
-      else
-        puts response.to_s
-        return response.error!
-      end
-    end
-    
-    def get_remote_file(uri, target)
-      if(!File.exists?(target))
-        puts "Fetching #{uri.to_s} now!"
-        response = fetch(uri.to_s)
-  
-        File.makedirs(File.dirname(target))
-        # Store the downloaded file on disk
-        File.open(target, 'wb') do |f|
-          f.write(response.body)
-        end
-  
-        puts ""
-        puts "Downloaded #{(response.body.size / 1024).to_s} KB"
-        puts "to: #{target}"
-        puts ""
-      end
-    end
-
-    def clean_path(path)
-      if(path.index(' '))
-        return %{'#{path}'}
-      end
-      return path
-    end
-    
-    def execute(params)
-      # Execute the system call with params
-      # Sometimes DOS wants a 'run' prefix
-      # Sometimes OSX wants a 'open' prefix
-      # Sometimes Cygwin wants a './' prefix
-      # This method should be overridden in
-      # subclasses
-      sh %{#{clean_path(extracted_file_path)} #{params}}
-     end
-  end
-  
-  class WinRemoteFileTask < AbstractRemoteFileTask
-    
-    def clean_path(path)
-      path = path.split('/').join(File::SEPARATOR)
-      if(path.index(' '))
-        return %{"#{path}"}
-      end
-      return path
-    end
-    
-    def execute(params)
-      sh(%{"#{extracted_file_path}" #{params}})
-    end
-  end
-  
-  class CygwinRemoteFileTask < AbstractRemoteFileTask
-
-    def execute(params)
-      sh %{#{clean_path(extracted_file_path)} #{params}}
-    end
-  end
-  
-  class OSXRemoteFileTask < AbstractRemoteFileTask
-  end
-  
-  class UnixRemoteFileTask < AbstractRemoteFileTask
-  end
+
+# Tell Rake NOT to remove directory(ies) named 'core'
+CLEAN.exclude("core")
+
+module AsProject
+  # The RemoteFileTask was created to resolve
+  # external tool dependencies for relatively stable
+  # tools like mtasc, swfmill and mxmlc
+  # The intention is that common tools will have
+  # RemoteFileTasks deployed with AsProject and will 
+  # include mac/win/unix targets so that users on
+  # each platform will seamlessly download and 
+  # target these tools.
+  class RemoteFileTask < Rake::TaskLib
+
+    attr_accessor :name,
+                  :user_task,
+                  :remote_task_name,
+                  :win_url,
+                  :osx_url,
+                  :unix_url,
+                  :win_extracted_file,
+                  :osx_extracted_file,
+                  :unix_extracted_file,
+                  :osx_mounted_path
+
+    def initialize(name=:remote_file_task, do_not_define=false)
+      @name = name
+      @user_task = nil
+      @remote_task_name = name.to_s
+      yield self if block_given?
+      define unless do_not_define
+    end
+    
+    def define
+      define_user_task
+      self
+    end
+    
+    def user
+      return @user
+    end
+
+    def extracted_file_path
+      return @user_task.extracted_file_path
+    end
+
+    def define_user_task
+      if(@user_task.nil?)
+        if(remote_task_name.nil?)
+          raise UsageError.new('RemoteFileTask created without a remote_task_name value...')
+        end
+        @user = PathFinder.new().user
+        @user_task = @user.remote_file_task(remote_task_name, self)
+        task name => remote_task_name
+      end
+      @user_task
+    end
+    
+    def execute(params)
+      user_task.execute(params)
+    end
+    
+    def clean_path(path)
+      define_user_task
+      return user_task.clean_path(path)
+    end
+  end
+  
+  ###################################
+  # Concrete instances returned from
+  # User objects
+  class AbstractRemoteFileTask
+    include Archive::Tar
+
+    attr_accessor :name,
+                  :url,
+                  :mounted_path,
+                  :extracted_file
+
+    def initialize(name, user)
+      @name = name
+      @user = user
+      yield self if block_given?
+      define
+    end
+    
+    def define
+      @uri = URI.parse(url)
+      downloaded_file = downloaded_file_path
+      file downloaded_file do |f|
+        get_remote_file(@uri, downloaded_file)
+      end
+      
+      if(extracted_file_path != downloaded_file)
+        if(!Rake::Task.task_defined?(extracted_file_path))
+          file extracted_file_path => downloaded_file do |f|
+            unpack_downloaded_file(downloaded_file, extracted_file_path)
+            File.chmod(0755, extracted_file_path)
+          end
+        end
+      end
+
+      task @name => [extracted_file_path]
+    end
+    
+    def extracted_file_path
+      return File.join(@user.downloads, @name.to_s, extracted_file)
+    end
+    
+    def downloaded_file_path
+      parts = @uri.path.split('/')
+      file = parts.pop
+      return File.join(@user.downloads, @name.to_s, file)
+    end
+    
+    def unpack_downloaded_file(file_name, expected_file)
+      dir = File.dirname(file_name)
+      Dir[dir + '/*'].each do |child|
+        if(child != '.' && child != '..' && child != file_name)
+          FileUtils.rm_rf(child)
+        end
+      end
+
+      if(!File.exists?(expected_file))
+        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_exe?(file_name))
+          raise UsageError.new("RemoteFileTask does not know how to unpack files of type: #{file_name}")
+        end
+      end
+    end
+    
+    def unpack_zip(zip_file, dir)
+      Zip::ZipFile::open(zip_file) do |zf|
+         zf.each do |e|
+           fpath = File.join(dir, e.name)
+           FileUtils.mkdir_p(File.dirname(fpath))
+           zf.extract(e, fpath)
+         end
+       end
+    end
+    
+    def unpack_targz(tgz_file, dir)
+      tar = Zlib::GzipReader.new(File.open(tgz_file, 'rb'))
+      Minitar.unpack(tar, dir)
+    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
+      
+      mounted_target = File.join(full_mounted_path, extracted_file)
+
+      # Copy the Singular target out:
+      FileUtils.makedirs(File.dirname(extracted_file_path))
+      FileUtils.copy(mounted_target, extracted_file_path)
+        
+      # Copy the entire DMG out:
+#      resolver = TemplateResolver.new
+#      resolver.replace_all = true
+#      resolver.copy_files(full_mounted_path, dir, false)
+      if(File.exists?(full_mounted_path))
+        system("hdiutil unmount -force \"#{full_mounted_path}\"")
+      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('.')
+      return (parts.pop == 'gz' && parts.pop == 'tar')
+    end
+    
+    def is_gzip?(file)
+      return (file.split('.').pop == 'gz')
+    end
+    
+    def is_dmg?(file)
+      return (file.split('.').pop == 'dmg')
+    end
+    
+    def make_downloaded_dir(file)
+      dir = File.dirname(file)
+      File.makedirs(dir)
+    end
+    
+    def remote_file_dir
+      return File.join(@user.downloads, @name.to_s)
+    end
+    
+    def remote_location
+      return File.join(remote_file_dir, extracted_file)
+    end
+    
+    def fetch(location, limit = 10)
+      uri = URI.parse(location)
+
+      # Download the file now to the downloads dir
+      # If the file is an archive (zip, gz, tar, tar.gz, dmg), extract to
+      # AsProject/remote_files/@name/@location
+      # Check the location again...
+      raise UsageError.new("The RemoteFileTask can only handle HTTP requests at this time, it seems you were trying: #{uri.scheme}") if uri.scheme != 'http'
+      raise UsageError.new('HTTP redirect too deep') if limit == 0
+      
+      response = nil
+      t = Thread.new {
+        response = Net::HTTP.get_response(uri.host, uri.path)
+      }
+      # TODO: Add actual bytesLoaded vs bytesTotal
+      # To the output...
+      while t.alive?
+        print(".")
+        $stdout.flush
+        sleep(0.2)
+      end
+      
+      if(response.is_a? Net::HTTPSuccess)
+        return response
+      elsif(response.is_a? Net::HTTPRedirection)
+        return fetch(response['location'], limit - 1)
+      else
+        puts response.to_s
+        return response.error!
+      end
+    end
+    
+    def get_remote_file(uri, target)
+      if(!File.exists?(target))
+        puts "Fetching #{uri.to_s} into #{target} now!"
+        response = fetch(uri.to_s)
+  
+        File.makedirs(File.dirname(target))
+        # Store the downloaded file on disk
+        File.open(target, 'wb') do |f|
+          f.write(response.body)
+        end
+  
+        puts ""
+        puts "Downloaded #{(response.body.size / 1024).to_s} KB"
+        puts "to: #{target}"
+        puts ""
+      end
+    end
+
+    def clean_path(path)
+      if(path.index(' '))
+        return %{'#{path}'}
+      end
+      return path
+    end
+    
+    def execute(params)
+      # Execute the system call with params
+      # Sometimes DOS wants a 'run' prefix
+      # Sometimes OSX wants a 'open' prefix
+      # Sometimes Cygwin wants a './' prefix
+      # This method should be overridden in
+      # subclasses
+      target = File.basename(extracted_file_path)
+      if(!Logger.debug)
+        puts("#{target} #{params}")
+      end
+      system("#{clean_path(extracted_file_path)} #{params}")
+     end
+  end
+  
+  class WinRemoteFileTask < AbstractRemoteFileTask
+    
+    def clean_path(path)
+      path = path.split('/').join(File::SEPARATOR)
+      if(path.index(' '))
+        return %{"#{path}"}
+      end
+      return path
+    end
+    
+    def execute(params)
+      target = File.basename(extracted_file_path)
+      if(!Logger.debug)
+        puts("#{target} #{params}")
+      end
+      system(%{"#{extracted_file_path}" #{params}})
+    end
+  end
+  
+  class CygwinRemoteFileTask < AbstractRemoteFileTask
+    
+    def execute(params)
+      target = File.basename(extracted_file_path)
+      if(!Logger.debug)
+        puts("#{target} #{params}")
+      end
+      system(%{#{clean_path(extracted_file_path)} #{params}})
+    end
+  end
+  
+  class OSXRemoteFileTask < AbstractRemoteFileTask
+    
+    def execute(params)
+      target = File.basename(extracted_file_path)
+      if(!Logger.debug)
+        puts("#{target} #{params}")
+      end
+      system("#{clean_path(extracted_file_path)} #{params}")
+     end
+
+    def full_mounted_path
+      return '/Volumes/' + mounted_path
+    end
+  end
+  
+  class UnixRemoteFileTask < AbstractRemoteFileTask
+  end
 end