sproutcore 1.6.0.1 → 1.7.1.beta

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

@@ -18,12 +18,12 @@ module Chance
       # images in the class's @sprites property and updating the individual slices 
       # with a :sprite property containing the identifier of the sprite, and offset
       # properties for the offsets within the image.
-      def generate_sprite_definitions(opts)
+      def generate_sprite_definitions(opts)        
         @sprites = {}
 
         group_slices_into_sprites(opts)
         @sprites.each do |key, sprite|
-          layout_slices_in_sprite sprite
+          layout_slices_in_sprite sprite, opts
         end
       end
 
@@ -70,7 +70,7 @@ module Chance
       # Determines the name of the sprite for the given slice. The sprite
       # by this name may not exist yet.
       def sprite_name_for_slice(slice, opts)
-        if slice[:repeat] == "repeat-both"
+        if slice[:repeat] == "repeat"
           return slice[:path] + (opts[:x2] ? "@2x" : "")
         end
 
@@ -79,10 +79,23 @@ module Chance
 
       # Performs the layout operation, laying either up-to-down, or "
       # (for repeat-y slices) left-to-right.
-      def layout_slices_in_sprite(sprite)
+      def layout_slices_in_sprite(sprite, opts)
         # The position is the position in the layout direction. In vertical mode
         # (the usual) it is the Y position.
         pos = 0
+        
+        # Adds some padding that will be painted with a pattern so that it is apparent that
+        # CSS is wrong.
+        # NOTE: though this is only in debug mode, we DO need to make sure it is on a 2px boundary.
+        # This makes sure 2x works properly.
+        padding = @options[:pad_sprites_for_debugging] ? 2 : 0
+        
+        # The position within a row. It starts at 0 even if we have padding,
+        # because we always just add padding when we set the individual x/y pos.
+        inset = 0
+        
+        # The length of the row. Length, when layout out vertically (the usual), is the height
+        row_length = 0
 
         # The size is the current size of the sprite in the non-layout direction;
         # for example, in the usual, vertical mode, the size is the width.
@@ -94,17 +107,19 @@ module Chance
         smallest_size = nil
 
         is_horizontal = sprite[:use_horizontal_layout]
-
-        sprite[:slices].each do |slice|
+        
+        # Figure out slice width/heights. We cannot rely on slicing to do this for us
+        # because some images may be being passed through as-is.
+        sprite[:slices].each {|slice|
           # We must find a canvas either on the slice (if it was actually sliced),
           # or on the slice's file. Otherwise, we're in big shit.
           canvas = slice[:canvas] || slice[:file][:canvas]
-
+        
           # TODO: MAKE A BETTER ERROR.
           unless canvas
-            throw "Could not sprite image " + slice[:path] + "; if it is not a PNG"
+            throw "Could not sprite image " + slice[:path] + "; if it is not a PNG, make sure you have rmagick installed"
           end
-
+          
           # RMagick has a different API than ChunkyPNG; we have to detect
           # which one we are using, and use the correct API accordingly.
           if canvas.respond_to?('columns')
@@ -114,10 +129,10 @@ module Chance
             slice_width = canvas.width
             slice_height = canvas.height
           end
-
+          
           slice_length = is_horizontal ? slice_width : slice_height
           slice_size = is_horizontal ? slice_height : slice_width
-
+          
           # When repeating, we must use the least common multiple so that
           # we can ensure the repeat pattern works even with multiple repeat
           # sizes. However, we should take into account how much extra we are
@@ -128,8 +143,41 @@ module Chance
 
             size = size.lcm slice_size
           else
-            size = [size, slice_size].max
+            size = [size, slice_size + padding * 2].max
+          end
+          
+          slice[:slice_width] = slice_width.to_i
+          slice[:slice_height] = slice_height.to_i
+        }
+        
+        # Sort slices from widest/tallest (dependent on is_horizontal) or is_vertical
+        # NOTE: This means we are technically sorting reversed
+        sprite[:slices].sort! {|a, b|
+          # WHY <=> NO WORK?
+          if is_horizontal
+            b[:slice_height] <=> a[:slice_height]
+          else
+            b[:slice_width] <=> a[:slice_width]
+          end
+        }
+
+        sprite[:slices].each do |slice|
+          # We must find a canvas either on the slice (if it was actually sliced),
+          # or on the slice's file. Otherwise, we're in big shit.
+          canvas = slice[:canvas] || slice[:file][:canvas]
+          
+          slice_width = slice[:slice_width]
+          slice_height = slice[:slice_height]
+          
+          slice_length = is_horizontal ? slice_width : slice_height
+          slice_size = is_horizontal ? slice_height : slice_width
+          
+          if slice[:repeat] != "no-repeat" or inset + slice_size + padding * 2 > size or not @options[:optimize_sprites]
+            pos += row_length
+            inset = 0
+            row_length = 0
           end
