sproutcore 1.5.0.pre.4 → 1.5.0.pre.4.1

data/spec/lib/builders/chance_spec.rb

@@ -0,0 +1,81 @@
+require "lib/builders/spec_helper"
+
+describe SC::Builder::Chance do
+
+  include SC::SpecHelpers
+  include SC::BuilderSpecHelper
+
+  before do
+    std_before :chance_test
+  end
+
+  after do
+    std_after
+  end
+
+  it "should combine CSS files according to sc_require statements" do
+    # Chance's output is not guaranteed to be the same each time it runs.
+    # It will have the same effect, but details (such as some class names)
+    # will differ.
+    #
+    # To accurately test, we must simply look for file names in the comments
+    # SCSS writes and make sure the files are in the right order.
+
+    # First, generate the entries to be handed to the Chance entry.
+    file_names = %w(z_first_file.css demo.css last_file.css)
+    entries = file_names.reverse.map do |filename|
+      path = File.join(@target.source_root, 'resources', filename)
+      entry = @manifest.add_entry filename,
+        :source_path => path,
+        :staging_path => path,
+        :build_path => path
+
+      File.exist?(entry.source_path).should be_true
+      entry
+    end
+
+    entries.length.should > 0
+    file_names.length.should > 0
+
+    # We will hand the entries over in the WRONG order, because Chance parses
+    # the sc_require to determine the correct order. ordered entries should be ignored
+    filename = "stylesheet.css"
+    entry = @manifest.add_composite filename,
+      :source_entries  => entries,
+      :ordered_entries => entries
+
+    dest = entry.build_path
+
+    # Build using the entry we created
+    SC::Builder::Chance.build(entry, dest)
+    result = File.readlines(dest)*""
+
+    # Check that a chance instance is created
+    # since we don't have any sc_require, it should have the same output
+    entry[:chance].files["chance.css"].should == result
+
+    # We also expect the 2x to be the same.
+    entry[:chance].files["chance@2x.css"].should == result
+
+    # Check that all files were generated
+    %w(chance.css chance@2x.css chance.js chance-mhtml.txt).each {|e| 
+      entry[:chance].files.should include(e) 
+    }
+
+    # We loop through. If the file name matches the last one, we skip the check; if it does not,
+    # we check that it is the next item in file_names
+    last = "chance_main.css"
+    result.gsub(/\/\* line [0-9]+, (.*?)\s*\*\//) {|e|
+      next if $1 == last
+
+      # Chance appends .scss, so we have to expect that
+      last = file_names.shift + ".scss"
+      $1.end_with?(last).should be_true
+    }
+
+    file_names.length.should == 0
+
+  end
+
+
+end

data/spec/lib/builders/module_spec.rb

@@ -0,0 +1,133 @@
+require "lib/builders/spec_helper"
+
+describe 'SC::Builder::ModuleInfo' do
+
+  include SC::SpecHelpers
+  include SC::BuilderSpecHelper
+
+  describe "app target" do
+
+    before do
+      std_before :module_test
+
+      # most of these tests assume load_debug is turned off like it would be
+      # in production mode
+      @target.config.load_debug = false
+      @target.config.theme = nil
+      @target.config.use_packed = false
+      @target.config.timestamp_urls = false
+
+      # make sure all targets have the same settings...
+      @target.expand_required_targets.each do |t|
+        t.config.timestamp_urls = false
+      end
+
+      # make sure all targets have the same settings...
+      @target.modules.each do |t|
+        t.config.timestamp_urls = false
+      end
+
+      # run std rules to run manifest.  Then verify preconditions to make sure
+      # no other changes to the build system effect the ability of these tests
+      # to run properly.
+      @manifest.build!
+    end
+
+    after do
+      std_after
+    end
+
+    it "VERIFY PRECONDITIONS" do
+      @target.should be_loadable
+    end
+
+    it "should require all the required targets" do
+      req = @target.required_targets
+
+      req.size.should == 1
+      req.first.target_name.should == :'/module_test/inlined_module'
+    end
+
+    it "should require one deferred module" do
+      req = @target.modules
+
+      req.size.should == 4
+      req.first.target_name.should == :'/module_test/deferred_module'
+      req[1].target_name.should == :'/module_test/required_target'
+      req[2].target_name.should == :'/module_test/inlined_module'
+      req[3].target_name.should == :'/module_test/dynamic_req_target_1'
+    end
+  end
+
+  describe "static framework target" do
+
+    before do
+      std_before :req_target_1
+
+      # most of these tests assume load_debug is turned off like it would be
+      # in production mode
+      @target.config.load_debug = false
+      @target.config.theme = nil
+      @target.config.timestamp_urls = false
+
+      # run std rules to run manifest.  Then verify preconditions to make sure
+      # no other changes to the build system effect the ability of these tests
+      # to run properly.
+      @manifest.build!
+    end
+
+    after do
+      std_after
+    end
+
+    it "VERIFY PRECONDITIONS" do
+      @target.should_not be_loadable
+    end
+
+    it "should not require a dynamic framework" do
+      (req = @target.modules).size.should == 0
+    end
+  end
+
+  describe "dynamic framework target" do
+
+    before do
+      std_before :req_target_2
+
+      # most of these tests assume load_debug is turned off like it would be
+      # in production mode
+      @target.config.load_debug = false
+      @target.config.theme = nil
+      @target.config.timestamp_urls = false
+
+      # make sure all targets have the same settings...
+      @target.expand_required_targets.each do |t|
+        t.config.timestamp_urls = false
+      end
+
+      # make sure all targets have the same settings...
+      @target.modules.each do |t|
+        t.config.timestamp_urls = false
+      end
+
+      # run std rules to run manifest.  Then verify preconditions to make sure
+      # no other changes to the build system effect the ability of these tests
+      # to run properly.
+      @manifest.build!
+    end
+
+    after do
+      std_after
+    end
+
+    it "VERIFY PRECONDITIONS" do
+      @target.should_not be_loadable
+    end
+
+    it "should require its own dynamic framework" do
+      (req = @target.modules).size.should == 0
+      (req = @target.required_targets).size.should == 1
+    end
+  end
+
+end

