airake 0.2.8 → 0.2.9

data/lib/airake/commands/acompc.rb

@@ -18,35 +18,36 @@ module Airake #:nodoc:
       def initialize(options = {})
         @path = options[:acompc_path] || "acompc"
         @extra_opts = options[:acompc_extra_opts]
-        with_options(options, { :source_path => "src" })
-        
-        raise "No output path specified" unless output_path
+        with_options(options, { :source_path => "src" })                
+        assert_required([ :path, :source_path, :output_path, :include_packages ])
+        @include_classes = include_classes        
       end
       
-      def include_classes_option
+      # Find classes list from packages, raises error if result is empty
+      def include_classes
         classes = []
         paths = []
-        include_packages.each do |include_package|
-          path = File.join(source_path, include_package.gsub(".", "/")) + "/**/*.as"
+        @include_packages.each do |include_package|
+          path = File.join(@source_path, include_package.gsub(".", "/")) + "/**/*.as"
           paths << path
           Dir[path].each do |file|
             classes << include_package + "." + File.basename(file).gsub(".as", "")
           end
         end
         raise "No classes found at:\n\t#{paths.join("\n\t")}" if classes.empty?
-        classes.join(" ")
+        classes
       end
             
       # Get the acompc compile command
       def compile
         command = []
-        command << path
+        command << @path
         command << "-source-path"
-        command << source_path
+        command << @source_path
         command << "-include-classes"
-        command << include_classes_option
+        command << @include_classes.join(" ")
         command << "-output"
-        command << output_path        
+        command << @output_path        
         process(command)
       end
             

data/lib/airake/commands/adl.rb

@@ -9,20 +9,21 @@ module Airake #:nodoc:
       
       attr_reader :project, :path, :extra_opts, :appxml_path, :root_dir
       
-      # options:: :adl_path, adl_extra_opts, :appxml_path, :root_dir
+      # options:: :adl_path, :adl_extra_opts, :appxml_path, :root_dir
       def initialize(options = {})
         @path = options[:adl_path] || "adl"
         @extra_opts = options[:adl_extra_opts]
         with_options(options)
+        assert_required([ :path, :appxml_path, :root_dir ])
       end
       
       # Get the ADL launch command
       def launch
         command = []
-        command << path
-        command << extra_opts
-        command << escape(appxml_path)
-        command << escape(root_dir)
+        command << @path
+        command << @extra_opts
+        command << escape(@appxml_path)
+        command << escape(@root_dir)
         process(command)
       end      
       

data/lib/airake/commands/adt.rb

@@ -14,21 +14,20 @@ module Airake #:nodoc:
         @path = options[:adt_path] || "adt"
         @extra_opts = options[:adt_extra_opts]
         with_options(options)
+        assert_required([ :path, :base_dir, :air_path, :appxml_path, :swf_path ])
       end
             
       # Get the ADT package command
       def package
-        raise ArgumentError, "Must specify :base_dir" unless base_dir
-        
         command = []
-        command << path
-        command << extra_opts
+        command << @path
+        command << @extra_opts
         command << "-package"
-        command << "-certificate #{certificate}" unless certificate.blank?
-        command << escape(relative_path(air_path, base_dir))
-        command << escape(relative_path(appxml_path, base_dir))
-        command << escape(relative_path(swf_path, base_dir))
-        command << assets
+        command << "-certificate #{certificate}" unless @certificate.blank?
+        command << escape(relative_path(@air_path, @base_dir))
+        command << escape(relative_path(@appxml_path, @base_dir))
+        command << escape(relative_path(@swf_path, @base_dir))
+        command << @assets unless @assets.nil?
         process(command)
       end
       

data/lib/airake/commands/amxmlc.rb

@@ -7,47 +7,55 @@ module Airake #:nodoc:
     # http://livedocs.adobe.com/labs/air/1/devappsflex/help.html?content=CommandLineTools_2.html#1032546
     class Amxmlc < Base
       
-      attr_reader :path, :extra_opts, :swf_path, :mxml_path, :lib_dir, :src_dir, :test_dir, :debug_option
+      attr_reader :path, :extra_opts, :swf_path, :mxml_path, :lib_dir, :src_dirs, :debug
       
-      # options:: :amxmlc_path, :amxmlc_extra_opts, :swf_path, :mxml_path, :lib_dir, :src_dir, :test_dir, :debug_option
+      # options:: :amxmlc_path, :amxmlc_extra_opts, :swf_path, :mxml_path, :lib_dir, :src_dirs, :debug
       def initialize(options = {})
         @path = options[:amxmlc_path] || "mxmlc +configname=air"
         @extra_opts = options[:amxmlc_extra_opts]
-        with_options(options)        
+        with_options(options)               
+        assert_required([ :path, :swf_path, :mxml_path ])
+        @source_paths = source_paths
+        raise ArgumentError, "There aren't any valid source directories to compile" if @source_paths.empty?                
+        @library_path = library_path
       end
             
       # Get the amxmlc compile command
       def compile
         command = []