+            
 
           # We have extras for manual tweaking of offsetx/y. We have to make sure there
           # is padding for this (on either side)
@@ -149,20 +197,44 @@ module Chance
           elsif slice[:max_offset_y] > 0 and not is_horizontal
             pos += slice[:max_offset_y]
           end
-
-
-          slice[:sprite_slice_x] = is_horizontal ? pos : 0
-          slice[:sprite_slice_y] = is_horizontal ? 0 : pos
+          
+          slice[:sprite_slice_x] = (is_horizontal ? pos : inset)
+          slice[:sprite_slice_y] = (is_horizontal ? inset : pos)
+          
+          # add padding for x, only if it a) doesn't repeat or b) repeats vertically because it has horizontal layout
+          if slice[:repeat] == "no-repeat" or slice[:repeat] == "repeat-y"
+            slice[:sprite_slice_x] += padding
+          end
+          
+          if slice[:repeat] == "no-repeat" or slice[:repeat] == "repeat-x"
+            slice[:sprite_slice_y] += padding
+          end
+          
           slice[:sprite_slice_width] = slice_width
           slice[:sprite_slice_height] = slice_height
 
-          pos += slice_length
+          inset += slice_size + padding * 2
+          
+          # We pad the row length ONLY if it is a repeat-x, repeat-y, or no-repeat image.
+          # If it is 'repeat', we do not pad it, because it should be processed raw.
+          row_length = [slice_length + (slice[:repeat] != "repeat" ? padding * 2 : 0), row_length].max
+          
+          # In 2X, make sure we are aligned on a 2px grid.
+          # We correct this AFTER positioning because we always position on an even grid anyway;
+          # we just may leave that even grid if we have an odd-sized image. We do this after positioning
+          # so that the next loop knows if there is space.
+          if opts[:x2]
+            row_length = (row_length.to_f / 2).ceil * 2
+            inset = (inset.to_f / 2).ceil * 2
+          end
+          
         end
+        pos += row_length
 
         # TODO: USE A CONSTANT FOR THIS WARNING
         smallest_size = size if smallest_size == nil
         if size - smallest_size > 10
-          puts "WARNING: Used more than 10 extra rows or columns to accomdate repeating slices."
+          puts "WARNING: Used more than 10 extra rows or columns to accommodate repeating slices."
           puts "Wasted up to " + (pos * size-smallest_size).to_s + " pixels"
         end
 
@@ -177,6 +249,14 @@ module Chance
       def generate_sprite(sprite)
         canvas = canvas_for_sprite(sprite)
         sprite[:canvas] = canvas
+        
+        # If we are padding sprites, we should paint the background something really
+        # obvious & obnoxious. Say, magenta. That's obnoxious. A nice light purple wouldn't
+        # be bad, but magenta... that will stick out like a sore thumb (I hope)
+        if @options[:pad_sprites_for_debugging]
+          magenta = ChunkyPNG::Color.rgb(255, 0, 255)
+          canvas.rect(0, 0, sprite[:width], sprite[:height], magenta, magenta)
+        end
 
         sprite[:slices].each do |slice|
           x = slice[:sprite_slice_x]
@@ -221,14 +301,18 @@ module Chance
 
         # Repeat the pattern to fill the width/height.
         while top < height do
+          left = 0
+
           while left < width do
