sproutit-sproutcore 1.0.0.20090407205609

data/lib/sproutcore/helpers/capture_helper.rb

@@ -0,0 +1,30 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+module SC
+
+  module Helpers
+
+    module CaptureHelper
+
+      # Captures the resulting value of the block and returns it
+      def capture(*args, &block)
+        self.renderer ? self.renderer.capture(args, &block) : block.call(*args).to_s
+      end
+
+      # executes the passed block, placing the resulting content into a variable called
+      # @content_for_area_name.  You can insert this content later by including this
+      # variable or by calling yield(:area_name)
+      #
+      def content_for(name, &block)
+        eval "@content_for_#{name} = (@content_for_#{name} || '') + (capture(&block) || '')"
+        return '' # incase user does <%= content_for ... %>
+      end
+
+    end
+  end
+end

data/lib/sproutcore/helpers/cssmin.rb

@@ -0,0 +1,202 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+# module and class name have been modified
+#
+# == MIT License
+# See http://code.google.com/p/rainpress/
+#
+# == About
+#
+# Rainpress is a compressor for CSS. It's written in ruby, but should not be 
+# limited to ruby projects.
+#
+# Rainpress does not apply common compression algorithms like gzip, it removes 
+# unnecessary characters and replaces some attributes with a shorter equivalent 
+# name.
+#
+# == Links
+#
+# * {Rainpress Website}[http://rainpress.xhochy.com/]
+# * {SVN repository}[http://code.google.com/p/rainpress/source]
+# * {Bugtracker}[https://bugs.launchpad.net/rainpress/]
+# * {Wiki}[http://code.google.com/p/rainpress/w/list]
+# * {Translations}[https://translations.launchpad.net/rainpress/]
+# * {XhochY Weblog (for Announcements about Rainpress)}[http://xhochy.org/en/]
+# * {Mailinglist}[http://groups.google.com/group/xy-oss-projects-discussion]
+# * {Continous Integration Builds and Tests}[http://cruisecontrol-rb.xhochy.com/builds/rainpress]
+# * {Freshmeat Record}[http://freshmeat.net/projects/rainpress]
+module SC::Helpers
+
+  # == Information
+  #
+  # This is the main class of Rainpress, create an instance of it to compress
+  # your CSS-styles.
+  #
+  # == Simple Usage
+  #
+  #   packer = SproutCore::CSSPacker.new
+  #   compressed_style = packer.compress(style)
+  class CSSPacker
+  
+    # Use always this functions if you want to compress your CSS-style
+    #
+    # <b>Options:</b>
+    #
+    # * <tt>:preserveComments</tt> - if set to true, comments will not be 
+    #   removed
+    # * <tt>:preserveNewline</tt> - if set to true, newlines will not be removed
+    # * <tt>:preserveSpaces</tt> - if set to true, spaces will not be removed
+    # * <tt>:preserveColors</tt> - if set to true, colors will not be modified
+    # * <tt>:skipMisc</tt> - if set to true, miscellaneous compression parts
+    #   will be skipped
+    def compress(style, options = {})
+      # remove comments
+      style = remove_comments(style) unless options[:preserveComments]
+    	
+  	  # remove newlines
+      style = remove_newlines(style) unless options[:preserveNewlines]
+    	
+	  # remove unneeded spaces
+      style = remove_spaces(style) unless options[:preserveSpaces]
+    	
+	  # replace colours with shorter names
+      style = shorten_colors(style) unless options[:preserveColors]
+      
+      # make all other things
+      style = do_misc(style) unless options[:skipMisc]
+      
+	  style
+	end
+  
+    # Remove all comments out of the CSS-Document
+  	def remove_comments(script)
+      input = script
+      script = ''
+      
+      while input.length > 0 do
+        pos = input.index("/*");
+        
+        # No more comments
+        if pos == nil
+          script += input
+          input = '';
+        else # Comment beginning at pos
+          script += input[0..(pos-1)] if pos > 0 # only append text if there is some
+          input = input[(pos+2)..-1]
+          # Comment ending at pos
+          pos = input.index("*/")
+          input = input[(pos+2)..-1]
+        end
+      end
+      
+      # return
+  		script
+  	end
+
+    # Remove all newline characters
+  	def remove_newlines(script)
+  		script.gsub(/\n|\r/,'')
+  	end
+  	
+    # 1. Turn mutiple spaces into a single
+    # 2. Remove spaces around ;:{},
+    # 3. Remove tabs
+    def remove_spaces(script)
+  	  script = script.gsub(/(\s(\s)+)/, ' ')
+      script = script.gsub(/\s*;\s*/,';')
+      script = script.gsub(/\s*:\s*/,':')
+      script = script.gsub(/\s*\{\s*/,'{')
+      script = script.gsub(/\s*\}\s*/,'}')
+      script = script.gsub(/\s*,\s*/,',')
+      script.gsub("\t",'');
+  	end
+  	
+  	# Replace color values with their shorter equivalent
+  	#
+  	# 1. Turn rgb(,,)-colors into #-values
+  	# 2. Shorten #AABBCC down to #ABC
+  	# 3. Replace names with their shorter hex-equivalent
+  	#    * white -> #fff
+   	#    * black -> #000
+  	# 4. Replace #-values with their shorter name
+  	#    * #f00 -> red
+  	def shorten_colors(style)
+  	  # rgb(50,101,152) to #326598
+      style = style.gsub(/rgb\s*\(\s*([0-9,\s]+)\s*\)/) do |match|
+        out = '#'
+        $1.split(',').each do |num|
+          if num.to_i < 16 
+            out += '0'
+          end
+          out += num.to_i.to_s(16) # convert to hex
+        end
+        out
+      end
+      # #AABBCC to #ABC, keep if preceed by a '='
+      style = style.gsub(/([^\"'=\s])(\s*)#([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])/) do |match|
+        out = match        
+        if ($3.downcase == $4.downcase) and ($5.downcase == $6.downcase) and ($7.downcase == $8.downcase)
+          out = $1 + '#' + $3.downcase + $5.downcase + $7.downcase 
+        end
+        out
+      end
+      # shorten several names to numbers
+      style = style.gsub(/:[\s]*white[\s]*;/, ':#fff;')
+      style = style.gsub(/:[\s]*white[\s]*\}/, ':#fff}')
+      style = style.gsub(/:[\s]*black[\s]*;/, ':#000;')
+      style = style.gsub(/:[\s]*black[\s]*\}/, ':#000}')
+      # shotern several numbers to names
+      style = style.gsub(/:[\s]*#([fF]00|[fF]{2}0000);/, ':red;')
+      style = style.gsub(/:[\s]*#([fF]00|[fF]{2}0000)\}/, ':red}')
+      
+  	  style
+    end
+  
+    # Do miscellaneous compression methods on the style
+    def do_misc(script)
+      # Replace 0(pt,px,em,%) with 0 but only when preceded by : or a white-space
+      script = script.gsub(/([\s:]+)(0)(px|em|%|in|cm|mm|pc|pt|ex)/) do |match|
+        match.gsub(/(px|em|%|in|cm|mm|pc|pt|ex)/,'')
+      end
+      # Replace 0 0 0 0; with 0.
+      script = script.gsub(':0 0 0 0;', ':0;')
+      script = script.gsub(':0 0 0 0}', ':0}')
+      script = script.gsub(':0 0 0;', ':0;')
+      script = script.gsub(':0 0 0}', ':0}')
+      script = script.gsub(':0 0}', ':0}')
+      script = script.gsub(':0 0;', ':0;')
+      # Replace background-position:0; with background-position:0 0;
+      script = script.gsub('background-position:0;', 'background-position:0 0;');
+      # Replace 0.6 to .6, but only when preceded by : or a white-space
+      script = script.gsub(/[:\s]0+\.(\d+)/) do |match|
+        match.sub('0', '') # only first '0' !!
+      end
+      # Replace ;;;; with ;
+      script = script.gsub(/[;]+/, ';')
+      # Replace ;} with }
+      script = script.gsub(';}', '}')
+      # Replace background-color: with background:
+      script = script.gsub('background-color:', 'background:')
+      # Replace font-weight:normal; with 400, bold with 700
+      script = script.gsub(/font-weight[\s]*:[\s]*normal[\s]*;/,'font-weight:400;')
+      script = script.gsub(/font-weight[\s]*:[\s]*normal[\s]*\}/,'font-weight:400}')
+      script = script.gsub(/font[\s]*:[\s]*normal[\s;\}]*/) do |match|
+        match.sub('normal', '400')
+      end
+      script = script.gsub(/font-weight[\s]*:[\s]*bold[\s]*;/,'font-weight:700;')
+      script = script.gsub(/font-weight[\s]*:[\s]*bold[\s]*\}/,'font-weight:700}')
+      script = script.gsub(/font[\s]*:[\s]*bold[\s;\}]*/) do |match|
+        match.sub('bold', '700')
+      end
+      
+      script
+    end
+    
+  end
+  
+end