-        command << path
-        command << source_path_option
-        command << library_path_option
+        command << @path
+        command << "-source-path #{@source_paths.join(" ")}"
+        command << "-library-path+=#{@library_path}"
         command << "-output"
-        command << escape(swf_path)
-        command << debug_option
-        command << extra_opts      
+        command << escape(@swf_path)
+        command << "-debug=#{@debug}" unless @debug.nil?
+        command << @extra_opts      
         #command << "-disable-incremental-optimizations=true"  
         command << "--"
-        command << escape(mxml_path)
+        command << escape(@mxml_path)
         process(command)
       end
       
     protected
       
-      def source_path_option      
+      def source_paths
+        source_paths = []
         # List of directories in lib/ for source_path +=
-        lib_source_paths = Dir["#{lib_dir}/*"].collect { |f| escape(f) if File.directory?(f) }.compact       
-        lib_source_paths << escape(test_dir) if test_dir and File.directory?(test_dir)
-        lib_source_paths << escape(src_dir) if src_dir and File.directory?(src_dir)
-
-        source_paths ||= lib_source_paths
-        source_paths.empty? ? "" : "-source-path #{source_paths.join(" ")}"
+        if @lib_dir and File.directory?(@lib_dir) 
+          Dir["#{@lib_dir}/*"].collect { |f| escape(f) if File.directory?(f) }.compact 
+        end
+        
+        @src_dirs.each do |src_dir|
+          if File.directory?(src_dir)
+            source_paths << escape(src_dir) 
+          else
+            raise "Source directory: #{src_dir} is not a directory or does not exist"
+          end
+        end
       end
 
-      def library_path_option
-        library_paths = []      
-        library_paths << escape(lib_dir) if lib_dir and File.directory?(lib_dir)
-        library_paths.empty? ? "" : "-library-path+=#{library_paths.join(" ")}"
+      def library_path
+        escape(@lib_dir) if @lib_dir and File.directory?(@lib_dir)
       end
       
     end

data/lib/airake/commands/base.rb

@@ -24,7 +24,8 @@ module Airake #:nodoc:
       
       def with_options(options, defaults = {}) 
         options.each do |key, value|
-          instance_variable_set("@#{key}", value)
+          raise "Invalid option: '#{key}' for command: #{self.class}" unless respond_to?(key.to_sym)
+          instance_variable_set("@#{key}", value)          
         end
         
         defaults.each do |key, value|
@@ -33,6 +34,12 @@ module Airake #:nodoc:
         end
       end
       
+      def assert_required(vars)        
+        vars.each do |var|
+          raise ArgumentError, "Must specify option: #{var}" if instance_variable_get("@#{var}").nil?
+        end
+      end
+      
     end
     
   end

data/lib/airake/project.rb

@@ -5,9 +5,8 @@ module Airake #:nodoc
   
     attr_reader :base_dir, :bin_dir, :src_dir, :lib_dir, :test_dir
     attr_reader :mxml_path, :appxml_path, :air_path, :swf_path
