sproutcore 1.6.0.beta.2-x86-mingw32

data/lib/sproutcore/helpers/cssmin.rb

@@ -0,0 +1,202 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple Inc.
+#            portions copyright @2006-2011 Strobe 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-2011 Strobe 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,125 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple Inc.
+#            portions copyright @2006-2011 Strobe Inc.
+#            and contributors
+# ===========================================================================
+
+require "set"
+
+
+# Backwards compatibility for Ruby 1.8
+class Array
+  unless method_defined?(:sort_by!)
+    def sort_by!(*args, &block)
+      replace(sort_by(*args, &block))
+    end
+  end
+end
+
+
+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.
+    #
+    # When module_info.js is present, it will always be sorted first.
+    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)
+        moduleInfoEntry = []
+        bundleLoadedEntry = []
+
+        all_entries = {}
+        entries.each do |e|
+          name = e.extensionless_filename
+          all_entries[name] = e
+        end
+
+
+        # first remove bundle entries which MUST be first or last
+        entries = entries.select do |entry|
+          if entry.normalized_filename == 'module_info.js'
+            moduleInfoEntry = [entry]
+            false
+          else
+            true
+          end
+        end
+
+        entries.sort_by! do |entry|
+          name = entry.normalized_filename
+
+          result = case name
+          when /main\.js$/
+            [2, name]
+          when /(?:lproj|resources)\/.+_page\.js$/
+            [1, name]
+          when /lproj\/strings.js$/
+            [-2, name]
+          else
+            [-1, name]
+          end
+
+          # force preferred filenames to the front on the list
+          result.unshift(@preferred_filenames.include?(name) ? -1 : 1)
+        end
+
+        # now process each entry to handle requires
+        seen = Set.new
+        ret = []
+        while cur = entries.shift
+          add_entry_to_set(cur, ret, seen, entries, all_entries)
+        end
+
+        return moduleInfoEntry + ret
+      end
+
+      protected
+
+      # Converts a passed set of requires into entries
+      def required_entries(required, entries, requiring_entry, all_entries)
+        return [] unless required
+
+        required.map do |filename|
+          normalized_filename = filename.downcase
+          entry = all_entries["source/#{normalized_filename}"] || all_entries["source/lproj/#{normalized_filename}"]
+
+          unless entry
+            SC.logger.warn "Could not find entry '#{filename}' required in #{requiring_entry.target[:target_name].to_s.sub(/^\//,'')}:#{requiring_entry[:filename]}"
+          end
+
+          entry
+        end.compact
+      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|
+          add_entry_to_set(required, ret, seen, entries, all_entries)
+        end
+        ret << entry
+      end
+
+    end
+  end
+end

data/lib/sproutcore/helpers/html5_manifest.rb