data/lib/sproutcore/helpers/dom_id_helper.rb

@@ -0,0 +1,21 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+module SC
+  module Helpers
+
+    module DomIdHelper
+      @@tick = 0
+
+      def dom_id!(type="id")
+        @@tick += 1
+        return "#{type}_#{(Time.now.to_i + @@tick)}"
+      end
+    end
+
+  end
+end

data/lib/sproutcore/helpers/entry_sorter.rb

@@ -0,0 +1,105 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+module SC
+  
+  module Helpers
+    
+    # Sorts a set of entries, respecting any "requires" found in the entries.
+    # To use the sorter, just call the class method EntrySorter.sort() passing
+    # the entries to sort along with any filenames you prefer to have added to
+    # the top.  If you don't specify any filenames, then the entries will be
+    # sorted alphabetically except for requires.
+    class EntrySorter
+    
+      def self.sort(entries, preferred_filenames = [])
+        self.new(preferred_filenames).sort(entries)
+      end
+    
+      def initialize(preferred_filenames = [])
+        @preferred_filenames = preferred_filenames
+      end
+    
+      attr_reader :preferred_filenames
+    
+      def sort(entries)
+        # first sort entries by filename - ignoring case
+        entries = entries.sort do |a,b| 
+          (a.filename || '').to_s.downcase <=> (b.filename || '').to_s.downcase
+        end
+        all_entries = entries.dup # needed for sort...
+       
+        # now process each entry to handle requires
+        seen = [] 
+        ret = [] 
+        while cur = next_entry(entries)
+          add_entry_to_set(cur, ret, seen, entries, all_entries)
+        end
+      
+        return ret
+      end
+
+      protected
+    
+      # Converts a passed set of requires into entries
+      def required_entries(required, entries, requiring_entry, all_entries)
+        return [] if required.nil?
+        required.map do |filename|
+          filename = filename.to_s.downcase.ext('')
+          source_filename = "source/#{filename}"
+          entry = all_entries.find do |e| 
+            e.filename.to_s.downcase.ext('') == source_filename
+          end
+        
+          # try localized version...
+          if entry.nil? && !(filename =~ /^lproj\//)
+            source_filename = "source/lproj/#{filename}"
+            entry = all_entries.find do |e| 
+              e.filename.to_s.downcase.ext('') == source_filename
+            end
+          end
+        
+          if entry.nil?
+            SC.logger.warn "Could not find entry '#{filename}' required in #{requiring_entry.target.target_name.to_s.sub(/^\//,'')}:#{requiring_entry.filename}"
+          end
+          
+          entry
+        end
+      end
+    
+      # Returns the next entry from the set of entries based on required order.
+      # Removed entry from array.
+      def next_entry(entries)
+        ret = nil
+      
+        # look for preferred entries first...
+        @preferred_filenames.each do |filename|
+          ret = entries.find { |e| e.filename.to_s.downcase == filename }
+          break if ret
+        end
+      
+        ret ||= entries.first # else fallback to first entry in set
+        entries.delete(ret) if ret
+        return ret 
+      end
+      
+      # Adds the specified entry to the ordered array, adding required first
+      def add_entry_to_set(entry, ret, seen, entries, all_entries)
+        return if seen.include?(entry)
+
+        seen << entry
+        req = required_entries(entry.required, entries, entry, all_entries)
+        req.each do |required|
+          next if required.nil?
+          add_entry_to_set(required, ret, seen, entries, all_entries)
+        end
+        ret << entry
+      end    
+    
+    end
+  end
+end

data/lib/sproutcore/helpers/packed_optimizer.rb

@@ -0,0 +1,102 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+module SC::Helpers
+  
+  # Given a set of targets, this can determine the optimial mix of loading
+  # packed targets vs individual targets to yield the smaller number of 
+  # assets.  To use this optimizer, just call the optimize() method.
+  class PackedOptimizer
+    
+    # Returns two arrays:  the first array are targets that should be loaded
+    # packed.  The array of targets that should be loaded, but not packed.
+    # And optional third array is also returned that includes targets which
+    # were passed in but are no longer needed because they are included in 
+    # a packed target.
+    def self.optimize(targets)
+      packed = []
+      unpacked = targets
+      cnt = packed.size + unpacked.size
+      
+      # for each target, try to use the packed version and see how many
+      # total items we come back with.  If the total number of targets is 
+      # less than the current best option, use that instead.
+      targets.each do |target|
+        cur_packed, cur_unpacked = self.new.process(target, targets)
+        cur_cnt = cur_packed.size + cur_unpacked.size
+        if cur_cnt < cnt
+          packed   = cur_packed
+          unpacked = cur_unpacked
+          cnt      = cur_cnt
+        end
+      end
+      
+      # return best!
+      return [packed, unpacked]
+    end
+    
+    attr_reader :packed
+    attr_reader :unpacked
+    
+    def initialize
+      @seen = []
+      @packed = []
+      @unpacked = []
+    end
+    
+    # Sorts the passed array of targets into packed and unpacked, starting
+    # with the passed target as the packed target.
+    def process(packed_target, targets)
+      # manually add in packed target...
+      @seen   << packed_target
+      @packed << packed_target
+      packed_target.expand_required_targets.each { |t| @seen << t }
+      
+      # then handle the rest of the targets
+      targets.each { |t| process_target(t) }
+      
+      return [packed, unpacked]
+    end
+    
+    # Sorts a single target into the correct bucket based on whether it is 
+    # seen or not.  If you also pass true to the second param, the required
+    # targets will also be sorted.
+    def process_target(target)
+      # if target was seen already, nothing to do
+      return if @seen.include?(target)
+
+      # add to seen
+      @seen << target
+      
+      # have we already seen any of the required targets?
+      req_targets = target.expand_required_targets
+      if req_targets.size > 0
+        already_seen = req_targets.find do |t|
+          @seen.include?(t)
+        end
+      else
+        already_seen = true
+      end
+      
+      
+      # if we have seen one, then we can't use the packed version so put it
+      # in the unpacked set.
+      if already_seen
+        req_targets.each { |t| process_target(t) }
+        @unpacked << target  # add last to keep order intact
+        
+      # if we have not seen any required, then we can mark this as packed.
+      # yeah!  mark the required targets as seen also
+      else
+        req_targets.each { |t| @seen << t }
+        @packed << target
+      end
+    end
+    
+  end
+  
+end