h4oflashsdk 1.0.0

data/lib/flashplayer/specification.rb

@@ -0,0 +1,45 @@
+  require 'flashsdk'
+
+  ##
+  # This is the Flash Player Sprout::Specification and is how
+  # we figure out from where to load the Flash Player for the
+  # current user system.
+  Sprout::Specification.new do |s|
+    s.name        = FlashPlayer::NAME
+    s.version     = FlashPlayer::VERSION
+
+    ##
+    # NOTE: The order of these declarations is important, the RubyFeature.load method
+    # will search for the first match that is appropriate for the end user system.
+    #
+    # Current releases of the Ruby One-Click Installer for Windows actually
+    # run on top of Mingw, and OSX is a *nix variant, which means that 
+    # all System types (in Ruby at least) derive from UnixSystem. 
+    #
+    # This means that the Linux/Unix declaration will
+    # match everyone, so it is effectively the same as ':universal'
+    s.add_remote_file_target do |t|
+      t.platform     = :windows
+      t.archive_type = :exe
+      t.url          = "http://download.macromedia.com/pub/flashplayer/updaters/11/flashplayer_11_sa_debug.exe"
+      #t.url          = "http://download.macromedia.com/pub/flashplayer/updaters/10/flashplayer_10_sa_debug.exe"
+      t.md5          = "6fbc96203b878529a5baefe2226a403e"
+      t.add_executable :flashplayer, "6fbc96203b878529a5baefe2226a403e.exe"
+    end
+
+    s.add_remote_file_target do |t|
+      t.platform     = :osx
+      t.archive_type = :zip
+      t.url          = "http://fpdownload.macromedia.com/pub/flashplayer/updaters/11/flashplayer_11_sa_debug.app.zip"
+      t.md5          = "861e7b57ffae780ba391ac6adcb40a0d"
+      t.add_executable :flashplayer, "Flash Player Debugger.app"
+    end
+
+    s.add_remote_file_target do |t|
+      t.platform     = :linux
+      t.archive_type = :tgz
+      t.url          = "http://fpdownload.macromedia.com/pub/flashplayer/updaters/11/flashplayer_11_sa_debug.i386.tar.gz"
+      t.md5          = "38151e67351abce195339dc44d4ff7d0"
+      t.add_executable :flashplayer, "flashplayerdebugger"
+    end
+  end

data/lib/flashplayer/system_mixins.rb

@@ -0,0 +1,98 @@
+
+module Sprout
+
+  module System
+    
+    class WinSystem
+      
+      def open_flashplayer_with exe, swf
+        return Thread.new {
+          execute exe, swf
+        }
+      end
+    end
+
+    class OSXSystem < UnixSystem
+
+      ##
+      # Use AppleScript to open the specified Flash Player
+      # because, simply launching the executable does not focus
+      # it.
+      def open_flashplayer_with exe, swf
+        # Clean paths differently for this exectuable,
+        # because we're forking out to AppleScript over
+        # a new process, and spaces need to be escaped.
+        @player_exe = exe.split(' ').join('\ ')
+
+        wrapper = []
+        wrapper << "osascript"
+        wrapper << open_flashplayer_script_path
+        wrapper << @player_exe
+
+        # Call the UnixSystem.open_flashplayer_with method:
+        super wrapper.join(" "), File.expand_path(swf)
+      end
+
+      private
+
+      ##
+      # Use AppleScript to close the Flash Player
+      def close_flashplayer
+        closer = []
+        closer << "osascript"
+        closer << close_flashplayer_script_path
+        closer << @player_exe
+        `#{closer.join(" ")}`
+      end
+
+      def ext_gem_path
+        File.join(File.dirname(__FILE__), '..', '..', 'ext')
+      end
+
+      def close_flashplayer_script_path
+        File.expand_path(File.join(ext_gem_path, "CloseFlashPlayerForDumbassOSX.scpt"))
+      end
+
+      def open_flashplayer_script_path
+        File.expand_path(File.join(ext_gem_path, "OpenFlashPlayerForDumbassOSX.scpt"))
+      end
+
+    end
+
+    # All others inherit from this class
+    class UnixSystem
+
+      def open_flashplayer_with exe, swf
+        player_open = false
+        trap("INT") { 
+          close_flashplayer
+          @player_thread.kill
+        }
+
+        @player_thread = Thread.new {
+          require 'open4'
+          @player_pid, stdin, stdout, stderr = Open4.popen4("#{exe} #{swf}")
+          player_open = true
+          stdout.read
+        }
+
+        # Wait until the player process has actually
+        # openned...
+        while !player_open
+          sleep 0.1
+        end
+
+        @player_thread
+      end
+      
+      private
+
+      def close_flashplayer
+        # Don't need to do anything - created
+        # this method to handle belligerent OS X trash.
+      end
+
+    end
+  end
+end
+