-    attr_reader :debug
-    attr_reader :options
-    attr_reader :assets
+    attr_reader :debug, :assets, :certificate
+    attr_reader :build_env
     
     # Options to override defaults
     Options = [ :certificate, :assets, :amxmlc_path, :adt_path, :adt_path, :bin_dir, :src_dir, :lib_dir, :test_dir, 
@@ -18,7 +17,7 @@ module Airake #:nodoc
     # base_dir:: Base (project) directory
     # mxml_path: Path to the project.mxml (relative)
     # options:: Override default paths, commands, extra opts, etc; See Options class var
-    def initialize(base_dir, mxml_path, options = {})
+    def initialize(base_dir, mxml_path, options = {}, build_env = :normal)
       raise ArgumentError, "Invalid MXML path: #{mxml_path}" if mxml_path.blank?
       
       mxml_dir = File.expand_path(File.dirname(mxml_path))
@@ -26,7 +25,7 @@ module Airake #:nodoc
       
       @base_dir = base_dir
       @mxml_path = File.join(mxml_dir, "#{project_name}.mxml")
-      @options = options
+      @build_env = build_env
       
       @bin_dir = options[:bin_dir] || File.join(base_dir, "bin")
       @src_dir = options[:src_dir] || File.join(base_dir, "src")
@@ -40,51 +39,72 @@ module Airake #:nodoc
       @swf_path = options[:swf_path] || File.join(@bin_dir, "#{project_name}.swf")
     
       # Debug options
-      @debug = options[:debug].is_a?(TrueClass) || options[:debug] == "true"      
+      @debug = options[:debug].is_a?(TrueClass) || options[:debug] == "true"                  
+      
+      @assets = options[:assets]
+      @certificate = options[:certificate]
     end
     
     # Flex compiler command for this project
     def amxmlc
-      options = @options.merge({ :swf_path => swf_path, :mxml_path => mxml_path, :lib_dir => lib_dir, 
-        :src_dir => src_dir, :test_dir => test_dir, :debug_option => debug_option })      
+      src_dirs = case build_env
+        when :normal then [ @src_dir ]
+        when :test then [ @src_dir, @test_dir ]
+        else raise "Invalid build_env setting: #{build_env}"
+        end
+
+      options = { :swf_path => @swf_path, :mxml_path => @mxml_path, :lib_dir => @lib_dir, 
+        :src_dirs => src_dirs, :debug => @debug }
+        
       Airake::Commands::Amxmlc.new(options)
     end
     
     # ADL command for this project
     def adl
-      options = @options.merge({ :appxml_path => appxml_path, :root_dir => base_dir })
+      options = { :appxml_path => @appxml_path, :root_dir => @base_dir }
       Airake::Commands::Adl.new(options)
     end
     
     # ADT command for this project
     def adt
-      options = @options.merge({ :air_path => air_path, :appxml_path => appxml_path, :swf_path => swf_path, :base_dir => base_dir })
+      options = { :air_path => @air_path, :appxml_path => @appxml_path, :swf_path => @swf_path, 
+        :base_dir => @base_dir, :assets => @assets, :certificate => @certificate  }
       Airake::Commands::Adt.new(options)
     end
+    
+    # List of files to remove on clean
+    def to_clean
+      case build_env
+      when :normal then [ swf_path, air_path ]
+      when :test then [ swf_path ]
+      end
+    end
         
     # Create project using parameters from rake ENV
+    # 
+    # This shouldn't really be here, but a Rakefile is a bad place to be :O
     #
     # You can set any of the options via ENV; just upcase it. <tt>:foo_bar => ENV["FOO_BAR"]</tt>
     #
     # Booleans must be "true" for true
-    def self.new_from_rake(env, is_test = false)
+    def self.new_from_rake(env, build_env = :normal)
       base_dir = env["BASE_DIR"]
-      mxml = is_test ? env["MXML_TEST"] : env["MXML"]
+      mxml = case build_env
+        when :test then env["MXML_TEST"]
+        when :normal then env["MXML"]
+        else raise "Invalid build env: #{build_env}"
+        end
       
       # For any option check to see if its in the ENV      
       options = {}
       Options.each do |option_key|
-        env_key = option_key.to_s.upcase
+        env_key = option_key.to_s.upcase      
         options[option_key] = env[env_key] if env.has_key?(env_key)
       end
       #puts "Using options: #{options.inspect}" unless options.empty?
-      self.new(base_dir, mxml, options)
+      self.new(base_dir, mxml, options, build_env)
     end
     
-    def debug_option
-      "-debug=#{@debug}" if @debug
-    end    
-    
   end
   
 end

data/lib/airake/runner.rb

@@ -7,23 +7,25 @@ module Airake #:nodoc:
     attr_reader :output, :cmd, :took, :process
 
     def initialize(cmd)
-      @cmd = RUBY_PLATFORM =~ /win32/ ? "cmd.exe /c #{cmd}" : cmd
+      @cmd = RUBY_PLATFORM =~ /win32/ ? "cmd.exe /c #{cmd}" : "#{cmd} 2>&1"
     end
     
     def run(verbose = true)
-      puts "Running: #{cmd}" if verbose
+      puts "Running: #{@cmd}" if verbose
       
       t1 = Time.now
-      IO.popen(@cmd) do |f|
-        @output = f.read
-        @process = Process.waitpid2(f.pid)[1]
+      IO.popen(@cmd) do |f|                        
+        while s = f.read(1)
+          printf s
+          STDOUT.flush
+        end
       end
+      @process = $?
       @took = Time.now - t1
       
       if verbose
-        puts output
         success? or fail
-        puts "Took %.2fs" % [ took ]
+        #puts "Took %.2fs" % [ @took ]
       end
     end
     

data/lib/airake/tasks/air.rake

@@ -15,7 +15,7 @@ namespace :air do
   desc "Test"
   task :test => :clean do
     ENV["DEBUG"] = "true" unless ENV.has_key?("DEBUG")
-    test_project = Airake::Project.new_from_rake(ENV, true)
+    test_project = Airake::Project.new_from_rake(ENV, :test)
     Airake::Runner.run(test_project.amxmlc, :compile)
     Airake::Runner.run(test_project.adl, :launch)
   end
@@ -135,11 +135,11 @@ namespace :air do
   desc "Clean"
   task :clean do 
     project = Airake::Project.new_from_rake(ENV)
-    paths = [ project.swf_path, project.air_path ]
+    paths = project.to_clean
     
     # Test 
-    test_project = Airake::Project.new_from_rake(ENV, true)
-    paths += [ test_project.swf_path ]
+    test_project = Airake::Project.new_from_rake(ENV, :test)
+    paths += project.to_clean
     
     paths.each do |path|
       FileUtils.rm(path, :verbose => true) if File.exist?(path)

data/lib/airake/version.rb

@@ -2,7 +2,7 @@ module Airake #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 2
-    TINY  = 8
+    TINY  = 9
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: airake
 version: !ruby/object:Gem::Version 
-  version: 0.2.8
-date: 2007-11-07 00:00:00 -05:00
+  version: 0.2.9
+date: 2007-11-09 00:00:00 -05:00
 summary: Tasks and generators for Adobe AIR apps
 require_paths: 
 - lib