hpeikemo-flexfarm 0.3.2

data/History.txt

@@ -0,0 +1,38 @@
+=== 0.3.2 / 2009-29-7
+
+* ffdebugger: Error output gets red text color.
+
+=== 0.3.1 / 2009-24-6
+
+* Using join(" ") instead og Array#to_s.
+
+=== 0.3.0 / 2009-21-5
+
+* Improved ffdebugger
+
+=== 0.2.2 / 2009-20-5
+
+* Improved error handling in flexmate.
+* generate_rakefile no longer halts vim.
+
+=== 0.2.1 / 2009-02-2
+
+* Fixed bug in ffcompile where it would not find compiler-deamon.
+
+=== 0.2.0 / 2009-02-1
+
+* Config and rakefile generator 
+* Renamed bin files; added ff-prefix.
+
+=== 0.1.2 / 2009-01-25
+
+* Added support for previewing air apps by setting Project#air_descriptor.
+
+=== 0.1.1 / 2009-01-17
+
+* Refactored to Flexfarm package.
+
+=== 0.1.0 / 2009-01-13
+
+* First implementation of gem-package.
+

data/Manifest.txt

@@ -0,0 +1,18 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+rakefile.rb.example
+bin/ffarm
+bin/ffcompile
+bin/ffdebugger
+bin/fffcshd
+lib/flexfarm.rb
+lib/cliwrapper.rb
+lib/fcsh.rb
+lib/fdb.rb
+lib/flashmate.rb
+lib/flexfarm_config.rb
+lib/flexrake.rb
+lib/generator.rb
+lib/default_config.rb

data/README.txt

@@ -0,0 +1,42 @@
+= flexfarm
+
+http://hpeikemo.github.com/flexfarm/
+
+== DESCRIPTION:
+
+flexFarm is a set of tools to charge and improve ActionScript development.
+
+
+== FEATURES/PROBLEMS:
+
+* Compile as3 projects. Quickly.
+* Debug as3 projects
+
+== SYNOPSIS:
+
+
+== REQUIREMENTS:
+
+* Adobe Flex 3 SDK
+
+== INSTALL:
+
+* sudo gem install ....
+
+== LICENSE:
+
+flexFarm is a set of tools to charge and improve ActionScript development.
+Copyright (C) 2009 Hans Petter Eikemo
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,26 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/flexfarm.rb'
+
+Hoe.plugin :git
+
+Hoe.spec('flexfarm') do
+  developer('Hans Petter Eikemo', 'hpeikemo@me.com')
+end
+
+# vim: syntax=Ruby
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "flexfarm"
+    gem.summary = "flexFarm is a set of tools to charge and improve ActionScript development."
+    gem.email = "hpeikemo@me.com"
+    gem.homepage = "http://github.com/hpeikemo/flexfarm"
+    gem.authors = ["Hans Petter Eikemo"]
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.2

data/bin/ffarm

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$:<<File.dirname(__FILE__)
+@command = ARGV.shift
+bin_name = File.basename(__FILE__)
+
+unless @command
+   puts "Type '#{bin_name} help' for usage."   
+   exit 1
+end
+
+def edit(file)
+   `#{ENV["EDITOR"] || "vim"} #{file}`      
+end
+
+
+case @command
+when "config"
+   require "generator.rb"
+   edit(Flexfarm::create_userconfig)   
+when "generate_rakefile"
+   require "generator.rb"
+   Flexfarm::create_rakefile
+when "compile"
+   load "ffcompile"
+when "fcshd"
+   load "fffcshd"
+when "debugger"
+   load "ffdebugger"
+when "help"
+   puts "#{bin_name} compile [compiler args...]","#{bin_name} fcshd","#{bin_name} debugger","#{bin_name} config","#{bin_name} generate_rakefile"
+else
+   puts "Unknown flexfarm command '#{@command}'. Type '#{bin_name} help' for usage."
+   exit 1
+end
+