data/spec/lib/helpers/minifier.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe SC::Helpers::Minifier do
+  include SC::SpecHelpers
+
+  before do
+    @project  = temp_project :helper_tests
+    @target   = @project.target_for :minifier_test
+    @manifest = @target.manifest_for :language => :en
+    @manifest.prepare!
+  end
+
+  it "saves items to be minified" do
+    SC::Helpers::Minifier << "/test/path"
+    SC::Helpers::Minifier << "/second/path"
+
+    SC::Helpers::Minifier.queue.should include("/test/path")
+    SC::Helpers::Minifier.queue.should include("/second/path")
+  end
+
+  it "minifies a file when given a path" do
+    source_path = File.join(@target.source_root, 'core.js')
+
+    SC::Helpers::Minifier.minify!(source_path)
+
+    # Fixture file contains nothing but comments. They should all be removed
+    # after minification.
+    IO.read(source_path).should == ""
+  end
+
+end

data/spec/lib/models/project/find_targets_for_spec.rb

@@ -33,7 +33,7 @@ describe SC::Project, 'find_targets_for' do
     target_types[:clients].should eql(:app)
     target_types[:frameworks].should eql(:framework)
     target_types[:themes].should eql(:theme)
-    target_types[:bundles].should eql(:framework)
+    target_types[:modules].should eql(:module)
     project.config.allow_nested_targets.should be_true
 
     # Note, this expectation assumes the fixtures in find_targets/standard has

data/vendor/chance/lib/chance/imagers/data_url.rb

@@ -7,6 +7,11 @@ module Chance
   # The DataURL Imager creates CSS with data urls for each slice.
   class DataURLImager < Chance::Imager
 
+    # Creates CSS for the slices to be provided to SCSS.
+    # This CSS is incomplete; it will need postprocessing. This CSS
+    # is generated with the set of slice definitions in @slices; the actual
+    # slicing operation has not yet taken place. The postprocessing portion
+    # receives sliced versions.
     def css
       output = ""
       slices = @slices
@@ -14,34 +19,80 @@ module Chance
       slices.each do |name, slice|
         # so, the path should be the path in the chance instance
         output += "." + slice[:css_name] + " { "
-        output += "background: url("
+        output += "_sc_chance: \"#{name}\";"
+        output += "} \n"
+      end
 
-        # set the mime type from the extension (while taking care of .jpg extensions)
-        mimeType = (slice[:path] =~ /jpg$/) ? "image/jpeg" : "image/" + slice[:path].slice(/(gif|jpeg|png)$/)
+      return output
 
-        output += '"data:' + mimeType
-        output += ';base64,'
+    end
 