data/lib/flashplayer/task.legacy.rb

@@ -0,0 +1,293 @@
+
+=begin
+
+  class FlashPlayerTask < Rake::Task
+    # This is the opening prelude to a collection of test results. When the
+    # task encounters this string in the trace output log file, it will begin
+    # collecting trace statements with the expectation that the following
+    # strings will be well-formatted XML data matching what JUnit emits for 
+    # Cruise Control.
+    #
+    # See the lib/asunit3/asunit.framework.XMLResultPrinter for more information.
+    @@test_result_pre_delimiter = '<XMLResultPrinter>'
+
+    # This is the closing string that will indicate the end of test result XML data
+    @@test_result_post_delimiter = '</XMLResultPrinter>'
+
+    @@home = nil
+    @@trust = nil
+
+    def initialize(task_name, app)
+      super(task_name, app)
+      @default_gem_name = 'sprout-flashplayer-tool'
+      @default_gem_version = '10.22.0'
+      @default_result_file = 'AsUnitResults.xml'
+      @inside_test_result = false
+    end
+
+    def self.define_task(args, &block)
+      t = super
+      yield t if block_given?
+      t.define
+    end
+    
+    # Local system path to the Flash Player Trust file
+    def FlashPlayerTask.trust
+      if(@@trust)
+        return @@trust
+      end
+      @@trust = File.join(FlashPlayerTask.home, '#Security', 'FlashPlayerTrust', 'sprout.cfg')
+      return @@trust
+    end
+
+    # Local system path to where the Flash Player stores trace output logs and trust files
+    def FlashPlayerTask.home
+      if(@@home)
+        return @@home
+      end
+
+      FlashPlayerTask.home_paths.each do |path|
+        if(File.exists?(path))
+          return @@home = path
+        end
+      end
+
+      if(@@home.nil?)
+        raise FlashPlayerError.new('FlashPlayer unable to find home folder for your platform')
+      end
+      return @@home
+    end
+
+    # Collection of the potential locations of the Flash Player Home
+    # For each supported Platform, the first existing location
+    # will be used.
+    def FlashPlayerTask.home_paths
+      return [File.join(User.library, 'Preferences', 'Macromedia', 'Flash Player'),
+              File.join(User.library, 'Application Support', 'Macromedia'),
+              File.join(User.home, 'Application Data', 'Macromedia', 'Flash Player'),
+              File.join(User.home, 'AppData', 'Roaming', 'Macromedia', 'Flash Player'),
+              File.join(User.home, '.macromedia', 'Flash_Player')]
+    end
+
+    # The swf parameter can be set explicitly in the block sent to this task as in:
+    #   
+    #   flashplayer :run do |t|
+    #     t.swf = 'bin/SomeProject.swf'
+    #   end
+    #
+    # Or it can be set implicitly as a rake prerequisite as follows:
+    #
+    #   flashplayer :run => 'bin/SomeProject' do |t|
+    #   end
+    #
+    def swf=(swf)
+      @swf = swf
+    end
+
+    def swf
+      @swf ||= nil
+      if(@swf.nil?)
+        prerequisites.each do |req|
+          if(req.index('.swf'))
+            @swf = req.to_s
+            break
+          end
+        end
+      end
+      return @swf
+    end
+
+    def gem_version=(version)
+      @gem_version = version
+    end
+    
+    def gem_version
+      return @gem_version ||= nil
+    end
+    
+    # Full name of the sprout tool gem that this tool task will use. 
+    # This defaults to sprout-flashplayer-tool
+    def gem_name=(name)
+      @gem_name = name
+    end
+
+    def gem_name
+      return @gem_name ||= @default_gem_name
+    end
+    
+    # The File where JUnit test results should be written. This value
+    # defaults to 'AsUnitResults.xml'
+    #
+    def test_result_file=(file)
+      @test_result_file = file
+    end
+
+    def test_result_file
+      @test_result_file ||= @default_result_file
+    end
+    
+    def test_result
+      @test_result ||= ''
+    end
+
+    def define 
+      CLEAN.add(test_result_file)
+    end
+
+    def execute(*args)
+      super
+      raise FlashPlayerError.new("FlashPlayer task #{name} required field swf is nil") unless swf
+      
+      log_file = nil
+
+      # Don't let trust or log file failures break other features...
+      begin
+        config = FlashPlayerConfig.new
+        log_file = config.log_file
+        FlashPlayerTrust.new(File.expand_path(File.dirname(swf)))
+
+        if(File.exists?(log_file))
+          File.open(log_file, 'w') do |f|
+            f.write('')
+          end
+        else
+          FileUtils.makedirs(File.dirname(log_file))
+          FileUtils.touch(log_file)
+        end
+      rescue StandardError => e
+        logger.puts '[WARNING] FlashPlayer encountered an error working with the mm.cfg log and/or editing the Trust file'
+      end
+      
+      @running_process = nil
+      @thread = run(gem_name, gem_version, swf)
+      read_log(@thread, log_file) unless log_file.nil?
+      @thread.join
+    end
+
+    def run(tool, gem_version, swf)
+      path_to_exe = Sprout.get_executable(tool, nil, gem_version)
+      target = User.clean_path(path_to_exe)
+      @player_pid = nil
+      
+      thread_out = $stdout
+      command = "#{target} #{User.clean_path(swf)}"
+
+      usr = User.new()
+      if(usr.is_a?(WinUser) && !usr.is_a?(CygwinUser))
+        return Thread.new {
+            system command
+        }
+      elsif usr.is_a?(OSXUser)
+        require 'clix_flash_player'
+        @clix_player = CLIXFlashPlayer.new
+        @clix_player.execute(target, swf)
+        return @clix_player
+      else
+        return Thread.new {
+          require 'open4'
+          @player_pid, stdin, stdout, stderr = Open4.popen4(command)
+          stdout.read
+        }
+      end
+    end
+    
+    def close
+      usr = User.new
+      if(usr.is_a?(WinUser))
+        Thread.kill(@thread)
+      elsif(usr.is_a?(OSXUser))
+        @clix_player.kill unless @clix_player.nil?
+      else
+        Process.kill("SIGALRM", @player_pid)
+      end
+    end
+    
+    def read_log(thread, log_file)
+      lines_put = 0
+
+      if(log_file.nil?)
+        raise FlashPlayerError.new('[ERROR] Unable to find the trace output log file because the expected location was nil')
+      end
+
+      if(!File.exists?(log_file))
+        raise FlashPlayerError.new('[ERROR] Unable to find the trace output log file in the expected location: ' + log_file)
+      end
+
+      while(thread.alive?)
+        sleep(0.2)
+        lines_read = 0
+
+        File.open(log_file, 'r') do |file|
+          file.readlines.each do |line|
+            lines_read = lines_read + 1
+            if(lines_read > lines_put)
+              if(!parse_test_result(line, thread))
+                logger.puts "[trace] #{line}"
+              end
+              $stdout.flush
+              lines_put = lines_put + 1
+            end
+          end
+        end
+      end
+    end
+
+    # Returns true if inside of a test result
+    def parse_test_result(line, thread)
+      if(@inside_test_result)
+        if(line.index(@@test_result_post_delimiter))
+          @inside_test_result = false
+          write_test_result(test_result)
+          close
+          examine_test_result test_result
+          return true
+        else
+          test_result << line
+        end
+      end
+
+      if(line.index(@@test_result_pre_delimiter))
+        @inside_test_result = true
+      end
+      
+      return @inside_test_result
+    end
+    
+    def write_test_result(result)
+      FileUtils.makedirs(File.dirname(test_result_file))
+      File.open(test_result_file, File::CREAT|File::TRUNC|File::RDWR) do |f|
+        f.puts(result)
+      end
+    end
+
+    def examine_test_result(result)
+      require 'rexml/document'
+      doc = nil
+      begin
+        doc = REXML::Document.new(result)
+      rescue REXML::ParseException => e
+        puts "[WARNING] Invalid test results encountered"
+        return
+      end
+      
+      # Handle JUnit Failures
+      failures = []
+
+      doc.elements.each('/testsuites/testsuite/testsuite/testcase/error') do |element|
+        failures << element.text
+      end
+
+      doc.elements.each("/testsuites/testsuite/testsuite/testcase/failure") do |element|
+        failures << element.text
+      end
+
+      if(failures.size > 0)
+        raise AssertionFailure.new("[ERROR] Test Failures Encountered \n#{failures.join("\n")}")
+      end
+    end
+
+  end
+
+=end
+
+