data/bin/ffcompile

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path("#{File.dirname(__FILE__)}/../lib")
+
+
+require "flexfarm_config.rb"
+require "socket"
+
+include Flexfarm
+
+
+SERVER_SCRIPT = File.dirname(__FILE__)+"/fffcshd"
+COMPILE_ARGS = ARGV.join(" ")
+
+errors = []
+compileErrors = []
+completed = false
+
+connection = TCPSocket.new("127.0.0.1", COMPILER_PORT) rescue nil
+if !connection
+   if File.exist? SERVER_SCRIPT
+      verbose_puts("Compiler deamon not running, attempting to start...")
+      system("#{SERVER_SCRIPT} 1>/dev/null 2>/dev/null &")         
+      sleep 0.5
+      connection = TCPSocket.new("127.0.0.1", COMPILER_PORT)
+   else
+      verbose_puts("Compiler deamon not running",1)
+      errors.push("Compiler deamon not running")
+   end
+end
+
+hello = connection.gets.chomp rescue nil
+
+if hello == "[connected]"   
+   connection.puts COMPILE_ARGS
+   while !connection.closed? && (line = connection.gets) 
+      if line =~ /^\[done\]/
+         verbose_puts("Operation complete.",1)
+         completed = true
+      elsif line =~ /^\[compileError\](.*)$/
+         compileErrors.push( $1 )
+      elsif line =~ /^\[error\](.*)$/
+         compileErrors.push( $1 )      
+      else
+         puts color("Output: ",36)+ line
+      end      
+   end
+   verbose_puts("Disconnected",1)
+end
+
+if (completed && compileErrors.empty?)
+   puts "[SUCCESS]"
+else
+   puts "[FAIL]"   
+   (errors+compileErrors).each do |error|
+      STDERR.puts error
+   end
+   exit 1
+end
+

data/bin/ffdebugger

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+
+$: << File.expand_path("#{File.dirname(__FILE__)}/../lib")
+
+require "flexfarm_config.rb"
+require "fdb.rb"
+require "readline"
+    
+include Flexfarm
+
+puts "\tStarting Flash debugger.","\tWaiting for connections."
+
+begin   
+   fdb = FDB.new(FDB_BIN)
+   while fdb.running?
+      sleep 0.1
+      
+      keyboard_input = FDB::getLines(STDIN).to_a
+                  
+      fdb.getErrors do |line|
+         puts color("Error: ",31)+line
+      end
+      fdb.getOutput do |line|
+         debugger_output(line) unless [FDB::WAITING_MODE,FDB::IDLE_MODE].include? fdb.mode
+      end
+      if fdb.available
+         fdb.dispatch("run")        if fdb.mode == FDB::IDLE_MODE         
+         fdb.dispatch("continue")   if fdb.mode == FDB::RUNNING_MODE
+         if fdb.mode == FDB::BREAK_MODE
+            begin
+               input = Readline::readline( color("input: ",31) )
+               Readline::HISTORY.push(input)
+            end while input !~ /\w/
+            fdb.dispatch( input )
+         end
+      elsif keyboard_input.last == "\n"
+         fdb.break
+      end
+   end
+rescue Exception => e
+   if e.class == Interrupt
+      puts "","Caught interupt signal.."
+   else
+      puts color("Unhandled exception: ",31)+e.inspect
+   end
+ensure
+   fdb.cleanup
+end

data/bin/fffcshd

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path("#{File.dirname(__FILE__)}/../lib")
+
+require "flexfarm_config.rb"
+require "fcsh.rb"
+require "socket"
+
+include Flexfarm
+
+
+begin
+   fcsh = FCSH.new(FCSH_BIN)
+   server = TCPServer.new("127.0.0.1", COMPILER_PORT)      
+   while fcsh.running? && !fcsh.available
+      sleep 0.2         
+      fcsh.getOutput do |line|
+         debugger_output(line)
+      end      
+   end
+         
+   fcsh.mode = FCSH::IDLE_MODE
+   puts "Accepting connections."
+   
+   while fcsh.running? && (connection = server.accept)         
+      verbose_puts("Got connection",1)
+      connection.puts "[connected]"
+      
+      queue = []
+
+      until connection.closed?
+         sleep 0.01
+         queue.push( *FCSH::getLines(connection).to_a )
+
+         fcsh.getErrors do |line|
+            puts color("Error: ",31)+line
+            if line =~ /.+\(\d+\)\: col\: /
+               connection.puts "[compileError]#{line}" 
+            elsif line =~ /Error\:/
+               connection.puts "[error]#{line}"
+            end
+         end         
+         fcsh.getOutput do |line|            
+            debugger_output(line)
+            connection.puts line
+         end
+         if fcsh.available
+            if !queue.empty?
+               input = queue.shift            
+               connection.close if input == "\r\n"
+               
+               if input =~ /^(mxmlc|compc )/
+                  fcsh.compile( input.chomp ) 
+               elsif input =~ /^q/                                 
+                  fcsh.dispatch("quit")
+                  exit 0
+               end
+            else
+               connection.puts "[done]"
+               connection.close
+            end
+         end      
+      end
+   end
+   
+rescue Exception => e
+   if e.class == Interrupt
+      puts "","Caught interupt signal.."
+   else
+      puts color("Unhandled exception: ",31)+e.inspect
+   end
+ensure
+   fcsh.cleanup
+end

