sproutit-sproutcore 1.0.0.20090407205609

data/lib/sproutcore/buildfile/build_task.rb

@@ -0,0 +1,33 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'task'))
+
+module SC
+
+  # Just like a normal task, but will not run if the destination path already
+  # exists and it is newer than the source.
+  class Buildfile::BuildTask < ::SC::Buildfile::Task
+
+    def needed?
+      return true if DST_PATH.nil? || SRC_PATHS.nil? # just try to build...
+      return true if !File.exist?(DST_PATH)
+      ret = false
+      dst_mtime = File.mtime(DST_PATH)
+      SRC_PATHS.each do |path|
+        next if path.nil? # skip incase of bad src paths...
+        
+        timestamp = File.exist?(path) ? File.mtime(path) : EARLY
+        ret = ret || (dst_mtime < timestamp)
+        break if ret
+      end
+      return ret 
+    end
+    
+  end
+end
+  

data/lib/sproutcore/buildfile/buildfile_dsl.rb

@@ -0,0 +1,162 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+module SC
+
+  class Buildfile
+    
+    # Describe the domain-specific-language helpers supported by buildfiles.
+    # This is included as a mixin for the buildfile.
+    module Commands
+
+      # Declare a basic task.
+      #
+      # Example:
+      #   task :clobber => [:clean] do
+      #     rm_rf "html"
+      #   end
+      #
+      def task(*args, &block)
+        define_task(::SC::Buildfile::Task, *args, &block)
+      end
+      
+      # Replace an existing task instead of enhancing it.
+      #
+      # Example:
+      #   replace_task :clobber => :clean do
+      #      rm_rf 'javascript'
+      #   end
+      #
+      def replace_task(*args, &block)
+        @is_redefining = true
+        begin
+          define_task(::SC::Buildfile::Task, *args, &block)
+        rescue Exception => e
+          @is_redefining = false
+          raise e
+        end
+      end
+      
+      # Define a build task.  A build task will not run if the destination
+      # file is newer than the source files.
+      #
+      def build_task(*args, &block)
+        define_task(::SC::Buildfile::BuildTask, *args, &block)
+      end
+
+      # Import the partial Rakefiles +fn+.  Imported files are loaded _after_ 
+      # the current file is completely loaded.  This allows the import statement 
+      # to appear anywhere in the importing file, and yet allowing the imported 
+      # files to depend on objects defined in the importing file.
+      #
+      # A common use of the import statement is to include files containing
+      # dependency declarations.
+      #
+      # Example:
+      #   import ".depend", "my_rules"
+      #
+      def import(*args)
+        base_path = current_path.nil? ? nil : File.dirname(current_path)
+        args.each do |fn| 
+          fn = File.expand_path(fn, base_path)
+          add_import(fn)
+        end
+      end
+    
+      # Create a new rake namespace and use it for evaluating the given block.
+      # Returns a NameSpace object that can be used to lookup tasks defined in 
+      # the namespace.
+      #
+      # E.g.
+      #
+      #   ns = namespace "nested" do
+      #     task :run
+      #   end
+      #   task_run = ns[:run] # find :run in the given namespace.
+      #
+      def namespace(name=nil, &block)
+        in_namespace(name, &block)
+      end
+
+      # Describe the next rake task.
+      #
+      # Example:
+      #   desc "Run the Unit Tests"
+      #   task :test => [:build]
+      #     runtests
+      #   end
+      #
+      def desc(description)
+        last_description = description
+      end
+
+      # Describe options on the next rake task.
+      #
+      # Example:
+      #   options :log => :env|:name|:none
+      #   task :test => [:build]
+      #     runtests
+      #   end
+      #
+      def task_options(opts)
+        last_task_options = opts
+      end
+
+      # Scope any config statements inside the passed block to the named mode.
+      # Normally if you call a config statement outside of a mode block, it will
+      # scope to all modes. 
+      #
+      # Example:
+      # mode :debug do
+      #  config :all, :combine_javascript => NO
+      #
+      def mode(build_mode, &block)
+        old_mode = current_mode
+        self.current_mode = build_mode.to_sym
+        yield if block_given?
+        self.current_mode = old_mode
+        return self
+      end
+
+      # Register the passed configuration settings scoped to a target.  Optional
+      # pass a block to edit the config.
+      #
+      # Example:
+      #  config :all, :url_root => "static"
+      #  config :sproutcore do |c|
+      #     c.url_root = "static"
+      #  end
+      #
+      def config(config_name, opts = {}, &block)
+        opts = ::SC::HashStruct.new(opts)
+        yield(opts) if block_given?
+        add_config config_name, opts
+        return self
+      end
+
+      # Register a proxy setting
+      #
+      # Example:
+      #  proxy '/url', :to => 'localhost:3000'
+      #
+      def proxy(proxy_path, opts={})
+        add_proxy proxy_path, opts
+      end
+      
+      # Register info about this buildfile as a project
+      def project(name=nil, type=nil)
+        self.project_name = name.nil? ? :default : name.to_sym
+        self.project_type = type.nil? ? :default : type.to_sym
+        self.project!
+      end
+      
+    end
+    
+    include Commands
+  end
+  
+end

