sproutcore 1.6.0.1-java → 1.7.1.beta-java

data/lib/frameworks/sproutcore/themes/legacy_theme/english.lproj/segmented.css

@@ -79,7 +79,7 @@
   background: static_url('images/sc-theme-repeat-x.png') no-repeat left -789px;
 }
 
-.sc-theme .sc-segmented-view .sc-segment label {
+.sc-theme .sc-segmented-view .sc-segment-view label {
   background: static_url('images/sc-theme-repeat-x.png') repeat-x left -764px;
   text-shadow: #fff 0px 1px 0px;
 }

data/lib/gen/app/templates/apps/@target_name@/Buildfile

@@ -3,9 +3,7 @@
 # This is your Buildfile for your app, <%= namespace %>. This tells SproutCore
 # how to build your app. These settings override those in your project
 # Buildfile, which contains default settings for all apps in your project.
-#
-# This line tells SproutCore's CSS preprocessor what class names to target.
-# Since your app has a theme named '<%= css_name %>', and it is based on SproutCore's
-# Ace theme (named 'ace'), it is set to 'ace.<%= css_name %>'.
-config :<%= target_name %>, :css_theme => 'ace.<%= css_name %>'
+
+# It is better to add :required targets here than in the global Buildfile.
+config :<%= target_name %>, :required => :sproutcore
 

data/lib/gen/app/templates/apps/@target_name@/resources/_theme.css

@@ -0,0 +1,18 @@
+/*
+  This defines the global $theme variable for use inside your CSS.
+  The $theme variable holds the CSS class names for your theme.
+  
+  You can then theme your app by using CSS like this:
+
+      $theme.button {
+        color: blue;
+        @include slices('white-button.png', $left: 3, $right: 3);
+      }
+  
+  Any _theme.css file is prepended to all files inside its directory,
+  and any subdirectories that don't define their own _theme.css file.
+  
+  This allows you to give different directories different values for
+  $theme if you wish.
+*/
+$theme: '.ace.<%= css_name %>';

data/lib/gen/project/templates/@filename@/Buildfile

@@ -1,8 +1,8 @@
 <%= copyright_block(namespace, :ruby) %>
 
 # This is your Buildfile, which sets build settings for your project.
-# For example, this tells SproutCore's build tools that your requires
-# the SproutCore framework.
+# For example, this tells SproutCore's build tools that EVERYTHING
+# requires the SproutCore framework.
 config :all, :required => :sproutcore
 
 # In addition to this Buildfile, which gives settings for your entire project,

data/lib/sproutcore.rb

@@ -47,7 +47,12 @@ module SproutCore
   # where you will find the build mode among other things set by sc-build.
   #
   def self.env
-    @env ||= HashStruct.new(:build_mode => :debug, :buildfile_names => %w(Buildfile sc-config sc-config.rb))
+    @env ||= HashStruct.new(
+      :build_mode => :debug,
+      :buildfile_names => %w(Buildfile sc-config sc-config.rb),
+      :whitelist_name => "Whitelist",
+      :blacklist_name => "Blacklist"
+    )
   end
   def self.env=(hash); @env = HashStruct.new(hash); end
 
@@ -116,10 +121,30 @@ module SproutCore
     end
   end
 
-  def self.yui_jar
-    @yui_jar ||= begin
-      yui_root = File.expand_path("../../vendor/sproutcore/lib", __FILE__)
-      File.join(yui_root, 'yuicompressor-2.4.6.jar')
+  # Additional targets to be included in the project. Each item is a hash
+  # with :path and :name attributes
+  def self.include_targets
+    @include_targets ||= []
+  end
+
+  # Adds a target to be included in the project SproutCore builds.
+  #
+  # This is useful to make additional frameworks available to SproutCore apps.
+  def self.include_target(target_name, target_path)
+    include_targets << { :name => target_name, :path => target_path }
+  end
+
+  def self.html_jar
+    @html_jar ||= begin
+      yui_root = File.expand_path("../../vendor/sproutcore", __FILE__)
+      File.join(yui_root, 'SCCompiler.jar')
+    end
+  end
+  
+  def self.js_jar
+    @js_jar ||= begin
+      yui_root = File.expand_path("../../vendor/sproutcore", __FILE__)
+      File.join(yui_root, 'lib/yuicompressor-2.4.6.jar')
     end
   end
 

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/builders/chance_file.rb

@@ -9,13 +9,18 @@ module SC
     def build(dst_path)
       instances = entry[:chance_instances] || [entry[:chance_instance]]
       
-      # Ensure all entries are staged. If -c was used, they may have been
-      # gotten rid of.
-      entry[:source_entries].each {|e| e.stage! }
+      # Ensure all entries are staged. When Abbot updates, it may skip regenerating
+      # the manifest and just run us, in which case, the previous staged version
+      # will be out-of-date.
+      entry[:source_entries].each {|e| e.stage! if entry[:build_required] }
 
       chance_file = entry[:chance_file]
 
       src = instances.map {|chance|
+        # Because files were restaged, they could be out-of-date.
+        # Let's double-check them all.
+        chance.check_all_files
+
 
         src = ""
         src = chance.output_for chance_file unless chance.nil?
@@ -40,19 +45,6 @@ module SC
     #
     # The default will rewrite calls to static_url().
     def rewrite_inline_code(code)
-      # look for sc_require, require or sc_resource.  wrap in comment
-      code.gsub!(/url\s*\(\s*["']mhtml\:chance-mhtml\.txt!(.+?)["']\s*\)/) {|mhtml|
-        static_entry = entry.manifest.find_entry("__sc_chance_mhtml.txt")
-
-        if !static_entry
-          url = ''
-        else
-          url = static_entry.cacheable_url
-        end
-
-        "expression('url(\"mhtml:' + document.location.protocol + '//' + document.location.host + '" + url + "!" + $1 + "' + '\")')"
-      }
-
       # chance_files refer, usually, to sprites.
       code.gsub!(/chance_file\(["'](.*?)['"]\)/) {|match|
         path = entry[:resource_name] + "-" + $1
@@ -63,6 +55,7 @@ module SC
         "static_url('#{$1}')"
       }
 
+      # look for sc_require, require or sc_resource.  wrap in comment
       code.gsub!(/((sc_require|require|sc_resource)\(\s*['"].*["']\s*\)\s*\;)/, '/* \1 */')
       replace_static_url(code)
       code

data/lib/sproutcore/builders/html.rb

@@ -112,7 +112,8 @@ module SC
     end
 
     def build(dst_path)
-      if CONFIG[:html5_manifest]
+      # WE ARE DISABLING HTML5 MANIFEST FOR NOW. Because it doesn't work.
+      if false and CONFIG[:html5_manifest]
         $to_html5_manifest << dst_path
         $to_html5_manifest_networks = CONFIG[:html5_manifest_networks]
         @content_for_html5_manifest = true

data/lib/sproutcore/builders/minify.rb

@@ -32,26 +32,6 @@ module SC
       send("build_#{@kind}".to_sym, dst_path)
     end
 
-    def build_css(dst_path)
-      a = Regexp.new('^'+MANIFEST.build_root)
-      if dst_path =~ a
-        # $to_minify << dst_path
-        FileUtils.mkdir_p(File.dirname(dst_path))
-        FileUtils.copy(entry.source_path, dst_path)
-      else
-        FileUtils.mkdir_p(File.dirname(dst_path)) # make sure loc exists...
-        filecompress = "java -Xmx128m -jar \"" + SC.yui_jar + "\" --type css --charset utf-8 --line-break 0 --nomunge --preserve-semi --disable-optimizations \"" + entry.source_path + "\" -o \"" + dst_path + "\" 2>&1"
-        SC.logger.info  'Compressing CSS with YUI .... '+ dst_path
-        SC.logger.debug `#{filecompress}`
-
-        if $?.exitstatus != 0
-          _report_error(output, entry.filename, entry.source_path)
-          SC.logger.fatal("!!!!YUI compressor failed, please check that your css code is valid.")
-          SC.logger.fatal("!!!!Failed compressing CSS... "+ dst_path)
-        end
-      end
-    end
-
     # Minify some javascript by invoking the YUI compressor.
     def build_javascript(dst_path)
       entry.source_entry.build!
@@ -63,21 +43,10 @@ module SC
         SC::Helpers::Minifier << dst_path
       end
     end
-
-    def build_inline_javascript(dst_path)
-      SC.logger.info  'Compiling inline Javascript with YUI: ' + dst_path + "..."
-      FileUtils.mkdir_p(File.dirname(dst_path)) # make sure loc exists...
-      filecompress = "java -Xmx128m -jar \"" + SC.yui_jar + "\" --type js \"" + entry.source_path + "\" -o \"" + dst_path + "\" 2>&1"
-      SC.logger.info  'Compiling with YUI:  '+ filecompress + "..."
-
-      output = `#{filecompress}`      # It'd be nice to just read STDERR, but
-                                      # I can't find a reasonable, commonly-
-                                      # installed, works-on-all-OSes solution.
-      if $?.exitstatus != 0
-        _report_error(output, entry.filename, entry.source_path)
-        SC.logger.fatal("!!!!YUI compiler failed, please check that your js code is valid")
-        SC.logger.fatal("!!!!Failed compiling ... "+ dst_path)
-      end
+    
+    def build_html(dst_path)
+      entry.source_entry.build!
+      SC::Helpers::Minifier << dst_path
     end
 
   private

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/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/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
+