flashsdk_sqe 0.0.1

data/lib/flashplayer/log_file.rb

@@ -0,0 +1,100 @@
+
+module FlashPlayer
+
+  class LogFile
+
+    attr_accessor :logger
+    attr_accessor :player_pid
+
+    def initialize
+      @logger = $stdout
+      super
+    end
+
+    def tail(thread = nil, player_pid = nil)
+      self.player_pid = player_pid
+      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 ||= fake_thread
+      lines_put = 0
+
+      while thread.alive? do
+        lines_put, last_line = read_from_file path, lines_put
+        logger.flush
+        sleep(0.1)
+
+        unless last_line.nil?
+          thread.kill
+          Process.kill('KILL', self.player_pid) if self.player_pid
+        end
+      end
+    end
+
+    def read_from_file path, lines_put
+      last_line = nil
+      File.open(path, 'r') do |file|
+        lines_read = 0
+        file.readlines.each do |line|
+          last_line = line if line =~ /ALL TESTS ARE COMPLETED/
+          if(lines_read >= lines_put)
+            logger.puts "[trace] #{line}"
+            logger.flush
+            lines_put += 1
+          end
+          lines_read += 1
+        end
+      end unless !File.exists?(path)
+      [lines_put, last_line]
+    end
+
+    def flashlog_path
+      begin
+        FlashPlayer.flashlog
+      rescue FlashPlayer::PathError
+        "/dev/null"
+      end
+    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
+
+    def fake_thread
+      Thread.new do
+        while true
+          sleep(0.2)
+        end
+      end
+    end
+
+  end
+end
+
+desc "Tail the flashlog.txt and block (until CTRL+C)"
+task :flashlog do
+  mm_config = FlashPlayer::MMConfig.new
+  mm_config.create
+  reader = FlashPlayer::LogFile.new
+  reader.tail 
+end
+

data/lib/flashplayer/mm_config.rb

@@ -0,0 +1,96 @@
+
+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
+      if(File.exists?(File.dirname(path)))
+        write_config(path, content(flashlog_path)) if(file_blank?(path))
+      end
+    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 flashplayer_home
+      FlashPlayer.home
+    end
+
+    def flashlog_path
+      FlashPlayer.flashlog
+    end
+
+    def file_blank?(file)
+      !File.exists?(file) || File.read(file).empty?
+    end
+
+    def write_config(location, content)
+      if(user_confirmation?(location))
+        FileUtils.makedirs File.dirname(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 #{location}")
+      end
+    end
+
+    def content(flashlog)
+      return <<EOF
+ErrorReportingEnable=1
+MaxWarnings=0
+TraceOutputEnable=1
+TraceOutputFileName=#{flashlog}
+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,51 @@
+
+module FlashPlayer
+  NAME    = 'flashplayer'
+  VERSION = '11.1.102'
+
+  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
+
+    def flashlog
+      File.join home, 'Logs', 'flashlog.txt'
+    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,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://fpdownload.macromedia.com/pub/flashplayer/updaters/11/flashplayer_11_sa_debug_32bit.exe"
+      t.url          = "http://download.macromedia.com/pub/flashplayer/updaters/10/flashplayer_10_sa_debug.exe"
+      t.md5          = "6fbc96203b878529a5baefe2226a403e"
+      t.add_executable :flashplayer, "5f7f4c4246784745b0e1b5593e9bc60f.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          = "2d5d0da2bcf4b76afe75f7a113f4f3f1"
+      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, @player_pid]
+      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
+
+