sprout 0.7.220-x86-darwin-10

data/lib/sprout/project_model.rb

@@ -0,0 +1,278 @@
+
+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.
+  #
+  # The ProjectModel can be configured as follows:
+  #   project_model :model do |p|
+  #     p.name          = 'SomeProject'
+  #     p.source_path   << 'somedir/otherdir'
+  #     p.library_path  << 'somedir'
+  #   end
+  #
+  # 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. 
+  #
+  # Arbitrary properties can be added as follows:
+  #   m = project_model :model do |p|
+  #     p.unknown_property = 'someValue'
+  #   end
+  # 
+  #   puts "Unknown Property: #{m.unknown_property}"
+  #
+  # The ProjectModel is typically treated as if it is a Singleton, and many helper tasks
+  # will automatically go look for their model at:
+  # 
+  #   Sprout::ProjectModel.instance
+  #
+  # Unlike a real Singleton, this static property will actually be populated with the most
+  # recently instantiated ProjectModel, and any well-behaved helper task will also
+  # allow you to send in a model as a prerequisite.
+  #
+  #   project_model :model_a
+  #   project_model :model_b
+  #
+  #   desc 'Compile and run a'
+  #   debug :debug_a => :model_a
+  #
+  #   desc 'Compile and run b'
+  #   debug :debug_b => :model_b
+  #
+  class ProjectModel < Hash
+    
+    # Relative path to the folder where compile time assets will be stored
+    attr_accessor :asset_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
+    # The Background Color of the SWF file
+    attr_accessor :background_color
+    # Contributors to the SWF file
+    attr_accessor :contributors
+    # If you don't want to use the default compiler for your language
+    # set it manually here.
+    # Possible values are:
+    # * sprout-flex2sdk-tool
+    # * sprout-flex3sdk-tool
+    # * sprout-flex4sdk-tool (Experimental)
+    # * sprout-mtasc-tool
+    attr_accessor :compiler_gem_name
+    # The version number of the compiler gem to use
+    attr_accessor :compiler_gem_version
+    # The primary creator of the SWF file
+    attr_accessor :creator
+    # Directory where documentation should be placed.
+    attr_accessor :doc_dir
+    # CSS documents that should be individually compiled
+    # for runtime stylesheet loading.
+    attr_accessor :external_css
+    # The default frame rate of the SWF file
+    attr_accessor :frame_rate
+    # The default height of the SWF file
+    # _(This value is overridden when embedded in an HTML page)_
+    attr_accessor :height
+    # The technology language that is being used, right now this value can be 'as2', 'as3' or 'mxml'.
+    # Code generators take advantage of this setting to determine which templates to use
+    # and build tasks use this setting to determin the input file suffix (.as or .mxml).
+    attr_accessor :language
+    # 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
+    # Array of sprout library symbols
+    attr_accessor :libraries
+    # The Array of SWC paths to add to all compilation tasks
+    attr_accessor :library_path
+    # The locale for the SWF file
+    attr_accessor :locale
+    # A collection of Flex Module root source files. If this collection
+    # has items added to it, the deploy task will generate a 'link_report' from
+    # the main application compilation and then consume it as 'load_externs' for 
+    # each module compilation.
+    attr_accessor :modules
+    # Organization responsible for this SWF file
+    attr_accessor :organization
+    # The production file that this Project will generate
+    attr_accessor :output
+    # Terminal command to preprocessor application that accepts STDIN and returns on STDOUT
+    attr_accessor :preprocessor
+    # Folder where preprocessed files will be created. Defaults to '.preprocessed'
+    attr_accessor :preprocessed_path
+    # The real name of the project, usually capitalized like a class name 'SomeProject'
+    attr_accessor :project_name
+    # The folder where compile time skins can be loaded from
+    attr_accessor :skin_dir
+    # The skin file that will be generated
+    attr_accessor :skin_output
+    # The Array of source paths to add to all compilation tasks
+    # _Do not add task-specific paths (like lib/asunit) to this value_
+    attr_accessor :source_path
+    # The relative path to your main source directory. Defaults to 'src'
+    attr_accessor :src_dir
+    # Enforce strict type checking
+    attr_accessor :strict
+    # The relative path to the directory where swc files should be kept.
+    # This value defaults to lib_dir
+    attr_accessor :swc_dir
+    # Relative path to the folder that contains your test cases
+    attr_accessor :test_dir
+    # The test executable
+    attr_accessor :test_output
+    # The test runner SWF height
+    attr_accessor :test_height
+    # The test runner SWF width
+    attr_accessor :test_width
+    # Tasks that can, will use the Flex Compiler SHell.
+    attr_accessor :use_fcsh
+    # Flash Player Tasks will launch using the Flex Debugger.
+    attr_accessor :use_fdb
+    # The default width of the SWF file
+    # _(This value is overridden when embedded in an HTML page)_
+    attr_accessor :width
+
+    # Static method that returns the most recently instantiated ProjectModel,
+    # or instantiates one if none have been created yet.
+    def self.instance
+      @@instance ||= ProjectModel.new
+      yield @@instance if block_given?
+      return @@instance
+    end
+    
+    # Decorates the static instance method.
+    def self.setup
+      @@instance ||= ProjectModel.new
+      yield @@instance if block_given?
+      return @@instance
+    end
+
+    def self.destroy # :nodoc:
+      @@instance = nil
+    end
+
+    def initialize
+      super
+      @project_name   = ''
+      @doc_dir        = 'doc'
+      @src_dir        = 'src'
+      @lib_dir        = 'lib'
+      @swc_dir        = 'lib'
+      @bin_dir        = 'bin'
+      @test_dir       = 'test'
+      @asset_dir      = 'assets'
+      @skin_dir       = File.join(@asset_dir, 'skins')
+      @frame_rate     = 24
+      @language       = 'as3'
+
+      @external_css   = []
+      @libraries      = []
+      @library_path   = []
+      @modules        = []
+      @source_path    = []
+
+      @model_dir      = nil
+      @view_dir       = nil
+      @controller_dir = nil
+      
+      @test_height    = 550
+      @test_width     = 900
+      @@instance      = self
+    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
+    
+    # Alias for project_name
+    def name=(name)
+      @project_name = name
+    end
+    
+    def name
+      @project_name
+    end
+    
+    def to_s
+      return "[Sprout::ProjectModel project_name=#{project_name}]"
+    end
+    
+    protected
+    
+    def method_missing(method_name, *args)
+      method_name = method_name.to_s
+      if method_name =~ /=$/
+        super if args.size > 1
+        self[method_name[0...-1]] = args[0]
+      else
+        super unless has_key?(method_name) and args.empty?
+        self[method_name]
+      end
+    end
+  end
+end
+
+# Helper method to expose the project model as a Rake Task
+def project_model(task_name)
+  model = Sprout::ProjectModel.new
+  yield model if block_given?
+
+  t = task task_name
+
+  def t.project_model=(model)
+    @model = model
+  end
+
+  def t.project_model
+    return @model
+  end
+    
+  t.project_model = model
+  return model
+end
+

