sprout 0.7.220-x86-darwin-10

data/lib/sprout/generator/base_mixins.rb

@@ -0,0 +1,186 @@
+
+class Gem::SourceIndex
+  
+  # This feature seems to be getting deprecated from the latest
+  # gems releases (1.3.x). 
+  # We actually need it and don't want the nagging - so,
+  # copied sources from RubyGems SVN trunk, and mixing in...
+  # :-(
+  # There should be a more stable integration point with RubyGems
+  # Any ideas or contributions are welcome!
+  def sprout_search(gem_pattern, platform_only = false)
+    version_requirement = nil
+    only_platform = false
+
+    # unless Gem::Dependency === gem_pattern
+    #   warn "#{Gem.location_of_caller.join ':'}:Warning: Gem::SourceIndex#search support for #{gem_pattern.class} patterns is deprecated"
+    # end
+
+    case gem_pattern
+    when Regexp then
+      version_requirement = platform_only || Gem::Requirement.default
+    when Gem::Dependency then
+      only_platform = platform_only
+      version_requirement = gem_pattern.version_requirements
+      gem_pattern = if Regexp === gem_pattern.name then
+                      gem_pattern.name
+                    elsif gem_pattern.name.empty? then
+                      //
+                    else
+                      /^#{Regexp.escape gem_pattern.name}$/
+                    end
+    else
+      version_requirement = platform_only || Gem::Requirement.default
+      gem_pattern = /#{gem_pattern}/i
+    end
+
+    unless Gem::Requirement === version_requirement then
+      version_requirement = Gem::Requirement.create version_requirement
+    end
+
+    specs = @gems.values.select do |spec|
+      spec.name =~ gem_pattern and
+        version_requirement.satisfied_by? spec.version
+    end
+
+    if only_platform then
+      specs = specs.select do |spec|
+        Gem::Platform.match spec.platform
+      end
+    end
+    
+    begin
+      specs.sort_by { |s| s.sort_obj }
+    rescue NoMethodError => e
+      puts "It looks like your RubyGems installation is not compatible with this version of Sprouts.\n\nTo update, run:\ngem update --system\n\n"
+      raise e
+    end
+  end
+end
+
+module RubiGen # :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]
+      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.sprout_search(/sprout-*#{@sprout_name}-bundle$/).inject({}) do |latest, gem|
+        hem = latest[gem.name]
+        latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+        latest
+      end.values.each do |gem|
+        yield Spec.new(gem.name.sub(/sprout-*#{@sprout_name}-bundle$/, ''), gem.full_gem_path, label)
+      end
+    end
+
+    def each_sprout
+      Gem::cache.sprout_search(/^sprout-.*/).inject({}) do |latest, gem|
+        hem = latest[gem.name]
+        latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+        latest
+      end.values.each do |gem|
+        yield Spec.new(gem.name, gem.full_gem_path, label)
+      end
+    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 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

data/lib/sprout/generator/named_base.rb

@@ -0,0 +1,227 @@
+
+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 < RubiGen::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
+
+      # Path to the in-project generate script
+      # pulled out for DOS branching
+      def generate_script_path
+        usr = User.new
+        if(usr.is_a?(WinUser) && !usr.is_a?(CygwinUser))
+          return File.join(class_name, 'script', "generate.rb")
+        else
+          return File.join(class_name, 'script', "generate")
+        end
+      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,7 @@
+# gem 'activesupport', '>= 2.0.2'
+gem 'rubigen'
+require 'rubigen'
+require 'sprout/generator/base_mixins'
+require 'sprout/generator/named_base'
+
+# This is the entry point for sprout generator features

data/lib/sprout/log.rb

@@ -0,0 +1,46 @@
+
+module Sprout #:nodoc:
+  
+  class Log #:nodoc:
+    @@debug = false
+    @@output = ''
+    @@printout = ''
+    
+    def Log.debug=(debug)
+      @@debug = debug
+    end
+    
+    def Log.debug
+      return @@debug
+    end
+    
+    def Log.puts(msg)
+      @@output << msg + "\n"
+      Log.flush
+    end
+    
+    def Log.print(msg)
+      @@printout << msg
+      Log.flush_print
+    end
+    
+    def Log.printf(msg)
+      @@printout << msg
+      Log.flush_print
+    end
+    
+    def Log.flush_print
+      if(!Log.debug)
+        $stdout.print @@printout
+        @@printout = ''
+      end
+    end
+    
+    def Log.flush
+      if(!Log.debug)
+        $stdout.puts @@output
+        @@output = ''
+      end
+    end
+  end
+end

data/lib/sprout/process_runner.rb

@@ -0,0 +1,111 @@
+
+module Sprout #:nodoc:
+  class ProcessRunnerError < StandardError # :nodoc:
+  end
+  
+  class ProcessRunner #:nodoc:
+    attr_reader :pid,
+                :r,
+                :w,
+                :e
+    
+    def initialize(*command)
+      @command = command
+      begin
+        @alive = true
+        usr = User.new()
+        if(usr.is_a?(WinUser) && !usr.is_a?(CygwinUser))
+          gem 'win32-open3', '0.2.5'
+          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::EACCES => e
+        update_executable_mode(*@command)
+        @pid, @w, @r, @e = open4.popen4(*@command)
+      rescue Errno::ENOENT => e
+        @alive = false
+        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 update_executable_mode(*command)
+      parts = command.join(' ').split(' ')
+      str = parts.shift
+      while(parts.size > 0)
+        if(File.exists?(str))
+          FileUtils.chmod(744, str)
+          return
+        else
+          str << " #{parts.shift}"
+        end
+      end
+    end
+    
+    def alive?
+      @alive = update_status
+    end
+    
+    def kill
+      Process.kill(9, pid)
+    end
+    
+    def close
+      update_status
+    end
+    
+    def update_status
+      pid_int = Integer("#{ @pid }")
+      begin
+        Process::kill 0, pid_int
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+    
+    def readpartial(count)
+      @r.readpartial(count)
+    end
+    
+    def readlines
+      @r.readlines
+    end
+    
+    def flush
+      @w.flush
+    end
+    
+    def getc
+      @r.getc
+    end
+    
+    def print(msg)
+      @w.print msg
+    end
+    
+    def puts(msg)
+      @w.puts(msg)
+    end
+    
+    def close_write
+      @w.close_write
+    end
+    
+    def read
+      return @r.read
+    end
+    
+    def read_err
+      return @e.read
+    end
+  end
+end