sprout 0.7.219-i686-darwin10

data/lib/sprout/tasks/zip_task.rb

@@ -0,0 +1,158 @@
+=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 'zip/zipfilesystem'
+
+# TODO: Make this task more like a rake FileTask
+# The output should be the task name and the input
+# files should be added as prerequisites
+
+module Sprout
+  class ZipError < StandardError #:nodoc:
+  end
+
+  # The ZipTask should accept any directory as input and either
+  # an expected zip file name or directory where one will be created
+  # for output.
+  # The resulting zip file will only be generated if a file in the
+  # input directory has a newer timestamp than the existing zip file
+  class ZipTask < Rake::FileTask
+
+    # Array of file names that should not be added to the zip archive.
+    # The default value of this property is:
+    #   @excludes = ['.', '..', '.svn', '.cvs', '.DS_Store', '.git', 'CVS', 'Thumbs.db']
+    attr_writer :excludes
+    # The file or folder that should be archived. 
+    #
+    # If input is a directory, all of it's contents
+    # will be recursively added to the archive (excluding any files that match +excludes+ of course).
+    #
+    # If input is a file, a new archive will be created with a similar file name and only that file
+    # will be added to the archive.
+    attr_writer :input
+    # Zip archive file to create. Usually, the name of the zip task will be used for this property,
+    # but in cases where you want a particular task name and a different output file, you can set
+    # this parameter.
+    attr_writer :output
+    
+    def self.define_task(args, &block) # :nodoc:
+      t = super
+      yield t if block_given?
+      t.define
+    end
+    
+    def define # :nodoc:
+      @input = define_input(input)
+      @output = define_output(output || name)
+    end
+    
+    def output
+      @output ||= nil
+    end
+    
+    def input
+      @input ||= nil
+    end
+
+    def execute(*args) # :nodoc:
+      create_archive
+    end
+    
+    def excludes
+      @excludes ||= ['.', '..', '.svn', '.cvs', '.DS_Store', '.git', 'CVS', 'Thumbs.db']
+    end
+
+    private
+    
+    def create_archive(force=false) # :nodoc:
+      return unless (force || name == output)
+      
+      start = Dir.pwd
+      begin
+        full_output = File.expand_path(output)
+        full_input = File.expand_path(input)
+        Dir.chdir(File.dirname(full_input))
+        masked_input = full_input.gsub("#{Dir.pwd}/", '')
+
+        # Create the containing folder for output
+        if(!File.directory?(File.dirname(full_output)))
+          FileUtils.mkdir_p(File.dirname(full_output))
+        end
+        
+        ZipUtil.pack(masked_input, full_output, excludes)
+  
+      ensure
+        Dir.chdir(start)
+      end
+    
+    end
+
+    def define_input(input)
+      file input do |t|
+        raise ZipError.new("ZipTask '#{name}' could not find valid input at: #{input}") unless (File.exists?(input))
+      end
+
+      input_files = FileList["#{input}/**/**/*"]
+      input_files.each do |f|
+        prerequisites << f
+      end
+      prerequisites << input
+      return input
+    end
+    
+    def define_output(out)
+      
+      # If the provided parent dir doesn't
+      # exist, create it
+      if(!File.exists?(File.dirname(out)))
+        FileUtils.mkdir_p(File.dirname(out))
+      end
+
+      # If the provided output is just a directory
+      # and it's parent doesn't yet exist, create the
+      # provided output directory before appending
+      # the real zip file name
+      if(!File.basename(out).index('.'))
+        FileUtils.mkdir_p(out)
+      end
+      
+      # If out is just a directory, append input's basename
+      # to create the zip file
+      if(File.directory?(out))
+        out = File.join(out, File.basename(input) + '.zip')
+      end
+      
+      if(out != name)
+        file out do
+          create_archive(true)
+        end
+        prerequisites << out
+      end
+      return out
+    end
+  end
+end
+
+def zip(args, &block)
+  Sprout::ZipTask.define_task(args, &block)
+end

data/lib/sprout/template_resolver.rb