@@ -0,0 +1,88 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2010 Apple Inc.
+#            portions copyright @2006-2011 Strobe Inc.
+#            and contributors
+# ===========================================================================
+require 'fileutils'
+
+module SC::Helpers
+
+  # Creates an HTML5 manifest file for application caching
+  class HTML5Manifest
+
+    def build(dst_path)
+      @files = []
+
+      @files << "CACHE MANIFEST\n# List of all resources required by this project\n"
+
+      path = dst_path.split('/tmp/build')
+
+      inspect_files(path[0] + '/tmp/build', path[1])
+
+      networks = $to_html5_manifest_networks
+      if networks
+        @files << "\n\nNETWORK:"
+        networks.each do |network|
+          @files << network
+        end
+        @files << "\n"
+      end
+
+      manifest_path = dst_path.sub('index.html', '') + 'app.manifest'
+      writelines manifest_path, @files
+    end
+
+    # writes the passed lines to the named file
+    def writelines(dst_path, lines)
+      FileUtils.mkdir_p(File.dirname(dst_path))
+      f = File.open(dst_path, 'w')
+      f.write joinlines(lines)
+      f.close
+    end
+
+    def joinlines(lines)
+      lines.join("\n")
+    end
+
+    # Reads the lines from the source file.  If the source file does not
+    # exist, returns empty array.
+    def readlines(src_path)
+      if File.exist?(src_path) && !File.directory?(src_path)
+        File.readlines(src_path)
+      else
+        []
+      end
+    end
+
+    def inspect_files(base_path, dst_path)
+      path = base_path + dst_path
+      content = readlines(path)
+
+      content.each do |line|
+        line.scan(/['"]([^\s]+?(?=\.(css|js|png|gif|jpg|jpeg))\.\2)['"]/i) do |x, y, z|
+          file_location = x
+          # in case of hyperdomaining, strip off the http part and then look
+          # for the file
+          if x[0,4] == 'http'
+            file_location = '/' + x.gsub(/https?\:\/\/.*?\//, '')
+          end
+
+          next unless File.exist?(base_path + file_location)
+
+          if !@files.include?(x)
+            @files << x
+          end
+
+          if y == 'css' || y == 'js'
+            inspect_files(base_path, file_location)
+          end
+
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/sproutcore/helpers/minifier.rb

@@ -0,0 +1,106 @@
+module SC::Helpers
+
+  # Helper to minify JavaScript files. You can either call the class method
+  # minify, or use << to add to the queue. If you add to the queue, you have
+  # no knowledge of when the minification will finish.
+  class Minifier
+    # CLASS HELPERS
+    def self.<<(path)
+      SC::Helpers::Minifier.instance << path
+    end
+
+    def self.minify(path)
+      SC::Helpers::Minifier.instance.minify path
+    end
+
+    def self.wait
+      SC::Helpers::Minifier.instance.wait
+    end
+
+    # Returns the instance (Minifier is a singleton)
+    @@instance = nil
+    def self.instance
+      @@instance = SC::Helpers::Minifier.new if @@instance.nil?
+
+      @@instance
+    end
+
+
+    # MINIFICATION MANAGER
+    def initialize
+      @queue = []
+      @working_minifiers = []
+      @max_minifiers = 4
+
+      @safety = Mutex.new
+    end
+
+    def wait
+      @working_minifiers.each {|m| m.join }
+    end
+
+
+    def <<(item)
+      @queue << item
+
+      _process_queue
+    end
+
+    # If the queue is not empty, and there are any available workers,
+    # spawn min(queue.length, max_minifiers) minifiers. They'll handle
+    # the queue on their own.
+    def _process_queue
+      [@queue.length, @max_minifiers - @working_minifiers.length].min.times {
+        _spawn_minifier
+      }
+    end
+
+    def _spawn_minifier
+      thread = Thread.new {
+        @working_minifiers << Thread.current
+
+        while @queue.length > 0
+          queue = @safety.synchronize {
+            queue = @queue.clone
+            @queue.clear
+
+            queue
+          }
+
+          next if queue.length == 0
+
+          minify(queue)
+
+          # NOTE: MORE ITEMS COULD BE ADDED TO QUEUE BY NOW,
+          # SO WE LOOP.
+        end
+
+        @working_minifiers.delete Thread.current
+      }
+    end
+
+    def minify(paths)
+      paths = paths.first if paths.is_a?(Array) && paths.length == 1
+
+      if paths.is_a?(Array)
+        paths = paths.map{|p| '"'+p+'"'}.join(' ')
+        outfile = '".js$:.js"'
+      else
+        paths = outfile = '"'+paths+'"'
+      end
+
+      command = %{java -Xmx256m -jar "#{SC.yui_jar}" -o #{outfile} #{paths} 2>&1}
+      output = `#{command}`
+
+      SC.logger.info output
+      if $?.exitstatus != 0
+        SC.logger.fatal(output)
+        SC.logger.fatal("!!!! Minifying failed. Please check that your JS code is valid.")
+        SC.logger.fatal("!!!! Failed compiling #{paths}")
+
+        exit(1)
+      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-2011 Strobe 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