data/flexfarm.gemspec

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{flexfarm}
+  s.version = "0.3.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Hans Petter Eikemo"]
+  s.date = %q{2009-07-05}
+  s.email = %q{hpeikemo@me.com}
+  s.executables = ["ffarm", "ffcompile", "ffdebugger", "fffcshd"]
+  s.extra_rdoc_files = [
+    "README.txt"
+  ]
+  s.files = [
+    "History.txt",
+     "Manifest.txt",
+     "README.txt",
+     "Rakefile",
+     "VERSION",
+     "bin/ffarm",
+     "bin/ffcompile",
+     "bin/ffdebugger",
+     "bin/fffcshd",
+     "flexfarm.gemspec",
+     "lib/cliwrapper.rb",
+     "lib/default_config.rb",
+     "lib/fcsh.rb",
+     "lib/fdb.rb",
+     "lib/flashmate.rb",
+     "lib/flexfarm.rb",
+     "lib/flexfarm_config.rb",
+     "lib/flexrake.rb",
+     "lib/generator.rb",
+     "rakefile.rb.example"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/hpeikemo/flexfarm}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{flexFarm is a set of tools to charge and improve ActionScript development.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/cliwrapper.rb

@@ -0,0 +1,66 @@
+require "open3"
+require 'readline'
+
+module Flexfarm
+         
+         
+class CliWrapper
+            
+   attr_reader :mode
+   attr_reader :available
+   
+   CLEANUP_MODE = :cleanup
+      
+   def initialize(executable_path)
+      @stdin, @stdout, @stderr = Open3.popen3(executable_path)
+      @running = true
+      @available = false
+   end
+   
+   def cleanup
+      return unless @running
+      self.mode = CLEANUP_MODE
+      verbose_puts("Quiting #{self.class}",1)
+      @running = false
+      @stdin.close unless @stdin.closed?
+      @stdout.close unless @stdout.closed?
+      @stderr.close unless @stderr.closed?      
+   end
+   
+   def running?
+      @running && @stdin.syswrite(nil)==0 rescue false
+   end   
+   
+   def getErrors
+      CliWrapper::getLines(@stderr).each {|line| yield(line) }
+   end
+   
+   def getOutput      
+      CliWrapper::getLines(@stdout).each {|line| yield(line) }
+   end
+   
+   def dispatch(command="")      
+      if available && !command.empty?
+         verbose_puts("[command: #{command}] ",2)
+         @stdin.puts command
+         @available = false
+      else
+         verbose_puts("[blocked command: #{command}] ",2)
+      end
+   end
+   
+   def mode= (value)
+      if (@mode != value)
+         @mode=value
+         verbose_puts("[Mode is #{@mode}]",2)
+      end
+   end
+      
+   def self.getLines(io)
+      buffer = ""
+      buffer += io.read_nonblock(1024) while true rescue buffer.to_a      
+   end
+      
+end
+
+end

data/lib/default_config.rb

@@ -0,0 +1,18 @@
+module Flexfarm   
+      
+   # Note that mxmlc do not handle (even escaped) spaces in any path.
+   #     (symlink to resolve related issues)
+   
+   FLEX_HOME = "/usr/share/flex/sdks/3.2.0"
+   FDB_BIN = "#{FLEX_HOME}/bin/fdb"
+   FCSH_BIN = "#{FLEX_HOME}/bin/fcsh"
+   ADL_BIN = "#{FLEX_HOME}/bin/adl"
+   ADT_BIN = "#{FLEX_HOME}/bin/adt"
+      
+   ADL_RUNTIME = "#{FLEX_HOME}/runtimes/air/mac"      
+   FLEX_COMPILER = "ffcompile"
+   
+   COMPILER_PORT = 4200
+   $verbose_level = 1
+   
+end

data/lib/fcsh.rb

@@ -0,0 +1,65 @@
+require "cliwrapper.rb"
+
+module Flexfarm
+
+
+class FCSH < CliWrapper
+   
+   MAX_TARGETS = 15
+   
+   SILENT = /^\(fcsh\) /
+   INPUT_PROMPT = /^\(fcsh\) /
+   ASSIGNED_TARGET = /Assigned (\d+) as the compile target id/
+   
+   INIT_MODE = :init
+   IDLE_MODE = :idle       
+   COMPILE_MODE = :compile
+      
+   def initialize(*args)
+      super(*args)
+      self.mode = INIT_MODE
+      @currentCommand = nil      
+      clean_targets
+   end
+   
+   def getOutput      
+      lines = FCSH::getLines(@stdout)
+      lines.each do |line| 
+         yield(line) unless line =~ SILENT         
+         if line =~ ASSIGNED_TARGET
+            target = $1.to_i
+            @compileTargets[@currentCommand] = $1
+         end
+      end      
+      if lines.last && lines.last =~ INPUT_PROMPT
+         @available = true         
+         clean_targets if @compileTargets.length > MAX_TARGETS
+      end
+      self.mode = IDLE_MODE if available && self.mode == COMPILE_MODE
+   end
+   
+   def compile(command)
+      self.mode = COMPILE_MODE
+      @currentCommand = command
+      target = @compileTargets[@currentCommand]
+      if target
+         dispatch("compile #{target}")
+      else
+         dispatch(command)
+      end      
+   end
+   
+   private
+   def clean_targets
+      if @compileTargets
+         verbose_puts("Too many targets (#{@compileTargets.length}), cleaning up..")
+         dispatch( "clear" ) 
+      end
+      @compileTargets = {}      
+   end
+   
+
+      
+end
+
+end

data/lib/fdb.rb

@@ -0,0 +1,60 @@
+require "cliwrapper.rb"
+
+module Flexfarm
+
+
+class FDB < CliWrapper
+   
+   SILENT = /^\(fdb\) |Do you want to attempt to halt execution|To help out, try nudging the Player/      
+   INPUT_PROMPT = /^\(fdb\) |\(y or n\)/
+   WAITING_FOR_PLAYER = /Waiting for Player to connect/
+   ALREADY_IN_USE = /Another Flash debugger is probably running/
+   FAILED_TO_CONNECT = /Failed to connect\; session timed out/
+   SESSION_STARTED = /Player connected\; session starting/
+   SESSION_TERMINATED = /Player session terminated/
+   NOT_CONFIRMED = /Not confirmed/
+   EXECUTION_HALTED = /^(Execution halted|Fault)/   
+      
+   IDLE_MODE = :idle          # Not waiting for anything, debugger just started or session just ended.
+   WAITING_MODE = :waiting    # Waiting for player to connect
+   STARTING_MODE = :starting  # Player connected; session starting.
+   RUNNING_MODE = :running    # Session running.
+   BREAK_MODE = :break        # Enter debugger. Interactive mode.
+   
+   def initialize(*args)
+      super(*args)
+      self.mode = IDLE_MODE
+   end
+
+   def getOutput      
+      lines = FDB::getLines(@stdout)
+      lines.each do |line| 
+         yield(line) unless line =~ SILENT       
+         self.mode = WAITING_MODE   if line =~ WAITING_FOR_PLAYER
+         self.mode = IDLE_MODE      if line =~ FAILED_TO_CONNECT  || line =~ SESSION_TERMINATED         
+         self.mode = BREAK_MODE     if line =~ EXECUTION_HALTED
+         init_session               if line =~ SESSION_STARTED                  
+         return cleanup             if line =~ ALREADY_IN_USE         
+      end
+      
+      if lines.last && lines.last =~ INPUT_PROMPT
+         @available = true
+      else
+         # self.mode = RUNNING_MODE
+         @available = false
+      end
+   end
+         
+   def break
+      @stdin.puts("","y") #if self.mode == RUNNING_MODE
+   end
+            
+   private
+   
+   def init_session
+      self.mode = RUNNING_MODE
+   end
+   
+end
+
+end

data/lib/flashmate.rb

@@ -0,0 +1,89 @@
+module FlexMate
+   
+   ERROR_REGEX = /(\/.*?)(?:(\(([0-9]+)\)|): col: (\d+)|:).*(Error|Warning):\s*(.*)$/
+   GENERIC_ERROR_REGEX = /Error/   
+   
+   
+      
+   def self.execute_build
+      require "open3"
+      @project_path = ENV['TM_PROJECT_DIRECTORY']
+      @build_command = "rake"
+
+      
+      
+      @stdin, @stdout, @stderr = Open3.popen3(@build_command)      
+      compileErrors = []
+      genericErrors = []
+      while out = @stderr.gets
+         # puts out
+         m = ERROR_REGEX.match( out )
+         m2 = GENERIC_ERROR_REGEX.match( out )
+         
+         if m
+            compileErrors << {
+               "message" => m[6],
+               "filepath" => m[1],
+               "file" => File.basename(m[1]),
+               "line" => m[3] || "1",
+               "column" => m[4] || "0"
+            } 
+         elsif m2
+            
+            compileErrors << {
+               "message" => out
+            }
+         end
+         
+      end
+      # while out = @stdout.gets 
+      #    puts out
+      # end
+      
+      return compileErrors
+   end
+   
+   def self.compile_project()
+      return unless ENV["TM_SUPPORT_PATH"]
+      
+      tm_path = ENV["TM_SUPPORT_PATH"] || ""
+      require tm_path+"/lib/textmate.rb"
+      require tm_path+"/lib/exit_codes"
+      require tm_path+"/lib/progress"
+      require tm_path+"/lib/web_preview"
+      
+      
+      TextMate.call_with_progress({
+         :title => "Rake",
+         :summary => 'Starting Up...',
+         :indeterminate => false,
+      #   :cancel => lambda { puts "Canceled compile!"; Process.kill('SIGUSR1') }
+      }) do |dialog|
+            
+         dialog.parameters = {'summary' => 'Compiling','progressValue' => 10 }            
+         @errors = execute_build
+         # sleep(10)
+         dialog.parameters = {'summary' => 'Compile complete','progressValue' => 100 }            
+         
+            
+      end
+      
+         
+                           
+      if @errors && @errors.length > 0
+         #maxchars = @errors.map{ |c| c["file"].to_s.length }.max
+         @errors.each { |choice|
+            if (choice["file"])
+               choice["title"] =  choice["file"] + ":" +choice["line"] + "  "+ choice["message"]
+            else
+               choice["title"] = choice["message"]
+            end
+         }
+         choice = TextMate::UI.menu(@errors[0..9])    
+         if choice && choice["filepath"]                
+            TextMate.go_to :file => choice["filepath"] , :line => choice["line"], :column => choice["column"]
+         end
+      end
+   end
+   
+end

data/lib/flexfarm.rb

@@ -0,0 +1,10 @@
+$: << File.expand_path(File.dirname(__FILE__))
+require "flexrake.rb"
+require "flashmate.rb"    
+
+
+module Flexfarm
+  VERSION = '0.3.2'
+  
+  
+end

data/lib/flexfarm_config.rb

@@ -0,0 +1,51 @@
+module Flexfarm   
+               
+   CONFIG_FILES = [File.expand_path("#{File.dirname(__FILE__)}/default_config.rb"),"/etc/ffarm.conf.rb",File.expand_path("~/.ffarm.conf.rb")]
+   CONFIG_FILES.reverse.each do |file| 
+      if File.exists?(file) 
+         require file 
+         break
+      end
+   end
+
+   def heading( msg, padding=1 )   
+      style = [47,30]
+      heading = "--#{" "*padding}#{msg}#{" "*padding}--"   
+      return "",color("="*(heading.length),*style),color(heading,*style),color("-"*(heading.length),*style)
+   end
+   
+   
+   def color(input,*args)   
+      return input if args.length==0 || ENV["TERM"] !~ /color/
+      "\e[#{args.join(";")}m#{input}\e[0m"
+   end
+   
+   COLOR_MODES = [[30,42],[33],[33]]
+   def verbose_puts(str,mode=0)
+      puts color(str,*COLOR_MODES[mode]) if $verbose_level >= mode
+   end
+   
+   def debugger_output(line)      
+      if m = line.match(/^(\[[^\]]+\])\s?(.+)/)
+         printContext = true
+         argsMessage = [0]
+         args = [33]
+         if (m[1]=="[Fault]")
+            args = [32,41]
+            argsMessage = [31]
+         end
+         if (m[1]=="[trace]")
+            printContext = false
+            argsMessage = [32]
+         end
+         if m[2].match(/^Error/)              
+            argsMessage = [31]
+         end
+         
+         puts (printContext ? color(m[1],*args)+" " : "")+color(m[2],*argsMessage)      
+      else
+         puts color(line.chomp)
+      end
+   end
+   
+end