-        # ChunkyPNG & RMagick images respond to to_blob, other images will be encoded from their contents
-        if (slice[:image].respond_to? "to_blob")
-          method = slice[:image].method(:to_blob)
+    def postprocess_css(src, slices)
+      src.gsub (/_sc_chance\:\s*["'](.*)["']\s*;/) {|match|
+        slice = slices[$1]
+
+        output = 'background: url("data:image/png;base64,'
+
+        base64Image = Base64.encode64(slice[:image].to_blob(:fast_rgba)).gsub("\n", "")
+        output += base64Image
 
-          # ChunkyPNG takes an argument to to_blob
-          slice[:image] = (method.arity == 1) ? slice[:image].to_blob(:fast_rgba) : slice[:image].to_blob
-        end
+        output += '");'
+        output += "\n"
 
-        base64Image = Base64.encode64(slice[:image])
+        # FOR IE < 8:
+        output += '*background: url("mhtml:chance-mhtml.txt!' + slice[:css_name] + '");'
+        output += "\n"
 
+        output
+      }
+    end
+
+    def postprocess_css_2x(src, slices)
+      src.gsub (/_sc_chance\:\s*["'](.*)["']\s*;/) {|match|
+        slice = slices[$1]
+
+        output = 'background: url("data:image/png;base64,'
+
+        base64Image = Base64.encode64(slice[:image].to_blob(:fast_rgba)).gsub("\n", "")
         output += base64Image
 
-        output += '"'
-        output += ");"
-        output += "} \n"
-      end
+        output += '");'
 
-      return output
+        output += "\n-webkit-background-size: " + slice[:target_width].to_s + "px "
+        output += slice[:target_height].to_s + "px;\n"
+
+        output
+      }
     end
 
+    def preload_javascript
+      slices = @slices
+
+      output = "if (typeof CHANCE_SLICES === 'undefined') var CHANCE_SLICES = [];"
+      output += "CHANCE_SLICES = CHANCE_SLICES.concat(["
+      output += slices.map {|name, slice| "'" + slice[:css_name] + "'" }.join(",\n")
+      output += "]);"
+    end
+
+    def mhtml(slices)
+      output = "Content-Type: multipart/related; boundary=\"CHANCE__BOUNDARY__\"\r\n"
+
+      slices.each {|name, slice|
+        output += "\n--CHANCE__BOUNDARY__\r\n"
+        output += "Content-Location:" + slice[:css_name] + "\r\n"
+        output += "Content-Transfer-Encoding:base64\r\n\r\n"
+
+        base64Image = Base64.encode64(slice[:image].to_blob(:fast_rgba)).gsub("\n", "")
+        output += base64Image
+        output += "\r\n"
+
+        output
+      }
+
+       output += "--CHANCE__BOUNDARY__--"
+
+      output
+    end
   end
 
 end

data/vendor/chance/lib/chance/instance.rb

@@ -8,7 +8,6 @@ require 'chance/sass_extensions'
 require 'chance/perf'
 require 'chance/slicing'
 
-require 'digest/md5'
 
 
 Compass.discover_extensions!
@@ -42,18 +41,28 @@ module Chance
     
     @@generation = 0
 
-    attr_accessor :css
-    
+    attr_accessor :files
+
     def initialize(options = {})
       @options = options
       @options[:theme] = "" if @options[:theme].nil?
-      
+
       if @options[:theme].length > 0 and @options[:theme][0] != "."
         @options[:theme] = "." + @options[:theme].to_s
       end
-      
-      @files = { }
-      @css = nil
+
+      # The mapped files are a map from file names in the Chance Instance to
+      # their identifiers in Chance itself.
+      @mapped_files = { }
+
+      # The @files set is the set of output files. The user of Chance should
+      # make each of these files available. Also, the files must be able to
+      # reference each other. You can supply a wrapper (in the :url_wrapper
+      # option).
+      #
+      # The Abbot build tools supply `static_url($url);`, which wraps all of
+      # the URLs with `static_url` so they can be replaced.
+      @files = {}
     end
 
     # maps a path relative to the instance to a file identifier
@@ -69,14 +78,14 @@ module Chance
 
       raise FileNotFoundError.new(path) unless file
 
-      @files[path] = identifier
+      @mapped_files[path] = identifier
     end
 
     # unmaps a path from its identifier. In short, removes a file
     # from this Chance instance. The file will remain in Chance's "virtual filesystem".
     def unmap_file(path)
       path = path.to_s
-      @files.delete path
+      @mapped_files.delete path
     end
 
     # Using a path relative to this instance, gets an actual Chance file
@@ -84,9 +93,9 @@ module Chance
     # content will have been read, and if it is an image file, will have been
     # loaded as an actual image.
     def get_file(path)
-      raise FileNotFoundError.new(path) unless @files[path]
+      raise FileNotFoundError.new(path) unless @mapped_files[path]
       
-      return Chance.get_file(@files[path])
+      return Chance.get_file(@mapped_files[path])
     end
 
     # Generates the output CSS.
@@ -102,12 +111,8 @@ module Chance
         # The output of this process is a "virtual" file that imports all of the 
         # SCSS files used by this Chance instance. This also sets up the @slices hash.
         import_css = _preprocess
-        
-        # Step 2: Slice images. The sliced canvases are saved in the individual slice
-        # hashes.
-        slice_images
-        
-        # Step 3: Generate CSS and images needed for output. For now, we hard-code
+
+        # Step 2: Generate CSS and images needed for output. For now, we hard-code
         # data url imager. Later, we will have a spriting imager.
         @imager = Chance::DataURLImager.new(@slices, self)
         
@@ -124,23 +129,39 @@ module Chance
         # else
           importer = nil
           css = @imager.css + "\n" + import_css
+          preload_javascript = @imager.preload_javascript
           cache_store = nil
         # end
 
-        # Step 4: Apply Sass Engine
+        # Step 3: Apply Sass Engine
         engine = Sass::Engine.new(css, Compass.sass_engine_options.merge({
           :syntax => :scss,
           :importer => importer,
           :filename => "chance_main.css",
-          :cache_store => cache_store
+          :cache_store => cache_store,
+          :cache_location => "./tmp/sass-cache"
         }))
         
         css = engine.render
+
+        # STEP 4: Slice images and postprocess into CSS
+        slice_images
+
+        # Normal variant (with IE7 compat)
+        css_normal = @imager.postprocess_css css, @slices
+        mhtml = @imager.mhtml(@slices)
+
+        # 2x variant
+        slice_images(true)
+        css_2x = @imager.postprocess_css_2x css, @slices
       ensure
         Chance._current_instance = nil
       end
 
-      @css = css
+      @files["chance.css"] = css_normal
+      @files["chance@2x.css"] = css_2x
+      @files["chance.js"] = preload_javascript
+      @files["chance-mhtml.txt"] = mhtml
     end
     
     # Looks up a slice that has been found by parsing the CSS. This is used by
@@ -172,7 +193,7 @@ module Chance
       return if file[:included] === @@generation
 
       requires = file[:requires]
-      requires.each {|r| _include_file(@files[r]) } unless requires.nil?
+      requires.each {|r| _include_file(@mapped_files[r]) } unless requires.nil?
 
       file[:included] = @@generation
 
@@ -186,7 +207,7 @@ module Chance
       @options[:slices] = @slices
       
       @@generation = @@generation + 1
-      files = @files.values
+      files = @mapped_files.values
       @file_list = []
 
       files.each {|f| _include_file(f) }
@@ -196,30 +217,34 @@ module Chance
         # its method of determing the current file name is a marker in the
         # file. We may want to consider changing this to a parser option
         # now that we don't need this feature so much, but this works for now.
-        content = "@_chance_file " + @files.invert[file[:path]] + ";\n"
+        content = "@_chance_file " + @mapped_files.key(file[:path]) + ";\n"
         content += "$theme: '" + @options[:theme] + "';"
         content += file[:content]
-        
+
         parser = Chance::Parser.new(content, @options)
         parser.parse
         file[:parsed_css] = parser.css
-        
+
         # NO IMPORTERS FOR NOW
         #if Chance::SUPPORTS_IMPORTERS
         #  css = "@import \"" + file [:path] + ".scss\";"
         #else
+          tmp_path = File.join("./tmp/chance/", file[:path])
+
+          # SCSS requires the file names to end with ".scss", but we may
+          # already be getting files named *.scss. So, only add the extension
+          # if it is not already there.
+          tmp_path += ".scss" unless tmp_path.end_with? ".scss"
 
-          path_hash = Digest::MD5.hexdigest(file[:path])
-          tmp_path = "./tmp/chance/#{path_hash}.scss"
           FileUtils.mkdir_p(File.dirname(tmp_path))
-          
+
           f = File.new(tmp_path, "w")
           f.write(parser.css)
           f.close
-          
+
           css = "@import \"" + tmp_path + "\";"
         # end
-        
+
         css
       }.join("\n")
     end