-            if target.respond_to?(:compose)
-              target.compose!(source_canvas, left + x, top + y)
+            if target.respond_to?(:replace!)
+              target.replace!(source_canvas, left + x, top + y)
             else
               target.composite!(source_canvas, left + x, top + y)
             end
+
             left += source_width
           end
+
           top += source_height
         end
 
@@ -295,7 +379,14 @@ module Chance
 
         generate_sprite(sprite) if not sprite[:has_generated]
 
-        sprite[:canvas].to_blob
+        ret = sprite[:canvas].to_blob
+        
+        if Chance.clear_files_immediately
+          sprite[:canvas] = nil
+          sprite[:has_generated] = false
+        end
+        
+        ret
       end
 
       def sprite_names(opts={})

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

@@ -10,6 +10,8 @@ require 'chance/instance/spriting'
 require 'chance/instance/data_url'
 require 'chance/instance/javascript'
 
+require 'digest/md5'
+
 
 Compass.discover_extensions!
 Compass.configure_sass_plugin!
@@ -21,7 +23,9 @@ module Chance
     attr_reader :path
     def initialize(path)
       @path = path
+      super(message)
     end
+
     def message
       "File not mapped in Chance instance: #{path}"
     end
@@ -48,18 +52,25 @@ module Chance
       "chance@2x.css"         => { :method => :css, :x2 => true },
       "chance-sprited.css"    => { :method => :css, :sprited => true },
       "chance-sprited@2x.css" => { :method => :css, :sprited => true, :x2 => true },
-      "chance.js"             => { :method => :javascript },
-      "chance-mhtml.txt"      => { :method => :mhtml },
 
       # For Testing Purposes...
       "chance-test.css"       => { :method => :chance_test }
     }
 
+    @@uid = 0
+    
     @@generation = 0
 
     def initialize(options = {})
       @options = options
       @options[:theme] = "" if @options[:theme].nil?
+      @options[:pad_sprites_for_debugging] = true if @options[:pad_sprites_for_debugging].nil?
+      @options[:optimize_sprites] = true if @options[:optimize_sprites].nil?
+      
+      @@uid += 1
+      @uid = @@uid
+      
+      @options[:instance_id] = @uid if @options[:instance_id].nil?
 
       if @options[:theme].length > 0 and @options[:theme][0] != "."
         @options[:theme] = "." + @options[:theme].to_s
@@ -68,6 +79,10 @@ module Chance
       # The mapped files are a map from file names in the Chance Instance to
       # their identifiers in Chance itself.
       @mapped_files = { }
+      
+      # The file mtimes are a collection of mtimes for all the files we have. Each time we
+      # read a file we record the mtime, and then we compare on check_all_files
+      @file_mtimes = { }
 
       # The @files set is a set cached generated output files, used by the output_for
       # method.
@@ -80,6 +95,10 @@ module Chance
 
       # Tracks whether _render has been called.
       @has_rendered = false
+      
+      # A generation number for the current render. This allows the slicing and spriting
+      # to be invalidated smartly.
+      @render_cycle = 0
     end
 
     # maps a path relative to the instance to a file identifier
@@ -90,6 +109,11 @@ module Chance
     # The identifier would be a name of a file that you added to
     # Chance using add_file.
     def map_file(path, identifier)
+      if @mapped_files[path] == identifier
+        # Don't do anything if there is nothing to do.
+        return
+      end
+      
       path = path.to_s
       file = Chance.has_file(identifier)
 
@@ -104,12 +128,35 @@ module Chance
     # 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)
+      if not @mapped_files.include?(path)
+        # Don't do anything if there is nothing to do
+        return
+      end
+      
       path = path.to_s
       @mapped_files.delete path
 
       # Invalidate our render because things have changed.
       clean
     end
+    
+    # unmaps all files
+    def unmap_all
+      @mapped_files = {}
+    end
+
+    # checks all files to see if they have changed
+    def check_all_files
+      needs_clean = false
+      @mapped_files.each {|p, f|
+        mtime = Chance.update_file_if_needed(f)
+        if @file_mtimes[p].nil? or mtime > @file_mtimes[p]
+          needs_clean = true
+        end
+      }
+      
+      clean if needs_clean
+    end
 
     # Using a path relative to this instance, gets an actual Chance file
     # hash, with any necessary preprocessing already performed. For instance,
