sprout 0.5.29 → 0.7.153

data/lib/sprout/generator/base_mixins.rb

@@ -0,0 +1,132 @@
+
+module Rails # :nodoc:[all]
+  module Generator # :nodoc:[all]
+
+    class Base # :nodoc:[all]
+
+      def initialize(runtime_args, runtime_options = {})
+        @args = runtime_args
+        parse!(@args, runtime_options)
+
+        # Derive source and destination paths.
+        @source_root = options[:source] || File.join(spec.path, 'templates')
+        
+        if options[:destination]
+          @destination_root = options[:destination]
+        # The following two lines were changed:
+        #elsif defined? ::RAILS_ROOT
+        #  @destination_root = ::RAILS_ROOT
+        elsif defined? Sprout::Sprout.project_path
+          @destination_root = Sprout::Sprout.project_path
+        else
+          @destination_root = Dir.pwd
+        end
+
+        # Silence the logger if requested.
+        logger.quiet = options[:quiet]
+
+        # Raise usage error if help is requested.
+        usage if options[:help]
+      end
+
+    end
+
+    # GemGeneratorSource hits the mines to quarry for generators.  The latest versions
+    # of gems named sprout-#{sprout_name}-bundle are selected.
+    class GemGeneratorSource < AbstractGemSource # :nodoc:[all]
+      
+      def initialize(name=nil)
+        super()
+        @sprout_name = name
+      end
+
+      # Yield latest versions of generator gems.
+      def each
+        Gem::cache.search(/sprout-*#{@sprout_name}-bundle$/).inject({}) { |latest, gem|
+          hem = latest[gem.name]
+          latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+          latest
+        }.values.each { |gem|
+          yield Spec.new(gem.name.sub(/sprout-*#{@sprout_name}-bundle$/, ''), gem.full_gem_path, label)
+        }
+      end
+
+      def each_sprout
+        Gem::cache.search(/^sprout-.*/).inject({}) { |latest, gem|
+          hem = latest[gem.name]
+          latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+          latest
+        }.values.each { |gem|
+          yield Spec.new(gem.name, gem.full_gem_path, label)
+        }
+      end
+    end
+
+    # GemPathSource looks for generators within any RubyGem's 
+    # /sprout/generators/<generator_name>/<generator_name>_generator.rb file.
+    # It will only include generators from sprouts whose name includes
+    # #{sprout_name}-bundle
+    class GemPathSource < AbstractGemSource # :nodoc:[all]
+      
+      def initialize(name=nil)
+        super()
+        @sprout_name = name
+      end
+
+      # Yield each generator within rails_generator subdirectories.
+      def each
+        generator_full_paths.each do |generator|
+          yield Spec.new(File.basename(generator).sub(/_generator.rb$/, ''), File.dirname(generator), label)
+        end
+      end
+
+      private
+        def generator_full_paths
+          @generator_full_paths ||=
+            Gem::cache.inject({}) do |latest, name_gem|
+              name, gem = name_gem
+              hem = latest[gem.name]
+              latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+              latest
+            end.values.inject([]) do |mem, gem|
+              Dir[gem.full_gem_path + '/lib/sprout/**/generators/**/*_generator.rb'].each do |generator|
+                if(@sprout_name && gem.name.match(/sprout-#{@sprout_name}-bundle/))
+                  mem << generator
+                end
+              end
+              mem
+            end
+        end
+    end
+
+    module Lookup # :nodoc:[all]
+      module ClassMethods # :nodoc:[all]
+        
+        def use_sprout_sources!(sprout_name, project_path=nil)
+          reset_sources
+
+          # Project-specific generator paths
+          if project_path
+            sources << PathSource.new(:project, "#{project_path}/generators")
+            sources << PathSource.new(:script, "#{project_path}/script/generators")
+            sources << PathSource.new(:vendor, "#{project_path}/vendor/generators")
+          end
+
+          # System-wide generator paths
+          system_path = "#{Sprout::Sprout.sprout_cache}/generators/#{sprout_name}"
+          if(File.exists?(system_path))
+            sources << PathSource.new(:system, system_path)
+          end
+
+          # Gem generators will collect all
+          # rubygems that end with -bundle or -generators
+          if(Object.const_defined?(:Gem))
+            sources << GemGeneratorSource.new(sprout_name)
+            sources << GemPathSource.new(sprout_name)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/sprout/generator/named_base.rb

@@ -0,0 +1,216 @@
+
+module Sprout
+  module Generator #:nodoc:
+    
+    class NamedBaseError < StandardError #:nodoc:
+    end
+    
+    # The NamedBase is a good default base class for ActionScript class Generators.
+    # This class will accept the first command line argument and create
+    # many helpful properties for concrete generators to use.
+    #
+    # Can accept class names in following formats:
+    #   * src/package/package/ClassName.as
+    #   * test/package/package/ClassName.as
+    #   * package/package/ClassName
+    #   * package.package.ClassName
+    #
+    # Regardless of which format the name was sent in, the helper
+    # methods should provide valid results
+    #
+    class NamedBase < Rails::Generator::Base
+
+      # Fully qualified class named including package name like 'flash.display.Sprite'
+      attr_reader :full_class_name
+      # Path to the class file relative to your src_dir like 'flash/display/Sprite.as'
+      attr_reader :class_file
+      # The directory that contains the file, relative to your src_dir like 'flash/diplay'
+      attr_reader :class_dir
+      # The unqualified name of the class like 'Sprite'
+      attr_reader :class_name
+      # The package name of the class like 'flash.display'
+      attr_reader :package_name
+
+      def initialize(runtime_args, runtime_options = {})
+        super
+
+        rakefile = Sprout.project_rakefile
+        if(rakefile && File.exists?(rakefile))
+           load rakefile
+        end
+        @model = ProjectModel.instance
+
+        # Had to stop throwing on no args because the suite generator does
+        # not require the user to send in a class name....
+        #usage("Final argument must be a name parameter") if runtime_args.empty?
+        @args = runtime_args.dup
+        assign_names! @args.shift
+      end
+
+      # Quick access to the source directory identified by your project model
+      def src_dir
+        return model.src_dir
+      end
+      
+      # Quick access to the test directory identified by your project model
+      def test_dir
+        return model.test_dir
+      end
+      
+      # Quick access to the library directory identified by your project model
+      def lib_dir
+        return model.lib_dir
+      end
+      
+      # The path to your project. This will either be the directory from which
+      # the sprout gem was executed, or the nearest ancestor directory that
+      # contains a properly named rakefile.
+      def project_path
+        return model.project_path
+      end
+      
+      # The project_name that was either sent to the sprout gem or 
+      # defined in your rakefile project model
+      def project_name
+        @project_name ||= (Sprout.project_name || model.project_name)
+      end
+      
+      # The technology language that is stored in your project model usually (as2 or as3)
+      def language
+        return model.language
+      end
+
+      # Name of possible test case for this class_name
+      def test_case_name
+        @test_case_name ||= class_name + 'Test'
+      end
+      
+      # Full name of the possible test case for this class_name
+      def full_test_case_name
+        full_class_name + 'Test'
+      end
+
+      # Full path to the parent directory that contains the class
+      # like 'src/flash/display' for flash.display.Sprite class.
+      def full_class_dir
+        @full_class_dir ||= File.join(src_dir, class_dir)
+        # pull trailing slash for classes in the root package
+        @full_class_dir.gsub!(/\/$/, '')
+        @full_class_dir
+      end
+
+      # Full path to the class file from your project_path like 'src/flash/display/Sprite.as'
+      def full_class_path
+        @full_class_path ||= File.join(src_dir, class_file)
+      end
+
+      # Filesystem path to the folder that contains the TestCase file
+      def full_test_dir
+        @full_test_dir ||= full_class_dir.gsub(src_dir, test_dir)
+      end
+        
+      # Filesystem path to the TestCase file
+      def full_test_case_path
+        @full_test_case_path ||= File.join(full_test_dir, test_case_name + '.as')
+      end
+      
+      def instance_name
+        name = class_name.dup;
+        char = name[0, 1]
+        name[0, 1] = char.downcase
+        if(name.size > 10)
+          name = 'instance'
+        end
+        return name
+      end
+
+      # Will return whether the user originally requested a class name
+      # that looks like a test case (e.g., name.match(/Test$/) )
+      def user_requested_test
+        @user_requested_test ||= false
+      end
+
+      # Glob that is used to search for test cases and build 
+      # up the test suites
+      def test_glob
+        return @test_glob ||= '**/**/*Test.as'
+      end
+      
+      def test_glob=(glob)
+        @test_glob = glob
+      end
+
+      # Collection of all test case files either assigned or found
+      # using the test_glob as provided.
+      def test_cases
+        @test_cases ||= Dir.glob(test_dir + test_glob)
+      end
+      
+      def test_cases=(collection)
+        @test_cases = collection
+      end
+      
+      # Get the list of test_cases (which are files) as a 
+      # list of fully qualified class names
+      def test_case_classes
+        @test_case_classes = self.test_cases.dup
+        @test_case_classes.collect! do |file|
+          actionscript_file_to_class_name(file)
+        end
+        @test_case_classes
+      end
+
+      # Transform a file name in the source or test path
+      # to a fully-qualified class name
+      def actionscript_file_to_class_name(file)
+        name = file.dup
+        name.gsub!(/^#{Dir.pwd}\//, '')
+        name.gsub!(/^#{test_dir}\//, '')
+        name.gsub!(/^#{src_dir}\//, '')
+        name.gsub!(/.as$/, '')
+        name.gsub!(/#{File::SEPARATOR}/, '.')
+        return name
+      end
+      
+      protected
+
+      def banner
+        "Usage: #{$0} [options] packagename.ClassName"
+      end
+
+      def model
+        @model ||= ProjectModel.instance
+      end
+
+      def assign_names!(name)
+        # trim file name suffix in case it was submitted
+        name.gsub!(/\//, '.')
+        name.gsub!(/\.as$/, '')
+        name.gsub!(/\.mxml$/, '')
+        if(model)
+          # Pull leading src_dir from class name if submitted
+          name.gsub!(/^#{src_dir}\./, '')
+          name.gsub!(/^#{test_dir}\./, '')
+        end
+
+        if(name.match(/Test$/))
+          @user_requested_test = true
+          name = name.gsub(/Test$/, '')
+        end
+        if(name.match(/^I/) || name.match(/able$/))
+          @user_requested_interface = true
+        end
+
+        @full_class_name = name
+        parts = name.split('.')
+        @class_name = parts.pop
+        @package_name = parts.join('.')
+        @class_file = @full_class_name.split('.').join(File::SEPARATOR) + '.as'
+        @class_dir = File.dirname(@class_file)
+        if(@class_dir == '.')
+          @class_dir = ''
+        end
+      end
+    end
+  end
+end

data/lib/sprout/generator.rb

@@ -0,0 +1,6 @@
+gem 'activesupport', '>= 2.0.2'
+require 'rails_generator'
+require 'sprout/generator/base_mixins'
+require 'sprout/generator/named_base'
+
+# This is the entry point for sprout generator features

data/lib/{log.rb → sprout/log.rb}

@@ -1,7 +1,7 @@
 
-module PatternPark
+module Sprout #:nodoc:
   
-  class Log
+  class Log #:nodoc:
     @@debug = false
     @@output = ''
     @@printout = ''

data/lib/sprout/process_runner.rb

@@ -0,0 +1,46 @@
+
+module Sprout #:nodoc:
+  class ProcessRunnerError < StandardError # :nodoc:
+  end
+  
+  class ProcessRunner #:nodoc:
+    attr_reader :pid,
+                :r,
+                :w,
+                :e
+    
+    def initialize(*command)
+      @command = command
+      begin
+        usr = User.new()
+        if(usr.is_a?(WinUser) && !usr.is_a?(CygwinUser))
+          require 'win32/open3'
+          Open3.popen3(*@command) do |w, r, e, pid|
+          	@w = w
+          	@r = r
+          	@e = e
+          	@pid = pid
+          end
+        else
+          require 'open4'
+          @pid, @w, @r, @e = open4.popen4(*@command)
+        end
+      rescue Errno::ENOENT => e
+        part = command[0].split(' ').shift
+        raise ProcessRunnerError.new("The expected executable was not found for command [#{part}], please check your system path and/or sprout definition")
+      end
+    end
+    
+    def puts(msg)
+      @w.puts(msg)
+    end
+
+    def read
+      return r.read
+    end
+    
+    def read_err
+      return e.read
+    end
+  end
+end

data/lib/sprout/project_model.rb

@@ -0,0 +1,114 @@
+
+module Sprout
+  
+  # The ProjectModel gives you a place to describe your project so that you
+  # don't need to repeat yourself throughout a rakefile.
+  #
+  # The default set of properties are also used from code generators, library tasks and sometimes tools.
+  #
+  # This class should have some reasonable default values, but can be modified from any rakefile.
+  # If you don't find some properties that you'd like on the ProjectModel, you can simply add 
+  # new properties and use them however you wish!
+  class ProjectModel < Hash
+  
+    # The real name of the project, usually capitalized like a class name 'SomeProject'
+    attr_accessor :project_name
+    # The relative path to your main source directory. Defaults to 'src'
+    attr_accessor :src_dir
+    # The relative path to your library directory. Defaults to 'lib'
+    #
+    # Any remote .SWC and source libraries that are referenced in your rakefile will be installed
+    # into this directory. Source libraries will be placed in a folder that matches the library name,
+    # while SWCs will be simply placed directly into the lib_dir.
+    attr_accessor :lib_dir
+    # The folder where binary files will be created. Usually this is where any build artifacts like SWF files get placed.
+    attr_accessor :bin_dir
+    # Relative path to the folder that contains your test cases
+    attr_accessor :test_dir
+    # Relative path to the folder where compile time assets will be stored
+    attr_accessor :asset_dir
+    # The folder where compile time skins can be loaded from
+    attr_accessor :skin_dir
+    # The technology language that is being used, right now this is either 'as2' or 'as3'.
+    # Code generators take advantage of this setting to determine which templates to use.
+    attr_accessor :language
+
+    # TODO: Add clean hash interface so that users
+    # can simply add to this object's properties like:
+    # model.foo = 'bar'
+    # model.junk = true
+    # and then just as easily reference those vars from
+    # external generators...  
+    def self.instance
+      @@instance ||= ProjectModel.new
+    end
+    
+    def self.destroy # :nodoc:
+      @@instance = nil
+    end
+  
+    def initialize
+      super
+      @project_name   = ''
+      @src_dir        = 'src'
+      @lib_dir        = 'lib'
+      @bin_dir        = 'bin'
+      @test_dir       = 'test'
+      @asset_dir      = 'assets'
+      @skin_dir       = File.join(@asset_dir, 'skins')
+
+      @language       = 'as3'
+
+      @model_dir      = nil
+      @view_dir       = nil
+      @controller_dir = nil
+    end
+    
+    # Path to the project directory from which all other paths are created
+    def project_path
+      return Sprout.project_path
+    end
+    
+    def model_dir=(dir)
+      @model_dir = dir
+    end
+
+    # Simple MVC helper for project-wide models if your project is called 'SomeProject'
+    # this will default to:
+    #   SomeProject/src/someproject/models
+    def model_dir
+      if(@model_dir.nil?)
+        @model_dir = File.join(src_dir, project_name.downcase, 'models')
+      end
+      return @model_dir
+    end
+    
+    def view_dir=(dir)
+      @view_dir = dir
+    end
+
+    # Simple MVC helper for project-wide views if your project is called 'SomeProject'
+    # this will default to:
+    #   SomeProject/src/someproject/views
+    def view_dir
+      if(@view_dir.nil?)
+        @view_dir = File.join(src_dir, project_name.downcase, 'views')
+      end
+      return @view_dir
+    end
+    
+    def controller_dir=(dir)
+      @controller_dir = dir
+    end
+
+    # Simple MVC helper for project-wide views if your project is called 'SomeProject'
+    # this will default to:
+    #   SomeProject/src/someproject/controllers
+    def controller_dir
+      if(@controller_dir.nil?)
+        @controller_dir = File.join(src_dir, project_name.downcase, 'controllers')
+      end
+      return @controller_dir
+    end
+  end
+end

data/lib/{remote_file_loader.rb → sprout/remote_file_loader.rb}

@@ -1,45 +1,52 @@
-require 'open-uri'
 
-module PatternPark
-  class RemoteFileLoader
+module Sprout
+  class RemoteFileLoaderError < StandardError #:nodoc:
+  end
+  
+  class RemoteFileLoader #:nodoc:
     include Archive::Tar
     
-    def get_remote_file(uri, target)
-      if(Sprout.update || !File.exists?(target))
-        begin
-          response = fetch(uri.to_s)
-        rescue SocketError => e
-          puts "[ERROR] Unable to connect to #{uri}"
-          return
-        end
-        FileUtils.makedirs(File.dirname(target))
-
-        if(Sprout.update && File.exists?(target))
-          File.delete(target)
-        end
-
-        File.open(target, 'wb') do |f|
-          f.write(response)
+    def get_remote_file(uri, target, force=false, md5=nil)
+      if(force || !File.exists?(target))
+        response = fetch(uri.to_s)
+        if(response_is_valid?(response, md5))
+          write(response, target, force)
         end
       end
     end
     
-    def fetch(location)
-      uri = URI.parse(location)
-
+    def response_is_valid?(response, expected_md5sum=nil)
+      if(expected_md5sum)
+        md5 = Digest::MD5.new
+        md5 << response
+        raise BadCheckSum if (expected_md5sum != md5.hexdigest)
+      end
+      return true
+    end
+    
+    def write(response, target, force=false)
+      FileUtils.makedirs(File.dirname(target))
+      if(force && File.exists?(target))
+        File.delete(target)
+      end
+      File.open(target, 'wb') do |f|
+        f.write(response)
+      end
+    end
+    
+    def fetch(uri)
+      uri = URI.parse(uri)
       # Download the file now to the downloads dir
       # If the file is an archive (zip, gz, tar, tar.gz, dmg), extract to
-      # AsProject/remote_files/@name/@location
+      # Sprouts/cache/@type/@name
       # Check the location again...
       progress = nil
       response = nil
-      head = nil
       name = uri.path.split("/").pop
-
-      raise UsageError.new("The RemoteFileTask failed for #{name}. WE can only handle HTTP requests at this time, it seems you were trying: #{location}") if uri.scheme != 'http'
       
-
-      open(uri.to_s, :content_length_proc => lambda {|t|
+      raise RemoteFileLoaderError.new("The RemoteFileTask failed for #{name}. We can only handle HTTP requests at this time, it seems you were trying: '#{uri.scheme}'") if uri.scheme != 'http'
+      begin
+        open(uri.to_s, :content_length_proc => lambda {|t|
           if t && t > 0
             progress = ProgressBar.new(name, t)
             progress.file_transfer_mode
@@ -56,8 +63,15 @@ module PatternPark
           response = f.read
           progress.finish
         }
-        
-        return response
+      rescue SocketError => e
+        raise RemoteFileLoaderError.new("[ERROR] #{e.to_s}")
+      rescue OpenURI::HTTPError => e
+        raise RemoteFileLoaderError.new("[ERROR] Failed to load file from: '#{uri.to_s}'\n[REMOTE ERROR] #{e.io.read.strip}")
+      rescue Errno::ECONNREFUSED => e
+        raise Errno::ECONNREFUSED.new("[ERROR] Connection refused at: '#{uri.to_s}'")
+      end
+
+      return response
     end
     
     def unpack_downloaded_file(file_name, dir)
@@ -72,7 +86,10 @@ module PatternPark
           # just copy the swc...
         elsif(is_rb?(file_name))
           return
-        elsif(!is_exe?(file_name))
+        elsif(is_exe?(file_name))
+          FileUtils.mkdir_p(dir)
+          File.mv(file_name, dir)
+        else
           raise UsageError.new("RemoteFileTask does not know how to unpack files of type: #{file_name}")
         end
       end
@@ -84,7 +101,11 @@ module PatternPark
       if(RUBY_PLATFORM =~ /darwin/)
           # Unzipping on OS X
           FileUtils.makedirs(dir)
-          %x(cd #{dir};unzip #{zip_file})
+          zip_dir = File.expand_path(File.dirname(zip_file))
+          zip_name = File.basename(zip_file)
+          output = File.expand_path(dir)
+          #puts ">> zip_dir: #{zip_dir} zip_name: #{zip_name} output: #{output}"
+          %x(cd #{zip_dir};unzip #{zip_name} -d #{output})
       else
         retries = 0
         begin
@@ -93,7 +114,7 @@ module PatternPark
             zf.each do |e|
               fpath = File.join(dir, e.name)
               FileUtils.mkdir_p(File.dirname(fpath))
-              # Disgusting, Gross Hack to fix Windows/Ruby Bug
+              # Disgusting, Gross Hack to fix DOS/Ruby Bug
               # That makes the zip library throw a ZipDestinationFileExistsError
               # When the zip archive includes two files whose names 
               # differ only by extension.
@@ -130,6 +151,15 @@ module PatternPark
       end
       tar = Zlib::GzipReader.new(File.open(tgz_file, 'rb'))
       Minitar.unpack(tar, dir)
+      
+      # Recurse and unpack gzipped children (Adobe did this double 
+      # gzip with the Linux FlashPlayer for some reason)
+      Dir.glob("#{dir}/**/*.tar.gz").each do |child|
+        if(child != tgz_file)
+          unpack_targz(child, File.dirname(child))
+        end
+      end
+      
     end
     
     # This is actually not unpacking the FlashPlayer
@@ -155,12 +185,9 @@ module PatternPark
         # Copy the DMG contents using system copy rather than ruby utils
         # Because OS X does something special with .app files that the
         # Ruby FileUtils and File classes break...
-        Log.puts '=================='
         from = mounted_target
 #        from = File.join(full_mounted_path, extracted_file)
         to = File.join(@user.downloads, @name.to_s, extracted_file)
-        Log.puts 'from: ' + from
-        Log.puts 'to: ' + to
         FileUtils.makedirs(File.dirname(to))
         
         if(File.exists?(from))