data/lib/flashplayer/task.rb

@@ -0,0 +1,62 @@
+
+module FlashPlayer
+
+  class Task < Rake::Task
+
+    attr_accessor :input
+    attr_accessor :pkg_name
+    attr_accessor :pkg_version
+
+    ##
+    # This is the Rake::Task constructor
+    # signature...
+    def initialize task_name, rake_application
+      super
+      @input = task_name
+      @player = FlashPlayer::Executable.new
+      @pkg_name = FlashPlayer::NAME
+      @pkg_version = FlashPlayer::VERSION
+    end
+
+    def execute *args
+      super
+      update_input_if_necessary
+      @player.input = input
+      @player.fdb = use_fdb?
+      @player.execute
+    end
+
+    def logger=(logger)
+      @player.logger = logger
+    end
+
+    def logger
+      @player.logger
+    end
+
+    private
+
+    def use_fdb?
+      # Check as string b/c this is
+      # how the boolean value comes
+      # accross the command line input.
+      ENV['USE_FDB'].to_s == 'true'
+    end
+
+    def update_input_if_necessary
+      return if input.match(/\.swf$/)
+      prerequisites.each do |prereq|
+        if(prereq.match(/\.swf$/))
+          self.input = prereq
+          return
+        end
+      end
+    end
+
+  end
+end
+
+def flashplayer *args, &block
+  FlashPlayer::Task.define_task *args, &block
+end
+