@@ -178,6 +225,9 @@ module Chance
     def _render
       return if @has_rendered
 
+      # Update the render cycle to invalidate sprites, slices, etc.
+      @render_cycle = @render_cycle + 1
+      
       @files = {}
       begin
         # SCSS code executing needs to know what the current instance of Chance is,
@@ -188,13 +238,25 @@ 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
+        
+        # Because we encapsulate with instance_id, we should not have collisions even IF another chance
+        # instance were running at the same time (which it couldn't; if it were, there'd be MANY other issues)
+        image_css_path = File.join('./tmp/chance/image_css', @options[:instance_id].to_s, '_image_css.scss')
+        FileUtils.mkdir_p(File.dirname(image_css_path))
+        
+        file = File.new(image_css_path, "w")
+        file.write(_css_for_slices)
+        file.close
+        
+        image_css_path = File.join('./tmp/chance/image_css', @options[:instance_id].to_s, 'image_css')
+        
 
         # STEP 2: Preparing input CSS
         # The main CSS file we pass to the Sass Engine will have placeholder CSS for the
         # slices (the details will be postprocessed out).
         # After that, all of the individual files (using the import CSS generated
         # in Step 1)
-        css = _css_for_slices + "\n" + import_css
+        css = "@import \"#{image_css_path}\";\n" + import_css
 
         # Step 3: Apply Sass Engine
         engine = Sass::Engine.new(css, Compass.sass_engine_options.merge({
@@ -218,17 +280,24 @@ module Chance
     # slicing operation has not yet taken place. The postprocessing portion
     # receives sliced versions.
     def _css_for_slices
-      output = ""
+
+      output = []
       slices = @slices
 
       slices.each do |name, slice|
-        # so, the path should be the path in the chance instance
-        output += "." + slice[:css_name] + " { "
-        output += "_sc_chance: \"#{name}\";"
-        output += "} \n"
+        # Write out comments specifying all the files the slice is used from
+        output << "/* Slice #{name}, used in: \n"
+        slice[:used_by].each {|used_by|
+          output << "\t#{used_by[:path]}\n"
+        }
+        output << "*/"
+
+        output << "." + slice[:css_name] + " { "
+        output << "_sc_chance: \"#{name}\";"
+        output << "} \n"
       end
 
-      return output
+      return output.join ""
 
     end
 
@@ -241,16 +310,63 @@ module Chance
     # :sprited => whether to use spriting instead of data uris.
     def _postprocess_css(opts)
       if opts[:sprited]
-        postprocess_css_sprited(opts)
+        ret = postprocess_css_sprited(opts)
       else
-        postprocess_css_dataurl(opts)
+        ret = postprocess_css_dataurl(opts)
       end
+      
+      ret = _strip_slice_class_names(ret)
+    end
+    
+    #
+    # Strips dummy slice class names that were added by Chance so that SCSS could do its magic,
+    # but which are no longer needed.
+    #
+    def _strip_slice_class_names(css)
+      css.gsub! /\.__chance_slice[^{]*?,/, ""
+      css
     end
 
 
     # 
     # COMBINING CSS
     #
+    
+    # Determines the "Chance Header" to add at the beginning of the file. The
+    # Chance Header can set, for instance, the $theme variable.
+    #
+    # The Chance Header is loaded from the nearest _theme.css file in this folder
+    # or a containing folder (the file list specifically ignores such files; they are
+    # only used for this purpose)
+    #
+    # For backwards-compatibility, the fallback if no _theme.css file is present
+    # is to return code setting $theme to the now-deprecated @options[:theme] 
+    # passed to Chance
+    def chance_header_for_file(file)
+      # 'file' is the name of a file, so we actually need to start at dirname(file)
+      dir = File.dirname(file)
+      
+      # This should not be slow, as this is just a hash lookup
+      while dir.length > 0 and not dir == "."
+        header_file = @mapped_files[File.join(dir, "_theme.css")]
+        if not header_file.nil?
+          return Chance.get_file(header_file)
+        end
+        
+        dir = File.dirname(dir)
+      end
+      
+      # Make sure to look globally
+      header_file = @mapped_files["_theme.css"]
+      return Chance.get_file(header_file) if not header_file.nil?
+      
+      {
+        # Never changes (without a restart, at least)
+        :mtime => 0,
+        :content => "$theme: '" + @options[:theme] + "';\n"
+      }
+    end
+    
     #
     # _include_file is the recursive method in the depth-first-search
     # that creates the ordered list of files.
@@ -262,6 +378,9 @@ module Chance
     #
     def _include_file(file)
       return if not file =~ /\.css$/
+      
+      # skip _theme.css files
+      return if file =~ /_theme\.css$/
 
       file = Chance.get_file(file)
 
@@ -271,7 +390,13 @@ module Chance
       requires = file[:requires]
       file[:included] = @@generation
 
-      requires.each {|r| _include_file(@mapped_files[r]) } unless requires.nil?
+      if not requires.nil?
+        requires.each {|r|
+          # Add the .css extension if needed. it is optional for sc_require
+          r = r + ".css" if not r =~ /\.css$/
+          _include_file(@mapped_files[r])
+        }
+      end
 
 
 
@@ -289,35 +414,55 @@ module Chance
       @@generation = @@generation + 1
       files = @mapped_files.values
       @file_list = []
-
-      files.each {|f| _include_file(f) }
+      
+      # We have to sort alphabetically first...
+      tmp_file_list = []
+      @mapped_files.each {|p, f| tmp_file_list.push([p, f]) }
+      tmp_file_list.sort_by! {|a| a[0] }
+
+      tmp_file_list.each {|paths|
+        p, f = paths
+        
+        # Save the mtime for caching
+        mtime = Chance.update_file_if_needed(f)
+        @file_mtimes[p] = mtime
+        
+        _include_file(f)
+      }
 
       relative_paths = @mapped_files.invert
 
       @file_list.map {|file|
-        # The parser accepts single files that contain many files. As such,
-        # 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.
+        # NOTE: WE MUST CALL CHANCE PARSER NOW, because it generates our slicses.
+        # We can't be picky and just call it if something has changed. Thankfully,
+        # parser is fast. Unlike SCSS.
+        header_file = chance_header_for_file(relative_paths[file[:path]])
+        
         content = "@_chance_file " + relative_paths[file[:path]] + ";\n"
-        content += "$theme: '" + @options[:theme] + "';"
+        content += header_file[:content]
         content += file[:content]
 
         parser = Chance::Parser.new(content, @options)
         parser.parse
         file[:parsed_css] = parser.css
+        
+        # We used to use an md5 hash here, but this hides the original file name
+        # from SCSS, which makes the file name + line number comments useless.
+        #
+        # Instead, we sanitize the path.
+        path_safe = file[:path].gsub(/[^a-zA-Z0-9\-_\\\/]/, '-')
 
-        # Remove any non-letter characters that could cause a problem in filenames,
-        # i.e. colons in drive names on Windows
-        # Also removing leading slashes
-        cleaned_path = file[:path].gsub(/[^\w\/_-]+/,'_').sub(/^\//,'')
-        tmp_path = "./tmp/chance/#{cleaned_path}.scss"
+        tmp_path = "./tmp/chance/#{path_safe}.scss"
 
         FileUtils.mkdir_p(File.dirname(tmp_path))
-
-        f = File.new(tmp_path, "w")
-        f.write(parser.css)
-        f.close
+        
+        if (not file[:mtime] or not file[:wtime] or file[:wtime] < file[:mtime] or
+            not header_file[:mtime] or file[:wtime] < header_file[:mtime])
+          f = File.new(tmp_path, "w")
+          f.write(parser.css)
+          f.close
+          file[:wtime] = Time.now.to_f
+        end
 
         css = "@import \"" + tmp_path + "\";"