sprout 0.7.153-x86-linux

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,14 @@
+# Shamelessly copied from Ruby On Rails
+# Which happens to share the same MIT license!
+
+=begin
+#require "#{RAILS_ROOT}/config/environment"
+require 'rubygems'
+gem 'activesupport', '>= 2.0.2'
+require 'generator'
+#require 'generator/scripts/generate'
+require 'sprout'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+Rails::Generator::Scripts::Generate.new.run(ARGV)
+=end

data/lib/sprout/general_tasks.rb

@@ -0,0 +1,5 @@
+
+require 'sprout/tasks/sftp_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 'rails_generator'
+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,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/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