data/lib/sproutcore/buildfile/cloneable.rb

@@ -0,0 +1,34 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+module SC
+  
+  # Mixing for creating easily cloned objects.  Borrowed from Rake 0.8.3
+  module Cloneable
+
+    # Clone an object by making a new object and setting all the instance
+    # variables to the same values.
+    def dup
+      sibling = self.class.new
+      instance_variables.each do |ivar|
+        value = self.instance_variable_get(ivar)
+        new_value = value.clone rescue value
+        sibling.instance_variable_set(ivar, new_value)
+      end
+      sibling.taint if tainted?
+      sibling
+    end
+
+    def clone
+      sibling = dup
+      sibling.freeze if frozen?
+      sibling
+    end
+  end
+  
+  
+end

data/lib/sproutcore/buildfile/early_time.rb

@@ -0,0 +1,29 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+require 'singleton'
+
+module SC
+  
+  # EarlyTime is a fake timestamp that occurs _before_ any other time value.
+  # Borrowed from Rake 0.8.3
+  class EarlyTime
+    include Comparable
+    include Singleton
+
+    def <=>(other)
+      -1
+    end
+
+    def to_s
+      "<EARLY TIME>"
+    end
+  end
+
+  EARLY = EarlyTime.instance
+
+end  

data/lib/sproutcore/buildfile/invocation_chain.rb

@@ -0,0 +1,64 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+module SC
+  
+  # InvocationChain tracks the chain of task invocations to detect
+  # circular dependencies.  Borrowed from Rake 0.8.3
+  class InvocationChain
+    def initialize(value, tail)
+      @value = value
+      @tail = tail
+    end
+
+    def member?(obj)
+      @value == obj || @tail.member?(obj)
+    end
+
+    def already_invoked?(task)
+      (task == @value) || @tail.already_invoked?(task)
+    end
+    
+    def append(value)
+      if member?(value)
+        raise "Circular dependency detected: #{to_s} => #{value}"
+      end
+      self.class.new(value, self)
+    end
+
+    def to_s
+      "#{prefix}#{@value}"
+    end
+
+    def self.append(value, chain)
+      chain.append(value)
+    end
+
+    private
+
+    def prefix
+      "#{@tail.to_s} => "
+    end
+
+    class EmptyInvocationChain
+      def member?(obj)
+        false
+      end
+      def append(value)
+        InvocationChain.new(value, self)
+      end
+      def to_s
+        "TOP"
+      end
+      def already_invoked?(task); false; end
+    end
+
+    EMPTY = EmptyInvocationChain.new
+
+  end # class InvocationChain
+
+end

data/lib/sproutcore/buildfile/namespace.rb

@@ -0,0 +1,33 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+module SC
+  
+  # The NameSpace class will lookup task names in the the scope
+  # defined by a +namespace+ command.  Borrowed from Rake 0.8.3
+  #
+  class NameSpace
+
+    # Create a namespace lookup object using the given task manager
+    # and the list of scopes.
+    def initialize(task_manager, scope_list)
+      @task_manager = task_manager
+      @scope = scope_list.dup
+    end
+
+    # Lookup a task named +name+ in the namespace.
+    def [](name)
+      @task_manager.lookup(name, @scope)
+    end
+
+    # Return the list of tasks defined in this namespace.
+    def tasks
+      @task_manager.tasks
+    end
+  end # NameSpace
+  
+end

data/lib/sproutcore/buildfile/string_ext.rb