data/lib/flexrake.rb

@@ -0,0 +1,341 @@
+$: << File.expand_path(File.dirname(__FILE__))
+require "flexfarm_config.rb"
+require 'rake'
+
+module Flexfarm
+module Rake
+   
+   module Tasks 
+      start_time = Time.new
+      task :benchmark do
+         puts "Rake completed in %.2f seconds." % (Time.new-start_time)
+      end
+      
+      task :default => :debug
+      
+      desc "Compile for debugging and preview project"
+      task :debug => [:compileDebug,:copyAssetsDebug,:preview,:benchmark]
+   
+      desc "Compile project for release"
+      task :release => [:clean,:compileRelease,:copyAssetsRelease,:benchmark]
+   
+      desc "Output project settings."
+      task :info do
+         Flexfarm::Rake::each_project do |project|
+            puts heading("Project info for #{project.name}",35),"",project.info   
+         end         
+      end
+            
+      namespace :info do 
+         
+         desc "Output project assets"
+         task :assets do 
+            Flexfarm::Rake::each_project do |project|
+               puts "## #{project.name} (#{project.expand_path(project.basedir)})"
+               project.assets.each { |source_dir| 
+                  puts source_dir.collect {|file| "\t#{file}" }                
+               }
+            end
+         end
+         
+         namespace :command do
+
+            desc "Output compiler-command for debug-build"
+            task :debug do 
+               Flexfarm::Rake::each_project do |project|
+                  project[:debug] = true
+                  project[:optimize] = false
+                  project.define["CONFIG::debug"] = true
+                  project.targets { |target|
+                     puts "","## #{project.name}, #{target.main_src} => #{target.output_file}",target.compile_to(project.debug_dir),""
+                  }
+                  
+               end
+            end
+
+            desc "Output compiler-command for release-build"
+            task :release do 
+               Flexfarm::Rake::each_project do |project|
+                  project[:debug] = false
+                  project[:optimize] = true   
+                  project.define["CONFIG::debug"] = false
+                  project.targets { |target|
+                     puts "","## #{project.name}, #{target.main_src} => #{target.output_file}",target.compile_to(project.debug_dir),""
+                  }
+                  
+               end
+            end
+
+
+         end
+      end
+   
+      desc "Previews project by opening preview file. Requires project to be compiled for debugging."
+      task :preview do
+         project = Flexfarm::Rake::each_project.last
+         if project 
+            if project.air_descriptor
+               system("#{Flexfarm::ADL_BIN} -runtime #{Flexfarm::ADL_RUNTIME} #{project.expand_path("#{project.debug_dir}/#{project.air_descriptor}",true)} #{project.expand_path(project.debug_dir)} &")
+            else
+               system("open", project.expand_path("#{project.debug_dir}/#{project.preview_file}",true) )   
+            end
+         end                           
+      end
+   
+      desc "Compile project for debugging."
+      task :compileDebug do 
+         Flexfarm::Rake::each_project do |project|
+            project[:debug] = true
+            project[:optimize] = false
+            project.define["CONFIG::debug"] = true
+            project.compile_to(project.debug_dir)
+            sleep 0.05
+         end
+      end
+   
+      desc "Compile project for release."
+      task :compileRelease do
+         Flexfarm::Rake::each_project do |project|
+            project[:debug] = false
+            project[:optimize] = true   
+            project.define["CONFIG::debug"] = false
+            project.compile_to(project.release_dir)   
+            sleep 0.05
+         end
+      end
+      
+      desc "Package air application."
+      task :package => [:compileRelease] do
+         puts "Not implemented"
+         project = Flexfarm::Rake::each_project.last         
+         if project && project.air_descriptor
+            app_file = "app.air"
+            password = ""
+            certificate = ""
+            system("#{Flexfarm::ADT_BIN} -package -storetype pkcs12 -storepass #{password} -keystore #{certificate} -keypass #{password} #{app_file} bin-release/Application-app.xml -C #{project.expand_path(project.release_dir)} .")
+         
+         end
+      end
+   
+      desc "Copy all assets to debug-dir."
+      task :copyAssetsDebug do
+         Flexfarm::Rake::each_project do |project|
+            project.assets.each {|a| a.copy_to(project.debug_dir) }
+         end
+      end
+   
+      desc "Copy all assets to release-dir."
+      task :copyAssetsRelease do
+         Flexfarm::Rake::each_project do |project|
+            project.assets.each {|a| a.copy_to(project.release_dir) }
+         end
+      end
+   
+      desc "Remove release-dir and debug-dir."
+      task :clean do
+         Flexfarm::Rake::each_project do |project|
+            time = Time.new.to_i
+            [project.debug_dir,project.release_dir].each do |dir|
+               path = project.expand_path(dir)               
+               FileUtils.mv(path,"/tmp/deleted_#{project.name}_#{File.basename(dir)}_#{time}") if File.exist? path
+            end
+         end
+      end
+   end
+
+
+   @defined_projects = []   
+   def self.each_project(&block)
+      projects = @defined_projects.reverse
+      projects.each(&block) if block_given?
+      projects
+   end      
+   def self.define_project(&block)
+      @defined_projects.push(Project.new(&block))
+   end
+   
+   MXMLC_DEFAULT_ARGS = {
+      :defaultSize => [800,600], 
+      :defaultFrameRate => 25, 
+      :defaultBackgroundColor => "0x9CCA43",
+      :defaultScriptLimits => [15000,60],
+      :strict => true,
+      :benchmark => true
+   }
+
+   class Project
+      
+      attr_accessor :basedir, :release_dir, :debug_dir, :doc_dir, :air_descriptor
+      attr_reader :assets, :libs, :srcs, :args, :define
+      
+      def initialize
+         @basedir = "."
+         @release_dir = "bin-release"
+         @debug_dir = "bin-debug"
+         @doc_dir = "doc"
+         @targets = []
+         @assets = []
+         @libs = []
+         @srcs = []
+         @args = MXMLC_DEFAULT_ARGS
+         @define = {}
+         yield(self) if block_given?
+      end
+      
+      def compile_to(dir)
+         targets do |target|
+            success = system(FLEX_COMPILER,target.compile_to(dir));
+            raise "Compile error." unless success
+         end
+      end
+      
+      def name
+         File.basename(expand_path(@basedir))
+      end
+      
+      def info
+         spacer = " "*14
+         
+         [  color("Basedir     : ",33)+expand_path(@basedir),
+            color("Release-dir : ",33)+@release_dir,
+            color("Debug-dir   : ",33)+@debug_dir,
+            color("Doc-dir     : ",33)+@doc_dir,
+            color("Source-dirs :",33),
+            @srcs.map { |l| spacer+l },
+            color("Libraries   :",33),
+            @libs.map { |l| spacer+l },         
+            color("Arguments   :",33),
+            @args.map{|k,v| spacer+"-#{k}=#{v}" },
+            @define.map{|k,v| "-define=#{k},#{v}" },
+            color("Assets      :",33),
+            @assets.map { |a| spacer+a.to_s  },
+            color("Targets     :",33),
+            @targets.map { |t| spacer+"#{t.main_src} => #{t.output_file}"  },
+            color("Preview     : ",33)+preview_file
+         ]
+      end
+      
+      
+      def []=(k,v)
+         @args[k] = v
+      end
+      def [](k)
+         @args[k]
+      end
+      
+      def preview_file=(str)
+         @preview = str
+      end
+      
+      def preview_file()
+         @preview || targets.last.output_file rescue nil
+      end
+      
+      def add_target(output_file,main_src)
+         target = Target.new(self)
+         target.output_file = output_file
+         target.main_src = main_src
+         @targets << target
+      end
+      
+      def targets(&block)
+         tgts = @targets.reverse
+         tgts.each(&block) if block_given?
+         tgts
+      end
+      
+      def expand_path(path,ensure_existence=false)
+         path = File.expand_path(path,@basedir)
+         raise Exception.new("#{path} was not found") if ensure_existence && !File.exists?(path)
+         raise Exception.new("compiler does not support paths with whitespace (#{path})") if path =~ /\s/
+         return path
+      end   
+      
+   end
+   
+   class Target
+      
+      attr_accessor :output_file
+      attr_accessor :main_src
+      
+      def initialize(project)
+         @project = project
+      end
+      
+      def compile_to(dir)
+         cmd = ["mxmlc"]
+         cmd.push *@project.args.map{|k,v| "-#{transformArgumentKey(k)}=#{transformArgumentValue(v)}" }
+         cmd.push *@project.define.map{|k,v| "-define=#{transformArgumentKey(k)},#{transformArgumentValue(v)}" }
+         cmd.push "-sp", *@project.srcs.map{|p| @project.expand_path(p,true) }
+         cmd.push "-l",  *@project.libs.map{|p| @project.expand_path(p,true) }
+         cmd.push "-o", @project.expand_path("#{dir}/#{output_file}")
+         cmd.push "--", @project.expand_path(main_src,true)
+         cmd.join(" ")      
+      end
+      
+         
+      private
+      
+      def transformArgumentKey(key)
+         if key.class == Symbol
+            key.to_s.gsub(/[A-Z]/,'-\0').downcase 
+         else
+            key
+         end
+      end
+      def transformArgumentValue(value)
+         if value.respond_to? :join
+            value.join(",")
+         else
+            value.to_s
+         end
+      end      
+      
+   end
+   
+   class SourceDir < FileList
+      TO_S_ITEMS = 3
+      
+      attr_reader :root_dir
+      
+      def initialize(rootDir,&block)
+         @root_dir = rootDir
+         @root_dir.taint
+         super(&block)
+      end
+         
+      def resolve_add(fn)      
+         super(@root_dir+"/"+fn)
+      end
+      
+      def to_s()         
+         existing = collect.select { |item| File.exist?(item) }
+         files = existing.select { |item| File.file? item }
+         dirs = existing.select { |item| File.directory? item }
+         combined = (files+dirs)
+         combined[0...TO_S_ITEMS].join(", ")+ (combined.length > TO_S_ITEMS ? "..." : "") +" (#{files.length} files, #{dirs.length} dirs)"
+      end
+      
+      def copy_to(targetdir)
+         targetdir = File.expand_path(targetdir)
+         basedir = File.expand_path(@root_dir)
+         each do |source|
+            target = File.expand_path(source).gsub(basedir,targetdir)
+            copy_item(source,target)
+         end
+      end
+      
+      private
+      def copy_item(source,target)
+         if File.directory?(source) && !File.exist?(target)
+            FileUtils.mkdir_p( target )
+         elsif File.file? source            
+            FileUtils.rm(target) if File.exist?(target) && File.mtime(source) != File.mtime(target)               
+            FileUtils.copy_file(source,target, :preserve => true) unless File.exist? target
+         end      
+      end
+      
+   end
+   
+end
+end

data/lib/generator.rb

@@ -0,0 +1,24 @@
+require 'fileutils'
+
+module Flexfarm   
+
+   def self.create_userconfig
+     require "flexfarm_config"              
+     FileUtils.copy(CONFIG_FILES.first,CONFIG_FILES.last) if !File.exist? CONFIG_FILES.last
+     return File.expand_path(CONFIG_FILES.last)
+   end
+
+   def self.create_rakefile
+      target_file = "./rakefile.rb"
+      if File.exist? target_file
+         puts "Rakefile already exist. #{target_file}"
+      else
+         source_file = "#{File.dirname(__FILE__)}/../rakefile.rb.example"
+         FileUtils.copy(source_file,target_file)
+      end
+      return File.expand_path(target_file)
+   end
+
+
+
+end

data/rakefile.rb.example

@@ -0,0 +1,29 @@
+require "flexfarm"
+
+# 
+##   Project have some default properties,
+##   run 'rake info' to print full configuration.
+#         
+
+Flexfarm::Rake::define_project do |p|
+   p.add_target( "main.swf","src/Main.as" )
+
+   p.preview_file = "index.html"
+   
+   p.srcs << "src" << "lib" << "tests"
+
+   p.libs.push << "lib"\
+               << "#{Flexfarm::FLEX_HOME}/frameworks/libs/flex.swc"\
+               << "#{Flexfarm::FLEX_HOME}/frameworks/libs/utilities.swc"\
+               << "#{Flexfarm::FLEX_HOME}/frameworks/libs/framework.swc"\
+               << "#{Flexfarm::FLEX_HOME}/frameworks/libs/player/9/playerglobal.swc"
+
+   p.assets << Flexfarm::Rake::SourceDir.new("src") { |fl|
+      fl.add "assets","assets/**/*","*.xml","*.swf"
+      fl.exclude(/ Report\.txt$/)
+   }
+   p.assets << Flexfarm::Rake::SourceDir.new("html-template") { |fl|
+      fl.add "**/*"
+   }
+
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: hpeikemo-flexfarm
+version: !ruby/object:Gem::Version 
+  version: 0.3.2
+platform: ruby
+authors: 
+- Hans Petter Eikemo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-05 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: hpeikemo@me.com
+executables: 
+- ffarm
+- ffcompile
+- ffdebugger
+- fffcshd
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- VERSION
+- bin/ffarm
+- bin/ffcompile
+- bin/ffdebugger
+- bin/fffcshd
+- flexfarm.gemspec
+- lib/cliwrapper.rb
+- lib/default_config.rb
+- lib/fcsh.rb
+- lib/fdb.rb
+- lib/flashmate.rb
+- lib/flexfarm.rb
+- lib/flexfarm_config.rb
+- lib/flexrake.rb
+- lib/generator.rb
+- rakefile.rb.example
+has_rdoc: true
+homepage: http://github.com/hpeikemo/flexfarm
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: flexFarm is a set of tools to charge and improve ActionScript development.
+test_files: []
+