data/lib/sprout/remote_file_loader.rb

@@ -0,0 +1,71 @@
+
+module Sprout
+  class RemoteFileLoaderError < StandardError #:nodoc:
+  end
+
+  class RemoteFileLoader #:nodoc:
+    
+    def get_remote_file(uri, force=false, md5=nil)
+      response = fetch(uri.to_s)
+      if(force || response_is_valid?(response, md5))
+        return response
+      end
+    end
+    
+    def response_is_valid?(response, expected_md5sum=nil)
+      if(expected_md5sum)
+        md5 = Digest::MD5.new
+        md5 << response
+        
+        if(expected_md5sum != md5.hexdigest)
+          puts "The MD5 Sum of the downloaded file (#{md5.hexdigest}) does not match what was expected (#{expected_md5sum})."
+          puts "Would you like to install anyway? [Yn]"
+          response = $stdin.gets.chomp!
+          if(response.downcase == 'y')
+            return true
+          else
+            raise RemoteFileLoaderError.new('MD5 Checksum failed')
+          end
+        end
+      end
+      return true
+    end
+    
+    def fetch(uri)
+      uri = URI.parse(uri)
+      progress = nil
+      response = nil
+      name = uri.path.split("/").pop
+      
+      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
+            progress.set(0)
+          else
+            progress = ProgressBar.new(name, 0)
+            progress.file_transfer_mode
+            progress.set(0)
+          end
+        },
+        :progress_proc => lambda {|s|
+          progress.set s if progress
+        }) do |f|
+          response = f.read
+          progress.finish
+        end
+      rescue SocketError => sock_err
+        raise RemoteFileLoaderError.new("[ERROR] #{sock_err.to_s}")
+      rescue OpenURI::HTTPError => http_err
+        raise RemoteFileLoaderError.new("[ERROR] Failed to load file from: '#{uri.to_s}'\n[REMOTE ERROR] #{http_err.io.read.strip}")
+      rescue Errno::ECONNREFUSED => econ_err
+        raise Errno::ECONNREFUSED.new("[ERROR] Connection refused at: '#{uri.to_s}'")
+      end
+
+      return response
+    end
+    
+  end
+end

data/lib/sprout/remote_file_target.rb

