sproutcore 1.6.0.1 → 1.7.1.beta

data/lib/sproutcore/builders/module.rb

@@ -34,6 +34,13 @@ module SC
             scriptURL:'<%= @script %>',
             stringURL:'<%= @string %>'<% if @prefetched %>,
             isPrefetched: YES
+            <% end %><% if @inlined %>,
+            isLoaded: YES,
+            source: <%= @source %>
+            <% end %><% if @css_source %>,
+            cssSource: <%= @css_source %>
+            <% end %><% if @css_2x_source %>,
+            css2xSource: <%= @css_2x_source %>
             <% end %>
           })
         })();
@@ -56,6 +63,32 @@ module SC
 
         module_info = t.module_info({ :variation => entry[:variation] })
 
+        # Handle inlined modules. Inlined modules get included as strings
+        # in the module info.
+        source = nil, css_source = nil, css_2x_source = nil
+
+        # if (and only if) the module is inlined, we must include the source
+        # for the JS AND CSS inline as well (as strings)
+        if t[:inlined_module]
+          source = File.read(script_entry.stage![:staging_path]).to_json
+
+          css_entry = manifest.find_entry('stylesheet.css')
+          if css_entry
+            css_path = css_entry.stage![:staging_path]
+
+            # We must check if the file exists because there are cases where we can have
+            # an entry but no file: no file is added if the file is empty, but the file
+            # could be empty if all input files are empty or full of comments.
+            css_source = File.read(css_path).to_json if File.exist? css_path
+          end
+
+          css_2x_entry = manifest.find_entry('stylesheet@2x.css')
+          if css_2x_entry
+            css_2x_path = css_2x_entry.stage![:staging_path]
+            css_2x_source = File.read(css_2x_path).to_json if File.exist? css_2x_path
+          end
+        end
+
         output << eruby.evaluate({
           :target_name => t[:target_name].to_s.sub(/^\//,''),
           :dependencies    => module_info[:requires].map{ |t| "'#{t[:target_name].to_s.sub(/^\//,'')}'" },
@@ -63,7 +96,11 @@ module SC
           :styles2x    => module_info[:css_2x_urls].map {|url| "'#{url}'"},
           :script      => script_url,
           :string      => string_url,
-          :prefetched  => t[:prefetched_module]
+          :source      => source,
+          :inlined     => t[:inlined_module],
+          :prefetched  => t[:prefetched_module],
+          :css_source  => css_source,
+          :css_2x_source => css_2x_source
         })
       end
       writelines dst_path, [output]

data/lib/sproutcore/builders/split.rb

@@ -0,0 +1,63 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2011 Apple Inc.
+# ===========================================================================
+
+require "sproutcore/builders/base"
+require 'fileutils'
+
+module SC
+
+  # This builder is used to split packed CSS files, ironically enough,
+  # into smaller CSS files. This is due to an IE limitation of ~4096 maximum
+  # selectors per file.
+  #
+  # This is a bit hacky, but we add additional manifest entries even though, technically,
+  # the manifest generation process is finished. We do this because we have NO WAY
+  # of knowing how many selectors there will be until CSS is both built and packed.
+  #
+  # The static HTML helper makes sure to build! the packed stylesheet entries first so
+  # that this rule has been processed. After that, it looks for [:split_entries] on the
+  # packed entry.
+  class Builder::SplitCSS < Builder::Base
+    def build(dst_path)
+      e = entry.source_entry
+      e.stage!
+      
+      src = File.read(entry[:staging_path])
+      files = SC::Helpers::SplitCSS.split_css src
+      
+      if files.length > 1 and entry.target.config[:split_css_for_ie]
+        entry[:split_entries] = []
+        entry[:is_split] = true
+        entry.hide!
+        
+  
+        files.each_index {|index|
+          name = entry[:filename].sub /\.css$/, ""
+          
+          path = dst_path.sub /\.css$/, ""
+          path = "#{path}-#{index}.css"
+      
+          writeline path, files[index]
+      
+          # Is this hacky? Yes. But IE is stupid. So we have to modify the manifest
+          # very late, because we don't know the 
+          resource_name = "#{name}-#{index}.css"
+          split_entry = entry.manifest.add_composite resource_name,
+            :staging_path => path,
+            :build_path => path,
+            :source_entries => [entry],
+            :url => [entry.manifest[:url_root], resource_name].join("/"),
+            :timestamp => entry[:timestamp]
+
+          entry[:split_entries] << split_entry
+        }
+      else
+        e.build!
+      end
+    end
+
+  end
+
+end

data/lib/sproutcore/builders/strings.rb

@@ -33,7 +33,13 @@ module SC
       str.scan(/['"](.+)['"]\s*:\s*['"](.+)['"],?\s*$/) do |x,y|
         # x & y are JS strings that must be evaled as such..
         #x = eval(%("#{x}"))
-        y = eval(%[<<__EOF__\n#{y}\n__EOF__]).chop
+        begin
+          y = eval(%[<<__EOF__\n#{y}\n__EOF__]).chop
+        rescue SyntaxError
+          puts "Invalid string in #{source_path}:"
+          puts $&
+          exit
+        end
         ret[x] = y
       end
       return ret

data/lib/sproutcore/builders.rb

@@ -13,3 +13,4 @@ require "sproutcore/builders/test"
 require "sproutcore/builders/test_index"
 require "sproutcore/builders/string_wrapper"
 require "sproutcore/builders/handlebars"
+require "sproutcore/builders/split"

data/lib/sproutcore/helpers/css_split.rb

@@ -0,0 +1,190 @@
+# THE PARSER
+#
+# The parser will not bother splitting into tokens. We are _a_
+# step up from Regular Expressions, not a thousand steps.
+#
+# In short, we keep track of two things: { } and strings.
+#
+# Other than that, we look for @theme, slices(), and slice(),
+# in their various forms.
+#
+# Our method is to scan until we hit a delimiter followed by any
+# of the following:
+#
+# - @theme
+# - @include slices(
+# - slices(
+# - slice(
+#
+# Options
+# --------------------------------
+# You may pass a few configuration options to a Chance instance:
+#
+# - :theme: a selector that will make up the initial value of the $theme
+#   variable. For example: :theme => "ace.test-controls"
+#
+#
+# How Slice & Slices work
+# -------------------------------
+# @include slice() and @include slices() are not actually responsible
+# for slicing the image. They do not know the image's width or height.
+#
+# All that they do is determine the slice's configuration, including
+# its file name, the rectangle to slice, etc.
+require "stringio"
+
+
+module SC::Helpers
+  
+  module SplitCSS
+    UNTIL_SINGLE_QUOTE = /(?!\\)'/
+    UNTIL_DOUBLE_QUOTE = /(?!\\)"/
+
+    BEGIN_SCOPE = /\{/
+    END_SCOPE = /\}/
+    NORMAL_SCAN_UNTIL = /[^{},]+/
+    
+    MAX_SELECTOR_COUNT = 4000
+    
+    def self.split_css(input)
+      scanner = StringScanner.new(input)
+      
+      current = ""
+      ret = [current]
+      
+      selectors = ""
+      in_selector = false
+      selector_count = 0
+      
+      while not scanner.eos?
+        # Handle any strings, etc. This also handles whitespace, strings, blah.
+        # Basically, unless we see a scope, we know we are in a selector.
+        selectors << handle_skip(scanner)
+        
+        # Handle scope
+        if scanner.match?(BEGIN_SCOPE)
+          # Push the current selectors
+          current << selectors
+          selectors = ""
+          in_selector = false
+          
+          current << handle_scope(scanner)
+          
+          # For readability and reliability in certain browsers, add a newline at the end
+          # of each rule.
+          current << "\n"
+          next
+        end
+        
+        # Handle , -- which would mean we are finishing a selector
+        if scanner.match? /,/
+          selectors << scanner.scan(/,/)
+          in_selector = false
+          
+          next
+        end
+        
+        if not in_selector
+          # At this point we MUST be in a selector.
+          in_selector = true
+          selector_count += 1
+          
+          if selector_count > MAX_SELECTOR_COUNT
+            current = ""
+            ret << current
+            
+            selector_count = 0
+          end
+        end
+        
+        # skip over anything that our tokens do not start with. We implement this differently
+        # since these are ONLY selectors, and therefore we must add them to selector instead of output.
+        res = scanner.scan(NORMAL_SCAN_UNTIL)
+        break if scanner.eos?
+        
+        if res.nil?
+          selectors << scanner.getch
+        else
+          selectors << res
+        end
+      end
+      
+      ret
+    end
+    
+    def self.handle_scope(scanner)
+      str = ""
+      
+      # Consume the begin scope we matched
+      str << scanner.scan(BEGIN_SCOPE)
+      
+      while not scanner.eos?
+        str << handle_skip(scanner)
+        
+        if scanner.match? BEGIN_SCOPE
+          str << self.handle_scope(scanner)
+        end
+        
+        if scanner.match? END_SCOPE
+          str << scanner.scan(END_SCOPE)
+          return str
+        end
+        
+        str << handle_content(scanner)
+      end
+      
+      str
+    end
+    
+    def self.handle_content(scanner)
+      str = ""
+      
+      res = scanner.scan(NORMAL_SCAN_UNTIL)
+      if res.nil?
+        str << scanner.getch
+      else
+        str << res
+      end
+      
+      str
+    end
+    
+    def self.handle_skip(scanner)
+      str = ""
+
+      while true do
+        if scanner.match?(/\s+/)
+          str << scanner.scan(/\s+/)
+          next
+        end
+        if scanner.match?(/\/\*/)
+          str << handle_comment(scanner)
+          next
+        end
+        if scanner.match?(/["']/)
+          str << handle_string(scanner)
+          next
+        end
+        break
+      end
+      
+      str
+    end
+    
+    def self.handle_comment(scanner)
+      str = '/*'
+      
+      scanner.pos += 2
+      str << scanner.scan_until(/\*\//)
+    end
+    
+    def self.handle_string(scanner)
+      str = scanner.getch
+      str += scanner.scan_until(str == "'" ? UNTIL_SINGLE_QUOTE : UNTIL_DOUBLE_QUOTE)
+      
+      str
+    end
+    
+  end
+end
+

data/lib/sproutcore/helpers/entry_sorter.rb

@@ -72,6 +72,8 @@ module SC
             [1, name]
           when /lproj\/strings.js$/
             [-2, name]
+          when /lproj\/layout.js$/
+            [-2, name]
           else
             [-1, name]
           end

data/lib/sproutcore/helpers/minifier.rb

@@ -80,26 +80,50 @@ module SC::Helpers
     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+'"'
+      if not paths.kind_of?(Array)
+        paths = [paths]
+      end
+      
+      # Split paths into HTML and JS
+      html_paths = paths.select {|p| p =~ /\.html$/}
+      js_paths = paths.select {|p| p =~ /\.js$/}
+      
+      if html_paths.length > 0
+        command = %{java -jar "#{SC.html_jar}" "#{html_paths.join '" "'}" 2>&1}
+        puts "Executing #{command}"
+        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
+      
+      if js_paths.length > 0
+        js_paths.each {|p|
+          command = %{java -jar "#{SC.js_jar}" -o "#{p}" "#{p}" 2>&1}
+          puts "Executing #{command}"
+          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
 
-      command = %{java -Xmx256m -jar "#{SC.yui_jar}" -o #{outfile} #{paths} 2>&1}
-      output = `#{command}`
+      # SCyui doesn't need a -o. It writes to the original path.
+
 
-      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

data/lib/sproutcore/helpers/static_helper.rb

@@ -75,22 +75,15 @@ module SC
         combine_stylesheets = t.config[:combine_stylesheets]
 
         combined_entries(t, opts, 'stylesheet.css', 'stylesheet-packed.css') do |cur_target, cur_entry|
-
           # We have to figure out if we should use the 2x version.
           # For this, we have to figure out the original name again...
           if opts[:x2]
-            name = cur_entry.extensionless_filename
+            name = cur_entry.filename
 
-            if name == "stylesheet"
-              name = "stylesheet@2x.css"
-            elsif name == "stylesheet-packed"
-              name = "stylesheet@2x-packed.css"
-            else
-              raise "Unexpected entry name when collecting CSS: " + name
-            end
+            name = name.gsub /stylesheet/, "stylesheet@2x"
 
             v = opts[:language] ? { :language => opts[:language] } : manifest.variation
-            x2_entry = t.manifest_for(v).entry_for name
+            x2_entry = cur_target.manifest_for(v).entry_for name
 
             cur_entry = x2_entry if x2_entry
           end
@@ -190,11 +183,7 @@ module SC
             ret << inline_javascript(resource_name)
           end
         end
-
-        url_prefix = $script_name ? %("#{$script_name}") : "null";
-
-        ret << %(<script type="text/javascript">SC.buildMode = "#{SC.build_mode}"; \n SC.urlPrefix = #{url_prefix}; </script>)
-
+        
         return ret * "\n"
       end
 
@@ -413,6 +402,13 @@ module SC
 
           # get the stylesheet or js entry for it...
           entry = cur_manifest.entry_for packed_entry_name
+          
+          if entry.nil?
+            # If it didn't find it, it may have been hidden by the IE hack for splitting CSS.
+            # In this case, we have to find it, but searching for any hidden file won't work
+            # because there could be more than one. So, we search based on 
+            entry = cur_manifest.entry_for packed_entry_name, { :hidden => true, :is_split => true  }
+          end
 
           # It used to be like this:
           # next if entry.nil? || !entry.composite? # no stylesheet or js
@@ -420,8 +416,30 @@ module SC
           # a reason to check for composite entries, either. So, the composite
           # check has been removed.
           next if entry.nil? # no stylesheet or js
-
-          yield(t, entry)
+          
+          # HACK FOR IE. Yes, IE hacks are now in Ruby as well! Isn't that grand!
+          # Basically, IE does not allow more than 4096 selectors. The problem: it has
+          # a max of 4096 selectors per file!!!
+          #
+          # and the problem is, we don't know the number of selectors until AFTER CSS
+          # is built. So, we have to, at the last minute, find these other files.
+          # They are given entries, but these entries are supplied AFTER the manifest
+          # is technically finished. So, it is only now that we can go find them.
+          #
+          # In fact: it may not even be around yet. It won't until this CSS entry is built.
+          # We didn't always have to build the CSS entries before serving HTML but... now we do.
+          # Because IE sucks.
+          entry.build!
+          
+          # The builder adds a :split_entries. :split_entries were added, we need to split
+          # CSS files.
+          if entry[:split_entries]
+            entry[:split_entries].each {|e|
+              yield(t, e)
+            }
+          else
+            yield(t, entry)
+          end
         end
 
         unpacked.each do |t|

data/lib/sproutcore/helpers.rb

@@ -8,4 +8,4 @@ require "sproutcore/helpers/static_helper"
 require "sproutcore/helpers/tag_helper"
 require "sproutcore/helpers/text_helper"
 require "sproutcore/helpers/minifier"
-
+require "sproutcore/helpers/css_split"

data/lib/sproutcore/models/manifest.rb

@@ -93,6 +93,31 @@ module SC
     end
 
     def built?; @is_built; end
+    
+    #
+    # Resets this manifest, and all same-variation manifests the target depends on.
+    # This is useful when building: it clears the entries and frees up memory so
+    # building doesn't take multiple gigabytes.
+    #
+    def reset!
+      return if @is_resetting
+      @is_resetting = true
+      
+      targets = target.expand_required_targets({ :theme => true }) + [target]
+      entries = targets.map do |t|
+        t.manifest_for(variation).reset!
+      end
+      
+      targets = target.modules({ :debug => false, :test => false, :theme => true }).each do |t|
+        t.manifest_for(variation).reset!
+      end
+      
+      reset_entries!
+      
+      @is_resetting = false
+      
+      return self
+    end
 
     # Resets the manifest entries.  this is called before a build is
     # performed. This will reset only the entries, none of the other props.
@@ -102,6 +127,7 @@ module SC
     #
     def reset_entries!
       @is_built = false
+      self.delete(:entries)
       @entries = EntryList.new
       return self
     end

data/lib/sproutcore/models/target.rb

@@ -157,6 +157,11 @@ module SC
       # make sure we update for changes in theme and required (commonly changed):
       key << config[:theme].to_s if config[:theme] and opts[:theme]
       key << config[:required].to_s if config[:required]
+      if opts[:modules]
+        key << config[:inlined_modules] if config[:inlined_modules]
+        key << config[:prefetched_modules] if config[:prefetched_modules]
+        key << config[:deferred_modules] if config[:deferred_modules]
+      end
 
       key = key.compact.join('.')
 
@@ -166,7 +171,7 @@ module SC
       return ret unless ret.nil?
 
       # else compute return value, respecting options
-      ret = [config[:required], config[:inlined_modules]]
+      ret = [config[:required]]
       if opts[:debug] && config[:debug_required]
         ret << config[:debug_required]
       end
@@ -190,6 +195,12 @@ module SC
         end
       end
 
+      if opts[:modules]
+        ret << config[:inlined_modules]
+        ret << config[:prefetched_modules]
+        ret << config[:deferred_modules]
+      end
+
       ret = ret.flatten.compact.map do |n|
         if (t = target_for(n)).nil?
           SC.logger.warn "Could not find target #{n} that is required by #{self[:target_name]}"