data/lib/flashplayer/trust.rb

@@ -0,0 +1,45 @@
+
+module FlashPlayer
+
+  class Trust
+
+    attr_accessor :logger
+
+    def initialize
+      @logger = $stdout
+    end
+
+    def add path
+      file = trust_file
+      create(file) unless File.exists?(file)
+      update_if_necessary file, path
+    end
+
+    private
+
+    def create file
+      dir = File.dirname file
+      FileUtils.makedirs(dir) unless File.exists?(dir)
+      FileUtils.touch file
+    end
+
+    def update_if_necessary file, path
+      path = File.expand_path path
+      if(!has_path?(file, path))
+        File.open(file, 'a') do |f|
+          f.puts path
+        end
+        logger.puts ">> Added #{path} to Flash Player Trust file at: #{file}"
+      end
+    end
+
+    def has_path? file, path
+      !File.read(file).index(path).nil?
+    end
+
+    def trust_file
+      FlashPlayer.trust
+    end
+  end
+end
+

data/lib/flashplayer.rb

@@ -0,0 +1,9 @@
+require 'flashplayer/system_mixins'
+require 'flashplayer/errors'
+require 'flashplayer/module'
+require 'flashplayer/mm_config'
+require 'flashplayer/trust'
+require 'flashplayer/log_file'
+require 'flashplayer/executable'
+require 'flashplayer/task'
+require 'flashplayer/specification'

data/lib/flashsdk/acompc.rb

@@ -0,0 +1,29 @@
+module FlashSDK
+
+  ##
+  # The ACOMPC tool is a wrapper for the acompc tool.
+  #
+  class ACOMPC < COMPC
+
+    ##
+    # The default executable target.
+    #
+    set :executable, :acompc
+    
+    ##
+    # TODO: Remove this method once this bug is fixed:
+    # http://www.pivotaltracker.com/story/show/4194771
+    #
+    def execute *args
+      self.executable = :acompc
+      super
+    end
+  end
+end
+
+def acompc args, &block
+  exe = FlashSDK::ACOMPC.new
+  exe.to_rake(args, &block)
+  exe
+end
+

data/lib/flashsdk/adl.rb

@@ -0,0 +1,83 @@
+module FlashSDK
+
+  class ADL < Sprout::Executable::Base
+
+    add_param :runtime, Path
+
+    add_param :pubid, String
+
+    add_param :nodebug, Boolean
+
+    add_param :profile, String, { :delimiter => ' ' }
+
+    add_param :screensize, String, { :delimiter => ' ' }
+
+    add_param :app_desc, String, { :hidden_name => true, :delimiter => ' ' }
+
+    add_param :root_dir, String, { :hidden_name => true, :delimiter => ' ' }
+
+    #add_param :shitty_dashes, String, { :hidden_name => true, :delimiter => ' ', :default => '--' }
+
+    add_param :input, File, { :hidden_name => true }
+
+    ##
+    # The the Ruby file that will load the expected
+    # Sprout::Specification.
+    #
+    # Default value is 'flex4'
+    #
+    set :pkg_name, 'flex4'
+
+    ##
+    # The default pkg version
+    #
+    set :pkg_version, ">= #{FlashSDK::VERSION}"
+    
+    ##
+    # The default executable target.
+    #
+    set :executable, :adl
+
+    ##
+    # The default prefix
+    #
+    set :default_prefix, '-'
+
+    ##
+    # Overide the default task creation so
+    # adl will run regardless of a file product.
+    #
+    def create_outer_task *args
+      Rake::Task.define_task(*args) do
+        execute
+      end
+    end
+
+    ##
+    # Overide the default behaviour to stop the file product
+    # being added to to the CLEAN task.
+    #
+    def update_rake_task_name_from_args *args
+      self.rake_task_name = parse_rake_task_arg args.last
+      self.rake_task_name
+    end
+  end
+end
+
+def adl *args, &block
+  exe = FlashSDK::ADL.new
+  exe.to_rake(*args, &block)
+  exe
+end
+
+##
+# TODO: This should NOT be here!
+# This is preventing that method from working
+# as expected only after this FILE is required.
+class Sprout::System::UnixSystem
+
+    def should_repair_executable path
+      return false
+      #return (File.exists?(path) && !File.directory?(path) && File.read(path).match(/^\#\!\/bin\/sh/))
+    end
+end