sprout 0.7.191-mswin32

data/lib/sprout/builder.rb

@@ -0,0 +1,35 @@
+
+module Sprout
+
+  # accepts a destination path and a sprout specification
+  # and will download and unpack the platform-specific
+  # archives that are identified in the spec
+  class Builder # :nodoc:
+    
+    class BuilderError < StandardError #:nodoc:
+    end
+
+    def self.build(file_targets_yaml, destination)
+      data = nil
+      
+      File.open(file_targets_yaml, 'r') do |f|
+        data = f.read
+      end
+      
+      usr = User.new
+      platform = usr.platform.to_s
+      
+      targets = YAML.load(data)
+      targets.each do |target|
+        if(target.platform == 'universal' || target.platform == platform)
+          target.install_path = FileUtils.mkdir_p(destination)
+          target.resolve
+          return target
+        end
+      end
+      raise BuilderError.new("Sprout::Builder.build failed, unsupported platform or unexpected yaml")
+    end
+    
+  end
+end
+

data/lib/sprout/commands/generate.rb

@@ -0,0 +1,9 @@
+=begin
+require 'rubygems'
+gem 'activesupport', '>= 2.0.2'
+require 'generator'
+require 'sprout'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Scripts::Generate.new.run(ARGV)
+=end

data/lib/sprout/general_tasks.rb

@@ -0,0 +1,6 @@
+
+require 'sprout/tasks/sftp_task'
+require 'sprout/tasks/ssh_task'
+require 'sprout/tasks/zip_task'
+require 'sprout/tasks/gem_wrap_task'
+require 'sprout/tasks/library_task'

data/lib/sprout/generator.rb

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

data/lib/sprout/generator/base_mixins.rb

@@ -0,0 +1,126 @@
+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.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 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/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