@@ -0,0 +1,151 @@
+
+module Sprout
+  class RemoteFileTargetError < StandardError #:nodoc:
+  end
+
+  class RemoteFileTarget # :nodoc:
+
+    attr_writer   :archive_path
+    
+    # The string environment variable name to check before downloading anything.
+    attr_accessor :environment
+    
+    # The user path where this gem will download and install files
+    # This value is set by the Sprout::Builder that creates this RemoteFileTarget
+    attr_accessor :install_path
+
+    # Optional md5 hash, usually set in the sprout.spec for each RemoteFileTarget
+    # If this value is set, the downloaded archive will be hashed, the hashes will
+    # be compared and if they differ, the installation process will break.
+    attr_accessor :md5
+
+    # Used for dmg archives. Absolute path to the mounted dmg (essentially its name)
+    attr_accessor :mount_path
+
+    # Which platform will this RemoteFileTarget support.
+    # Supported options are:
+    #  * universal
+    #  * macosx
+    #  * win32
+    #  * linux
+    attr_accessor :platform
+
+    # URL where Sprouts can go to download the RemoteFileTarget archive
+    attr_accessor :url
+    
+    # If the archive type cannot be assumed from the returned file name,
+    # it must be provided as one of the following:
+    #   :exe
+    #   :zip
+    #   :targz
+    #   :gzip
+    #   :swc
+    #   :rb
+    #   :dmg
+    # @see ArchiveUnpacker
+    attr_accessor :archive_type
+
+    # Filename for the downloaded file. Introduced to fix railsy URL issues.
+    attr_accessor :filename
+
+    # Relative path within the archive to the executable or binary of interest
+    def archive_path
+      @archive_path ||= ''
+    end
+
+    # Resolve this RemoteFileTarget now. This method is called by the Sprout::Builder
+    # and will download, install and unpack the described archive, unless it is
+    # already installed
+    def resolve(update=false)
+      # Wanted to raise, but it seems we support RemoteFileTargets that are actually self-installed binaries...
+      # like SWFMill on Linux. @see the BuilderTest.test_build_no_install for more info.
+      # raise RemoteFileTargetError.new('Cannot retrieve a RemoteFileTarget without a url') if url.nil?
+      return if url.nil?
+      
+      if(filename)
+        self.downloaded_path = File.join(File.dirname(downloaded_path), filename)
+      end
+      
+      if(url && (update || !File.exists?(downloaded_path)))
+        content = download(url, update)
+        FileUtils.makedirs(File.dirname(downloaded_path))
+        FileUtils.touch(downloaded_path)
+        File.open(downloaded_path, 'rb+') do |file|
+          file.write(content)
+        end
+      end
+
+      if(!File.exists?(installed_path) || !File.exists?(File.join(installed_path, archive_path) ))
+        archive_root = File.join(install_path, 'archive')
+        install(downloaded_path, archive_root, update, archive_type)
+      end
+    end
+    
+    # Return the basename of the executable that this RemoteFileTarget refers to
+    def executable
+      return File.basename(archive_path)
+    end
+    
+    # The root path to the unpacked archive files. This is the base path that will be added to any
+    # +archive_path+ relative paths
+    def installed_path
+      @installed_path ||= inferred_installed_path
+      return @installed_path
+    end
+    
+    def downloaded_path=(path)
+      @downloaded_path = path
+    end
+    
+    # Parent directory where archives are downloaded
+    # can be something like: ~/Library/Sprouts/cache/0.7/sprout-somesprout-tool.x.x.x/
+    def downloaded_path
+      @downloaded_path ||= File.join(install_path, file_name(url))
+      return @downloaded_path
+    end
+    
+    # Base file name represented by the provided +url+
+    # Will strip off any ? arguments and trailing slashes. May not play nice with Rails URLS,
+    # We expect archive file name suffixes like, zip, gzip, tar.gz, dmg, etc.
+    def file_name(url=nil)
+      return @filename if(@filename)
+
+      url ||= self.url
+      url = url.split('?').shift
+      
+      parts = url.split('/')
+      if(parts.last == '/')
+        parts.pop
+      end
+      
+      file = parts.pop
+      
+      if(!archive_type.nil? && file.match(/\.#{archive_type.to_s}$/).nil?)
+        file << ".#{archive_type.to_s}"
+      end
+      
+      return file
+    end
+    
+    private
+    
+    def inferred_installed_path
+      if(!environment.nil? && !ENV[environment].nil? && File.exists?(ENV[environment]))
+        return ENV[environment]
+      end
+      
+      return File.join(install_path, 'archive')
+    end
+    
+    def download(url, update=false)
+      loader = RemoteFileLoader.new
+      loader.get_remote_file(url, update, md5)
+    end
+    
+    def install(from, to, force, archive_type=nil)
+      unpacker = ArchiveUnpacker.new
+      unpacker.unpack_archive(from, to, force, archive_type)
+    end
+    
+  end
+end

data/lib/sprout/simple_resolver.rb

@@ -0,0 +1,88 @@
+=begin
+Copyright (c) 2007 Pattern Park
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=end
+require 'erb'
+
+module Sprout
+
+  class SimpleResolver #:nodoc:
+
+    def initialize(template, output, files, base_dir=nil)
+      @template = template
+      @output = output
+      @files = files
+      @base_dir = base_dir
+      @ignored_files = []
+      execute
+      finish
+    end
+  
+    def execute
+      template_file = File.open(@template, 'r')
+      content = template_file.read
+      result = ERB.new(content, nil, '>').result(binding)
+
+      output_file = File.open(@output, 'w')
+      output_file.write(result)
+    
+      template_file.close
+      output_file.close
+    end
+  
+    def files
+      return @files
+    end
+
+    def finish
+      if(@ignored_files.size > 0)
+        Logger.puts '>> SimpleResolver ignored the following files because their names were invalid:'
+        @ignored_files.each do |file|
+          puts file
+        end
+      end
+    end
+  
+    def xml_edit_warning
+      return <<EOF
+    <!--
+    DO NOT EDIT THIS FILE!
+    This file was auto-generated from
+    an ERB template which can be
+    found at: 
+    #{@template}
+    -->
+EOF
+    end
+  
+    def edit_warning
+      return <<EOF
+  /*************************************
+   * DO NOT EDIT THIS FILE!
+   * This file was auto-generated from
+   * an ERB template which can be
+   * found at: 
+   * #{@template}
+   *************************************/
+EOF
+    end
+  end
+end

data/lib/sprout/tasks/erb_resolver.rb

@@ -0,0 +1,118 @@
+require 'erb'
+
+# Rake task that makes it stupid-easy to render ERB templates
+# to disk. Just add parameters to the yielded object, and
+# they will be available to your Template.
+#
+#   erb_resolver 'config/SomeFile.xml' do |t|
+#     t.param1 = 'value'
+#     t.other_param = 'other value'
+#     t.another_param = ['a', 'b', 'c']
+#   end
+#
+# Your erb template must be found at: 
+#
+#   [task_name].erb
+#
+# For the above example, this file would be: 
+#
+#   config/SomeFile.xml.erb
+# 
+module Sprout
+  
+  class ERBResolver < Rake::FileTask
+
+    # Path to the input ERB template. This
+    # value will default to the value of
+    # "#{ERBResolver.output}.erb"
+    attr_accessor :template
+
+    def initialize(name, app) # :nodoc:
+      super
+      @context = ERBContext.new
+    end
+
+    def define(args)
+    end
+
+    def prepare
+      prepare_prerequisites
+    end
+
+    # Modified from Rake::Task.execute
+    def execute(args=nil)
+      args ||= EMPTY_TASK_ARGS
+      if application.options.dryrun
+        puts "** Execute (dry run) #{name}"
+        return
+      end
+      if application.options.trace
+        puts "** Execute #{name}"
+      end
+      application.enhance_with_matching_rule(name) if @actions.empty?
+      @actions.each do |action|
+        execute_erb_task(action, args)
+      end
+    end
+    
+    def execute_erb_task(action, args=nil)
+      case action.arity
+      when 1
+        action.call(@context)
+      else
+        action.call(@context, args)
+      end
+      
+      @context.execute(template, output, args)
+    end
+
+    def self.define_task(*args, &block)
+      t = super
+      if(t.is_a?(ERBResolver))
+        t.define(args)
+        t.prepare
+      end
+      return t
+    end
+
+    def template
+      @template ||= "#{output}.erb"
+    end
+
+    def output
+      self.name
+    end
+
+    protected
+
+    def prepare_prerequisites
+      prerequisites << file(template)
+      CLEAN.add(output)
+    end
+
+  end
+  
+  # An empty, dynamic object that will be yielded
+  # to the provided block and later supplied to the
+  # ERB template.
+  #
+  # Returning this empty object gives us the ability
+  # to use parameter names in our templates even if
+  # they are already used by Rake tasks (i.e. name).
+  class ERBContext
+    include DynamicAccessors
+    
+    def execute(template, output, args=nil)
+      content = nil
+      File.open(template, 'r') { |f| content = f.read }
+      result = ERB.new(content, nil, '>').result(binding)
+      File.open(output, 'w') { |f| f.write(result) }
+      Log.puts ">> Created ERB output at: #{output} from: #{template}"
+    end
+  end
+  
+end
+
+def erb_resolver(*args, &block)
+  Sprout::ERBResolver.define_task(args, &block)
+end