@@ -0,0 +1,207 @@
+
+module Sprout
+  
+  class TemplateResolver < Hash #:nodoc:
+    include Singleton
+    
+    attr_accessor :replace_all, 
+                  :ignore_all
+                  
+    @@SPROUT_FILE_NAME = 'Sprout'
+    @@RENDER_IGNORE_FILES = ['asclass_config.rb', 'SWFMillTemplate.erb', 'Template.erb']
+    @@BINARY_EXTENSIONS = ['.jpg', '.png', '.gif', '.doc', '.xls', '.exe', '.swf', 'fla', '.psd']
+    @@LOG_PREFIX = ">> Created file: "
+    @@DELETE_PREFIX = ">> Deleted file: "
+
+    def initialize
+      super
+      @replace_all = false
+      @ignore_all = false
+    end
+    
+    def copy_files(from, to, render=false)
+      created_files = Array.new
+      if(!File.exists? from)
+        raise UsageError.new('TemplateResolver attempted to copy files from (' + from + ') but it does not exist...')
+      end
+      if(File.directory? from)
+        Dir.open(from).each do |filename|
+          if(!Sprout.ignore_file? filename)
+            fullname = File.join(from, filename)
+            new_fullname = File.join(to, filename)
+            cleaned_filename = clean_file_name(filename)
+            cleaned_fullname = File.join(to, cleaned_filename)
+            if(File.directory? fullname)
+              Dir.mkdir(new_fullname) unless File.exists? new_fullname
+              puts new_fullname
+              copy_files(fullname, new_fullname, render)
+            else
+              file = copy_file(fullname, cleaned_fullname, render)
+            end
+          end
+        end
+      else
+        raise UsageError.new("copy_files called with a file (" + from + ") instead of a directory!")
+      end
+      
+      return created_files
+    end
+    
+    def puts(file, is_delete=false)
+      prefix = (is_delete) ? @@DELETE_PREFIX : @@LOG_PREFIX
+      Log.puts(prefix + file.gsub(Dir.pwd + '/', ''))
+    end
+    
+    def b(path)
+      (is_binary?(path)) ? 'b' : '' 
+    end
+    
+    def copy_file(from, to, render=false, delegate=nil)
+      if(write_file?(to))
+        content = nil
+        File.open(from, 'r' + b(from)) do |f|
+          content = f.read
+        end
+        if(render && should_render?(from))
+          begin
+            bind = (delegate.nil?) ? binding : delegate.get_binding
+            content = ERB.new(content, nil, '>').result(bind)
+          rescue NameError => e
+            Log.puts '>> Template ' + from + ' references a value that is not defined'
+            raise e
+          end
+        end
+        FileUtils.makedirs(File.dirname(to))
+        File.open(to, 'w' + b(to)) do |f|
+          f.write(content)
+        end
+        puts to
+        return to
+      end
+      return nil
+    end
+    
+    def should_render?(file)
+      if(is_binary?(file) || @@RENDER_IGNORE_FILES.index(File.basename(file)))
+        return false
+      end
+      return true
+    end
+    
+    def write_file?(file)
+      if(!File.exists?(file))
+        return true
+      elsif(@replace_all)
+        puts(file, true)
+        File.delete(file)
+        return true
+      elsif(@ignore_all)
+        return false
+      end
+
+      relative = file.gsub(Dir.pwd, '')
+      msg = <<EOF
+
+[WARNING] Sprout Encountered an existing file at [#{relative}], what would you like to do?
+(r)eplace, (i)gnore, (R)eplace all or (I)gnore all?
+
+EOF
+      if(Log.debug)
+        return false
+      end
+
+      $stdout.puts msg
+      answer = $stdin.gets.chomp
+      if(answer == 'r')
+        return true
+      elsif(answer == 'i')
+        return false
+      elsif(answer == 'R')
+        msg = <<EOF
+        
+Are you sure you want to replace ALL duplicate files?
+(y)es or (n)o
+
+EOF
+        $stdout.puts msg
+        answer = $stdin.gets.chomp
+        if(answer == 'y')
+          @replace_all = true
+        else
+          write_file?(file)
+        end
+      elsif(answer == 'I')
+        @ignore_all = true
+        return false
+      else
+        $stdout.puts "I didn't understand that response... Please choose from the following choices:\n\n"
+        write_file?(file)
+      end
+    end
+    
+    def render_file filename
+      file = File.open(filename, 'r')
+      resolved = ERB.new(file.read, nil, '>').result(binding)
+      file.close
+      file = File.open(filename, 'w')
+      file.write(resolved)
+      file.close
+    end
+    
+    def clean_file_name name
+      return name.gsub(@@SPROUT_FILE_NAME, project_name)
+    end
+    
+    def project_name
+      return Sprout.project_name
+    end
+    
+    def instance_name
+      return project_name[0,1].downcase + project_name[1,project_name.size]
+    end
+    
+    #TODO: Figure out if the file is plain text or not... Possible?
+    def is_binary? file
+      file_extension = File.extname(file).downcase
+      @@BINARY_EXTENSIONS.each do |ext|
+        if(file_extension == ext)
+          return true
+        end
+      end
+      return false
+    end
+
+=begin
+  Found this code for binary inspection here:
+  http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/44940
+  it's not 100%, but better than what I'm doing with extensions.
+  This should be tested and inserted above
+  if it works.
+
+  NON_ASCII_PRINTABLE = /[^\x20-\x7e\s]/
+
+  def nonbinary?(io, forbidden, size = 1024)
+    while buf = io.read(size)
+      return false if forbidden =~ buf
+    end
+    true
+  end
+
+  # usage: ruby this_script.rb filename ...
+  ARGV.each do |fn|
+    begin
+      open(fn) do |f|
+        if nonbinary?(f, NON_ASCII_PRINTABLE)
+          puts "#{fn}: ascii printable"
+        else
+          puts "#{fn}: binary"
+        end
+      end
+    rescue StandardError => e
+      puts "#$0: #$!"
+    end
+  end
+=end
+
+  end
+end

data/lib/sprout/user.rb

@@ -0,0 +1,383 @@
+require 'platform'
+require 'sprout/log'
+require 'sprout/process_runner'
+
+module Sprout
+
+  class ExecutionError < StandardError # :nodoc:
+  end
+
+  # The User class provides a single and consistent interface to User based paths
+  # and features so that Sprout implementation code doesn't need to be concerned
+  # with which Operating system it is running on.
+  #
+  class User
+    @@user = nil
+
+    # Retrieve a user instance that represents the currently logged in user on this system.
+    def User.new(os=nil, impl=nil)
+        if(os.nil? && impl.nil? && @@user)
+          return @@user
+        end
+        if(os.nil?)
+          os = Platform::OS
+        end
+        if(impl.nil?)
+          impl = Platform::IMPL
+        end
+        if(os == :win32 && impl == :vista)
+          @@user = VistaUser.new
+        elsif(os == :win32 && impl == :cygwin)
+          @@user = CygwinUser.new
+        elsif(os == :win32)
+          @@user = WinUser.new
+        elsif(os == :unix && impl == :macosx)
+          @@user = OSXUser.new
+#        elsif(os == :unix && impl == :linux)
+#          @@user = UnixUser.new
+        else
+          @@user = UnixUser.new
+        end
+    end
+
+    def User.user=(user) # :nodoc:
+      @@user = user
+    end
+
+    def User.home=(path) # :nodoc:
+      User.new().home = path
+    end
+    
+    def User.is_a?(type)
+      User.new().is_a?(type)
+    end
+
+    # Pass an executable or binary file name and find out if that file exists in the system
+    # path or not
+    def User.in_path?(executable)
+      User.new().in_path?(executable)
+    end
+    
+    # Retrieve the full path to an executable that exists in the user path
+    def User.get_exe_path(executable)
+      return User.new().get_exe_path(executable)
+    end
+
+    # Return the home path for the currently logged in user. If the user name is lbayes, this should be:
+    #
+    # Windows XP::  C:\Documents And Settings\lbayes
+    # Cygwin::  /cygdrive/c/Documents And Settings/lbayes 
+    # OS X::  /Users/lbayes
+    # Linux::   ~/
+    def User.home
+      User.new().home
+    end
+
+    # Returns the home path for a named application based on the currently logged in user and operating system.
+    # If the user name is lbayes and the application name is Sprouts, this path will be:
+    #
+    # Windows XP::  C:\Documents And Settings\lbayes\Local Settings\Application Data\Sprouts
+    # Cygwin::  /cygdrive/c/Documents And Settings/Local Settings/Application Data/Sprouts
+    # OS X::  /Users/lbayes/Library/Sprouts
+    # Linux::   ~/.sprouts
+    def User.application_home(name)
+      return User.new().application_home(name)
+    end
+
+    # Returns the library path on the current system. This is the general path where all applications should
+    # store configuration or session data.
+    #
+    # Windows XP::   C:\Documents And Settings\lbayes\Local Settings\Application Data
+    # Cygwin::  /cygdrive/c/Documents And Settings/lbayes/Local Settings/Application Data 
+    # OS X::   /Users/lbayes/Library
+    # Linux::   ~/
+    def User.library
+      return User.new().library
+    end
+
+    # Execute a named tool sprout. The full sprout name should be provided to the tool parameter, and
+    # a string of shell parameters that will be sent to the tool itself.
+    def User.execute(tool, options='')
+      return User.new().execute(tool, options)
+    end
+    
+    def User.execute_silent(tool, options='')
+      return User.new().execute_silent(tool, options)
+    end
+
+    # Execute a named tool sprout as a new thread and return that thread
+    def User.execute_thread(tool, options='')
+      if(Log.debug)
+         return ThreadMock.new
+      else
+         return User.new().execute_thread(tool, options)
+      end
+    end
+
+    # Clean a path string in such a way that works for each platform. For example, Windows doesn't like
+    # it when we backslash to escape spaces in a path because that is the character they use as a delimiter.
+    # And OS X doesn't really like it when we wrap paths in quotes.
+    def User.clean_path(path)
+      return User.new().clean_path(path)
+    end
+
+  end
+
+  #############################
+  # UnixUser class
+  class UnixUser # :nodoc:
+
+    def initialize
+      setup_user
+      @home = nil
+    end
+    
+    def setup_user
+    end
+
+    def home=(path)
+      @home = path
+    end
+
+    def home
+      if(@home)
+        return @home
+      end
+      
+      # Original implementation:
+      #["HOME", "USERPROFILE"].each do |homekey|
+      # Change submitted by Michael Fleet (disinovate)
+      # Does this work for everyone on Windows?
+      ["USERPROFILE", "HOME"].each do |homekey|
+        return @home = ENV[homekey] if ENV[homekey]
+      end
+
+      if ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
+        return @home = "#{ENV["HOMEDRIVE"]}:#{ENV["HOMEPATH"]}"
+      end
+
+      begin
+        return @home = File.expand_path("~")
+      rescue StandardError => e
+        if File::ALT_SEPARATOR
+          return @home = "C:\\"
+        else
+          return @home = "/"
+        end
+      end
+    end
+
+    def get_exe_path(executable)
+      paths = get_paths
+      file = nil
+      paths.each do |path|
+        file = File.join(path, executable)
+        if(File.exists?(file))
+          return file
+        end
+      end
+      return nil
+    end
+
+    def in_path?(executable)
+      return !get_exe_path(executable).nil?
+    end
+
+    def get_paths
+      return ENV['PATH'].split(':')
+    end
+
+    def library
+      return home
+    end
+
+    def platform
+      if(Platform::OS == :win32)
+        return :win32
+      elsif(Platform::IMPL == :macosx)
+        return :macosx
+      else
+        return Platform::IMPL
+      end
+    end
+
+    def get_process_runner(command)
+      return ProcessRunner.new(command)
+    end
+
+    # Creates a new process, executes the command
+    # and returns the result and throws if the process
+    # writes to stderr
+    def execute(tool, options='')
+      Log.puts(">> Execute: #{File.basename(tool)} #{options}")
+      tool = clean_path(tool)
+      runner = get_process_runner("#{tool} #{options}")
+
+      error = runner.read_err
+      result = runner.read
+
+      if(result.size > 0)
+        Log.puts result
+      end
+
+      if(error.size > 0)
+        raise ExecutionError.new("[ERROR] #{error}")
+      end
+    end
+
+    # Creates and returns the process without
+    # attempting to read or write to the stream.
+    # This is useful for interacting with
+    # long-lived CLI processes like FCSH or FDB.
+    def execute_silent(tool, options='')
+      tool = clean_path(tool)
+      return get_process_runner("#{tool} #{options}")
+    end
+
+    def execute_thread(tool, options='')
+      return Thread.new do
+        execute(tool, options)
+      end
+    end
+
+    def clean_path(path)
+      if(path.index(' '))
+        # Changed 2/26/2008 in attempt to support 
+        # ToolTask.PathsParam s that have spaces in the values
+        return path.split(' ').join('\ ')
+#        return %{'#{path}'}
+      end
+      return path
+    end
+
+    def application_home(name)
+      return File.join(library, format_application_name(name.to_s));
+    end
+
+    def format_application_name(name)
+      if(name.index('.') != 0)
+        name = '.' + name
+      end
+      return name.split(" ").join("_").downcase
+    end
+  end
+
+  class OSXUser < UnixUser # :nodoc:
+    @@LIBRARY = 'Library'
+
+    def library
+      lib = File.join(home, @@LIBRARY)
+      if(File.exists?(lib))
+        return lib
+      else
+        return super
+      end
+    end
+
+    def format_application_name(name)
+      return name.capitalize
+    end
+  end
+
+  class WinUser < UnixUser # :nodoc:
+    @@LOCAL_SETTINGS = "Local\ Settings"
+    @@APPLICATION_DATA = "Application\ Data"
+
+    def initialize
+      super
+      @home = nil
+    end
+    
+    def setup_user
+    end
+
+    def home
+      usr = super
+      if(usr.index "My Documents")
+        usr = File.dirname(usr)
+      end
+      return usr
+    end
+
+    def get_paths
+      return ENV['PATH'].split(';')
+    end
+
+    def library
+      # For some reason, my homepath returns inside 'My Documents'...
+      application_data = File.join(home, @@LOCAL_SETTINGS, @@APPLICATION_DATA)
+      if(File.exists?(application_data))
+        return application_data
+      else
+        return super
+      end
+    end
+
+    def clean_path(path)
+      path = path.split('/').join("\\")
+      if(path.index(' '))
+        return %{"#{path}"}
+      end
+      return path
+    end
+
+    def format_application_name(name)
+      return name.capitalize
+    end
+  end
+
+  class CygwinUser < WinUser # :nodoc:
+
+    def initialize
+      super
+      @home = nil
+      @win_home = nil
+      @win_home_cyg_path = nil
+    end
+    
+    def setup_user
+    end
+
+    def clean_path(path)
+      if(path.index(' '))
+        return %{'#{path}'}
+      end
+      return path
+    end
+
+    def win_home
+      if(@win_home.nil?)
+        @win_home = ENV['HOMEDRIVE'] + ENV['HOMEPATH']
+      end
+      return @win_home
+    end
+
+    def home
+      if(@home.nil?)
+        path = win_home.split('\\').join("/")
+        path = path.split(":").join("")
+        parts = path.split("/")
+        path = parts.shift().downcase + "/" + parts.join("/")
+        @home = "/cygdrive/" + path
+      end
+    return @home
+    end
+
+  end
+
+  class VistaUser < WinUser # :nodoc:
+    def home
+      profile = ENV['USERPROFILE']
+      if(profile)
+        return profile
+      end
+      return super
+    end
+  end
+
+  class ThreadMock # :nodoc:
+    def alive?
+      return false
+    end
+  end
+end