@@ -0,0 +1,198 @@
+######################################################################
+# Rake extensions to Module. - Borrowed from Rake 0.8.3
+#
+class Module
+  # Check for an existing method in the current class before extending.  IF
+  # the method already exists, then a warning is printed and the extension is
+  # not added.  Otherwise the block is yielded and any definitions in the
+  # block will take effect.
+  #
+  # Usage:
+  #
+  #   class String
+  #     rake_extension("xyz") do
+  #       def xyz
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  def rake_extension(method)
+    if instance_methods.include?(method.to_s) || instance_methods.include?(method.to_sym)
+      $stderr.puts "WARNING: Possible conflict with Rake extension: #{self}##{method} already exists"
+    else
+      yield
+    end
+  end
+end # module Module
+
+
+######################################################################
+# User defined methods to be added to String.
+#
+class String
+  rake_extension("ext") do
+    # Replace the file extension with +newext+.  If there is no extenson on
+    # the string, append the new extension to the end.  If the new extension
+    # is not given, or is the empty string, remove any existing extension.
+    #
+    # +ext+ is a user added method for the String class.
+    def ext(newext='')
+      return self.dup if ['.', '..'].include? self
+      newext = newext.to_s
+      if newext != ''
+        newext = (newext =~ /^\./) ? newext : ("." + newext)
+      end
+      dup.sub!(%r(([^/\\])\.[^./\\]*$)) { $1 + newext } || self + newext
+    end
+  end
+
+  rake_extension("pathmap") do
+    # Explode a path into individual components.  Used by +pathmap+.
+    def pathmap_explode
+      head, tail = File.split(self)
+      return [self] if head == self
+      return [tail] if head == '.' || tail == '/'
+      return [head, tail] if head == '/'
+      return head.pathmap_explode + [tail]
+    end
+    protected :pathmap_explode
+
+    # Extract a partial path from the path.  Include +n+ directories from the
+    # front end (left hand side) if +n+ is positive.  Include |+n+|
+    # directories from the back end (right hand side) if +n+ is negative.
+    def pathmap_partial(n)
+      dirs = File.dirname(self).pathmap_explode
+      partial_dirs =
+        if n > 0
+          dirs[0...n]
+        elsif n < 0
+          dirs.reverse[0...-n].reverse
+        else
+          "."
+        end
+      File.join(partial_dirs)
+    end
+    protected :pathmap_partial
+      
+    # Preform the pathmap replacement operations on the given path. The
+    # patterns take the form 'pat1,rep1;pat2,rep2...'.
+    def pathmap_replace(patterns, &block)
+      result = self
+      patterns.split(';').each do |pair|
+        pattern, replacement = pair.split(',')
+        pattern = Regexp.new(pattern)
+        if replacement == '*' && block_given?
+          result = result.sub(pattern, &block)
+        elsif replacement
+          result = result.sub(pattern, replacement)
+        else
+          result = result.sub(pattern, '')
+        end
+      end
+      result
+    end
+    protected :pathmap_replace
+
+    # Map the path according to the given specification.  The specification
+    # controls the details of the mapping.  The following special patterns are
+    # recognized:
+    #
+    # * <b>%p</b> -- The complete path.
+    # * <b>%f</b> -- The base file name of the path, with its file extension,
+    #   but without any directories.
+    # * <b>%n</b> -- The file name of the path without its file extension.
+    # * <b>%d</b> -- The directory list of the path.
+    # * <b>%x</b> -- The file extension of the path.  An empty string if there
+    #   is no extension.
+    # * <b>%X</b> -- Everything *but* the file extension.
+    # * <b>%s</b> -- The alternate file separater if defined, otherwise use
+    #   the standard file separator.
+    # * <b>%%</b> -- A percent sign.
+    #
+    # The %d specifier can also have a numeric prefix (e.g. '%2d'). If the
+    # number is positive, only return (up to) +n+ directories in the path,
+    # starting from the left hand side.  If +n+ is negative, return (up to)
+    # |+n+| directories from the right hand side of the path.
+    #
+    # Examples:
+    #
+    #   'a/b/c/d/file.txt'.pathmap("%2d")   => 'a/b'
+    #   'a/b/c/d/file.txt'.pathmap("%-2d")  => 'c/d'
+    #
+    # Also the %d, %p, $f, $n, %x, and %X operators can take a
+    # pattern/replacement argument to perform simple string substititions on a
+    # particular part of the path.  The pattern and replacement are speparated
+    # by a comma and are enclosed by curly braces.  The replacement spec comes
+    # after the % character but before the operator letter.  (e.g.
+    # "%{old,new}d").  Muliple replacement specs should be separated by
+    # semi-colons (e.g. "%{old,new;src,bin}d").
+    #
+    # Regular expressions may be used for the pattern, and back refs may be
+    # used in the replacement text.  Curly braces, commas and semi-colons are
+    # excluded from both the pattern and replacement text (let's keep parsing
+    # reasonable).
+    #
+    # For example:
+    #
+    #    "src/org/onestepback/proj/A.java".pathmap("%{^src,bin}X.class")
+    #
+    # returns:
+    #
+    #    "bin/org/onestepback/proj/A.class"
+    #
+    # If the replacement text is '*', then a block may be provided to perform
+    # some arbitrary calculation for the replacement.
+    #
+    # For example:
+    #
+    #   "/path/to/file.TXT".pathmap("%X%{.*,*}x") { |ext|
+    #      ext.downcase
+    #   }
+    #
+    # Returns:
+    #
+    #  "/path/to/file.txt"
+    #
+    def pathmap(spec=nil, &block)
+      return self if spec.nil?
+      result = ''
+      spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
+        case frag
+        when '%f'
+          result << File.basename(self)
+        when '%n'
+          result << File.basename(self).ext
+        when '%d'
+          result << File.dirname(self)
+        when '%x'
+          result << $1 if self =~ /[^\/](\.[^.]+)$/
+        when '%X'
+          if self =~ /^(.*[^\/])(\.[^.]+)$/
+            result << $1
+          else
+            result << self
+          end
+        when '%p'
+          result << self
+        when '%s'
+          result << (File::ALT_SEPARATOR || File::SEPARATOR)
+        when '%-'
+          # do nothing
+        when '%%'
+          result << "%"
+        when /%(-?\d+)d/
+          result << pathmap_partial($1.to_i)
+        when /^%\{([^}]*)\}(\d*[dpfnxX])/
+          patterns, operator = $1, $2
+          result << pathmap('%' + operator).pathmap_replace(patterns, &block)
+        when /^%/
+          fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
+        else
+          result << frag
+        end
+      end
+      result
+    end
+  end
+end # class String