flashplayer 9.115.0 → 10.1.1.pre

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem "sprout", ">= 1.0.pre"
+
+group :development do
+  gem "shoulda"
+  gem "mocha"
+end
+

data/VERSION

@@ -0,0 +1 @@
+10.1.1.pre

data/flashplayer.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path File.dirname(__FILE__), 'lib'
+$:.unshift lib unless $:.include?(lib)
+
+require 'bundler'
+Bundler.setup
+
+require 'flashplayer'
+
+Gem::Specification.new do |s|
+  s.name        = FlashPlayer::NAME
+  s.version     = FlashPlayer::VERSION
+  s.author      = "Luke Bayes"
+  s.email       = "projectsprouts@googlegroups.com"
+  s.homepage    = "http://www.adobe.com/products/flex"
+  s.summary     = "Adobe Flash Player"
+  s.description = "The Adobe Flash Player"
+  s.files       = FileList['**/**/*'].exclude /.git|.svn|.DS_Store/
+  s.add_bundler_dependencies
+  s.require_paths << 'lib'
+end
+

data/lib/flashplayer.rb

@@ -0,0 +1,13 @@
+require 'sprout'
+
+lib = File.expand_path File.dirname(__FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'flashplayer/errors'
+require 'flashplayer/module'
+require 'flashplayer/mm_config'
+require 'flashplayer/trust'
+require 'flashplayer/log_file'
+require 'flashplayer/task'
+require 'flashplayer/specification'
+

data/lib/flashplayer/clix_flash_player.rb

@@ -0,0 +1,92 @@
+require 'rubygems'
+require 'open4'
+
+$CLIX_WRAPPER_TARGET = File.join(File.expand_path(File.dirname(__FILE__)), 'clix_wrapper.rb')
+
+class CLIXFlashPlayerError < StandardError; end
+
+class CLIXFlashPlayer
+  VERSION = '0.1.0'
+  
+  def initialize
+    @activate_pid = nil
+    @player_pid = nil
+    @thread = nil
+  end
+  
+  def execute(player, swf)
+    cleanup
+    player = clean_path(player)
+    swf = clean_path(swf)
+    validate(player, swf)
+    
+    if(!player.match('Contents/MacOS'))
+      player = File.join(player, 'Contents', 'MacOS', 'Flash Player')
+    end
+
+    setup_trap
+
+    @thread = Thread.new {
+      @player_pid = open4.popen4("#{player.split(' ').join('\ ')}")[0]
+      begin
+        raise "clix_wrapper.rb could not be found at: #{wrapper}" if !File.exists?($CLIX_WRAPPER_TARGET)
+        command = "ruby #{$CLIX_WRAPPER_TARGET} '#{player}' '#{swf}'"
+        @activate_pid, stdin, stdout, stderr = open4.popen4(command)
+        $stdout.puts stdout.read
+        error = stderr.read
+        raise error if !error.nil? && error != ''
+        Process.wait(@player_pid)
+      rescue StandardError => e
+        $stdout.puts e.to_s
+        kill
+        raise e
+      end
+    }
+  end
+  
+  def kill
+    system("kill -9 #{@player_pid}")
+  end
+  
+  def join
+    if(@thread.alive?)
+      @thread.join
+    end
+  end
+  
+  def alive?
+    return @thread.alive?
+  end
+  
+  private
+  
+  def clean_path(path)
+    File.expand_path(path.gsub("'", '').gsub("\\", ''))
+  end
+  
+  def cleanup
+    if(@thread && @thread.alive?)
+      kill
+      @thread.join
+    end
+  end
+  
+  def validate(player, swf)
+    raise CLIXFlashPlayerError.new("Player must not be nil") if(player.nil? || player == '')
+    raise CLIXFlashPlayerError.new("Player cannot be found: '#{player}'") if(!File.exists?(player))
+    raise CLIXFlashPlayerError.new("SWF must not be nil") if(swf.nil? || swf == '')
+    raise CLIXFlashPlayerError.new("SWF cannot be found: '#{swf}'") if(!File.exists?(swf))
+  end
+  
+  def setup_trap
+    # Trap the CTRL+C Interrupt signal
+    # Which prevents nasty exception messages
+    Kernel.trap('INT') do
+      if(@thread.alive?)
+        @thread.kill
+      end
+    end
+  end
+  
+end
+

data/lib/flashplayer/clix_wrapper.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby
+require 'rubygems'
+
+player = ARGV[0]
+swf = ARGV[1]
+
+raise "CLIXWrapper requires 'player' argument like:\nruby clix_wrapper [player] [swf]" if(player.nil?)
+raise "CLIXWrapper could not find player at '#{player}'" if !File.exists?(player)
+
+raise "CLIXWrapper requires 'swf' argument like:\nruby clix_wrapper [player] [swf]" if(swf.nil?)
+raise "CLIXWrapper could not find swf at '#{swf}'" if !File.exists?(swf)
+
+begin
+  require 'appscript'
+  # Give the player focus:
+  Appscript.app(player).activate
+  # Open the SWF:
+  Appscript.app(player).open(MacTypes::Alias.path(swf))
+rescue LoadError => e
+  raise "\n\n[ERROR] You must install the rb-appscript gem to use the desktop debug Flash Player, you do this by running:\n\nsudo gem install rb-appscript"
+end
+

data/lib/flashplayer/errors.rb

@@ -0,0 +1,12 @@
+
+module FlashPlayer
+
+  ##
+  # Had trouble finding or resolving a path.
+  class PathError < StandardError; end
+
+  ##
+  # There was a problem with an input.
+  class UsageError < StandardError; end
+end
+

data/lib/flashplayer/log_file.rb

@@ -0,0 +1,79 @@
+
+module FlashPlayer
+
+  class LogFile
+
+    attr_accessor :logger
+
+    def initialize
+      @config      = MMConfig.new
+      @logger      = $stdout
+    end
+
+    def tail thread
+      @config.create
+      tail_path flashlog_path, thread
+    end
+
+    private
+
+    def tail_path path, thread=nil
+      logger.puts ">> Tailing '#{path}', press CTRL+C to quit"
+      create_flashlog_at path
+      clear_flashlog_at path
+      read_flashlog_at path, thread
+    end
+
+    def read_flashlog_at path, thread=nil
+      thread ||= Thread.new{}
+      lines_put = 0
+
+      trap("INT") { thread.kill }
+      
+      while thread.alive? do
+        File.open(path, 'r') do |file|
+          lines_read = 0
+          file.readlines.each do |line|
+            if(lines_read >= lines_put)
+              logger.puts "[trace] #{line}"
+              logger.flush
+              lines_put += 1
+            end
+            lines_read += 1
+          end
+        end
+        logger.flush
+        sleep(0.2)
+      end
+
+      logger.puts ""
+      logger.puts ">> Exiting from tailing '#{path}' at user request"
+    end
+
+    def flashlog_path
+      File.join(FlashPlayer.home, 'Logs', 'flashlog.txt')
+    end
+
+    def clear_flashlog_at path
+      File.open(path, 'w') do |f|
+        f.write('')
+      end
+    end
+
+    def create_flashlog_at path
+      if(!File.exists?(path))
+        FileUtils.makedirs(File.dirname(path))
+        FileUtils.touch(path)
+      end
+    end
+
+  end
+end
+
+desc "Tail the flashlog.txt and block"
+def flashlog args
+  task args do
+    reader = FlashPlayer::LogFile.new
+    reader.tail
+  end
+end

data/lib/flashplayer/mm_config.rb

@@ -0,0 +1,88 @@
+
+module FlashPlayer
+
+  class MMConfig
+    FILE_NAME = 'mm.cfg'
+
+    attr_accessor :logger
+
+    def initialize
+      @file_name = FILE_NAME
+      @logger    = $stdout
+    end
+
+    def create
+      create_if_necessary_at config_path
+    end
+
+    private
+
+    def create_if_necessary_at path
+      write_config(path, content(path)) if(file_blank?(path))
+    end
+
+    def flashplayer_home
+      FlashPlayer.home
+    end
+
+    def config_path
+      if(flashplayer_home == osx_fp9_dir)
+        path = File.join(osx_fp9_dir, @file_name)
+      else
+        path = File.join(system_home, @file_name)
+      end
+    end
+
+    def file_blank?(file)
+      !File.exists?(file) || File.read(file).empty?
+    end
+
+    def write_config(location, content)
+      if(user_confirmation?(location))
+        File.open(location, 'w') do |f|
+          f.write(content)
+        end
+        logger.puts ">> Created file: " + File.expand_path(location)
+        location
+      else
+        raise FlashPlayer::PathError.new("Unable to create #{file_name} at: #{location}")
+      end
+    end
+
+    def content(file)
+      return <<EOF
+ErrorReportingEnable=1
+MaxWarnings=0
+TraceOutputEnable=1
+TraceOutputFileName=#{file}
+EOF
+    end
+
+    def user_confirmation?(location)
+      puts <<EOF
+
+Correctly configured mm.cfg file not found at: #{location}
+
+This file is required in order to capture trace output.
+
+Would you like this file created automatically? [Yn]
+
+EOF
+      answer = $stdin.gets.chomp.downcase
+      return (answer == 'y' || answer == '')
+    end
+
+    def osx_fp9_dir
+      File.join(system_library, 'Application Support', 'Macromedia')
+    end
+
+    def system_library
+      Sprout.current_system.library
+    end
+
+    def system_home
+      Sprout.current_system.home
+    end
+  end
+end
+

data/lib/flashplayer/module.rb

@@ -0,0 +1,52 @@
+
+module FlashPlayer
+  NAME    = 'flashplayer'
+
+  # Do this craptastic, otherwise we get a carriage return
+  # after our version, and that poops on our archive folder
+  # after downloading...
+  version_file = File.join(File.dirname(__FILE__), '..', '..', 'VERSION')
+  VERSION = File.read(version_file).gsub("\n", '')
+
+  class << self
+
+    def home
+      # NOTE: Look up the value every time,
+      # this way we're not storing state globally
+      # and the performance penalty is minimal...
+      home_paths.each do |path|
+        return path if File.exists?(path)
+      end
+      raise FlashPlayer::PathError.new('FlashPlayer unable to find home folder for your System')
+    end
+
+    def trust
+      File.join(home, '#Security', 'FlashPlayerTrust', 'sprout.cfg')
+    end
+
+    private
+
+    def system_home
+      Sprout.current_system.home
+    end
+
+    def system_library
+      Sprout.current_system.library
+    end
+
+    # Collection of the potential locations of the Flash Player Home
+    # For each supported Platform, the first existing location
+    # will be used.
+    def home_paths
+      [
+        File.join(system_library, 'Preferences', 'Macromedia', 'Flash Player'),
+        File.join(system_library, 'Application Support', 'Macromedia'),
+        File.join(system_home, 'Application Data', 'Macromedia', 'Flash Player'),
+        File.join(system_home, 'AppData', 'Roaming', 'Macromedia', 'Flash Player'),
+        File.join(system_home, '.macromedia', 'Flash_Player')
+      ]
+    end
+
+  end
+end
+

data/lib/flashplayer/specification.rb

@@ -0,0 +1,31 @@
+
+Sprout::Specification.new do |s|
+  s.name        = FlashPlayer::NAME
+  s.version     = FlashPlayer::VERSION
+
+  s.add_remote_file_target do |t|
+    t.platform     = :osx
+    t.archive_type = :zip
+    t.url          = "http://download.macromedia.com/pub/flashplayer/updaters/10/flashplayer_10_sa_debug.app.zip"
+    t.md5          = "ff6824b7fd676dd1b613204221f5b5b9"
+    t.add_executable :flashplayer, "Flash Player Debugger.app/Contents/MacOS/Flash Player Debugger"
+  end
+=begin
+  s.add_remote_file_target do |t|
+    t.platform     = :win32
+    t.archive_type = :exe
+    t.url          = "http://download.macromedia.com/pub/flashplayer/updaters/10/flashplayer_10_sa_debug.exe"
+    t.md5          = "4d8d58d72709f44421b2ea4e89cc30be"
+    t.add_executable :flashplayer, "flashplayer_10_sa_debug.exe"
+  end
+
+  s.add_remote_file_target do |t|
+    t.platform     = :linux
+    t.archive_type = :tgz
+    t.url          = "http://download.macromedia.com/pub/flashplayer/updaters/10/flashplayer_10_sa_debug.tar.gz"
+    t.md5          = "6cabe6038343374b547043d29de14417"
+    t.add_executable :flashplayer, "flash_player_10_linux_dev/standalone/debugger/flashplayer"
+  end
+=end
+end
+

data/lib/flashplayer/task.rb

@@ -0,0 +1,408 @@
+
+module FlashPlayer
+
+  class Task
+
+    attr_accessor :input
+
+    attr_accessor :pkg_name
+    attr_accessor :pkg_version
+
+    def initialize
+      @logger       = $stdout
+      @mm_config    = MMConfig.new
+      @reader       = LogFile.new
+      @trust_config = Trust.new
+      @process      = nil
+
+      @pkg_name     = FlashPlayer::NAME
+      @pkg_version  = FlashPlayer::VERSION
+    end
+
+    def execute swf
+      update_mm_config
+      update_trust_config_with swf
+      player_thread = launch_player_with swf
+      tail_flashlog player_thread
+    end
+
+    def logger=(logger)
+      @logger              = logger
+      @mm_config.logger    = logger
+      @reader.logger       = logger
+      @trust_config.logger = logger
+    end
+
+    def logger
+      @logger
+    end
+
+    private
+
+    def update_mm_config
+      @mm_config.create
+    end
+
+    def update_trust_config_with swf
+      @trust_config.add File.dirname(swf)
+    end
+
+    def clean_path path
+      current_system.clean_path path
+    end
+
+    def current_system
+      @current_system ||= Sprout.current_system
+    end
+
+    def launch_player_with swf
+      player = Sprout::Executable.load(:flashplayer, pkg_name, pkg_version).path
+      swf = clean_path swf
+      current_system.open_flashplayer_with player, swf
+    end
+
+    def tail_flashlog player_thread
+      @reader.tail player_thread
+    end
+  end
+end
+
+##
+# Update the native System instances
+# to handle FlashPlayer launching in 
+# order to overcome non-cli limitations.
+#
+module Sprout
+  module System
+    
+    class WinSystem
+      def open_flashplayer_with exe, swf
+        return Thread.new {
+          system command
+        }
+      end
+    end
+
+    class OSXSystem
+      def open_flashplayer_with exe, swf
+        require 'flashplayer/clix_flash_player'
+        @clix_player = CLIXFlashPlayer.new
+        @clix_player.execute(exe, swf)
+        return @clix_player
+      end
+    end
+
+    class UnixSystem
+      def open_flashplayer_with exe, swf
+        return Thread.new {
+          require 'open4'
+          @player_pid, stdin, stdout, stderr = Open4.popen4(command)
+          stdout.read
+        }
+      end
+    end
+  end
+end
+
+def flashplayer args
+  # TODO:
+  # This shouldn't take over the SWF task name
+  # but instead should be assigned a SWF.
+  task args do
+    player = FlashPlayer::Task.new
+    player.execute args
+  end
+end
+
+=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 # :nodoc:
+      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
+        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))
+                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
+
+