compass-sass37 1.1.0

data/lib/compass/sass_extensions/sprites/sprite_map.rb

@@ -0,0 +1,93 @@
+module Compass
+  module SassExtensions
+    module Sprites
+      class SpriteMap < Sass::Script::Value::Base
+        attr_accessor :image_names, :path, :name, :map, :kwargs
+        attr_accessor :images, :width, :height, :engine
+
+        include SpriteMethods
+        include ImageMethods
+        include LayoutMethods
+        include Sass::Script::Value::Helpers
+
+
+        # Initialize a new sprite object from a relative file path
+        # the path is relative to the <tt>images_path</tt> confguration option
+        def self.from_uri(uri, context, kwargs)
+          uri = uri.value
+          path, name = Compass::SpriteImporter.path_and_name(uri)
+          files = Compass::SpriteImporter.files(uri)
+          sprites = files.map do |sprite|
+            relative_name(sprite)
+          end
+          new(sprites, path, name, context, kwargs)
+        end
+        
+        def self.relative_name(sprite)
+          sprite = File.expand_path(sprite)
+          Compass.configuration.sprite_load_path.each do |path|
+            path_with_slash = "#{File.expand_path(path)}/"
+            
+            if sprite.include?(path_with_slash)
+              return sprite.gsub(path_with_slash, '')
+            end
+          end
+        end
+
+        def initialize(sprites, path, name, context, kwargs)
+          @image_names = sprites
+          @path = path
+          @name = name
+          @kwargs = kwargs
+          @kwargs['cleanup'] ||= bool(true)
+          @kwargs['layout'] ||= identifier('vertical')
+          @kwargs['sort_by'] ||= identifier('none')
+          @images = nil
+          @width = nil
+          @height = nil
+          @engine = nil
+          @evaluation_context = context
+          compute_image_metadata!
+        end
+
+        def sort_method
+          @kwargs['sort_by'].value
+        end
+
+        def inspect
+          puts 'images'
+          @images.each do |img|
+            puts img.file
+          end
+          puts "options"
+          @kwargs.each do |k,v|
+            puts "#{k}:#{v}"
+          end
+        end
+
+        def to_s(kwargs = self.kwargs)
+          sprite_url(self).value
+        end
+
+        def respond_to?(meth)
+          super || @evaluation_context.respond_to?(meth)
+        end
+
+        def method_missing(meth, *args, &block)
+          if @evaluation_context.respond_to?(meth)
+            @evaluation_context.send(meth, *args, &block)
+          else
+            super
+          end
+        end
+
+        private 
+
+        def modulize
+          @modulize ||= Compass::configuration.sprite_engine.to_s.scan(/([^_.]+)/).flatten.map {|chunk| "#{chunk[0].chr.upcase}#{chunk[1..-1]}" }.join
+        end
+
+      end
+    end
+  end
+end

data/lib/compass/sass_extensions/sprites/sprite_methods.rb

@@ -0,0 +1,136 @@
+module Compass
+  module SassExtensions
+    module Sprites
+      module SpriteMethods
+        
+        # Changing this string will invalidate all previously generated sprite images.
+        # We should do so only when the packing algorithm changes
+        SPRITE_VERSION = "2"
+        
+        # Calculates the overal image dimensions
+        # collects image sizes and input parameters for each sprite
+        # Calculates the height
+        def compute_image_metadata!
+          @width = 0
+          init_images
+          compute_image_positions!
+          init_engine
+        end
+        
+        def init_engine
+          @engine = eval("::Compass::SassExtensions::Sprites::#{modulize}Engine.new(nil, nil, nil)")
+          @engine.width = @width
+          @engine.height = @height
+          @engine.images = @images
+        end
+        
+        # Creates the Sprite::Image objects for each image and calculates the width
+        def init_images
+          @images = Images.new
+          image_names.each do |relative_file|
+            @images << Image.new(self, relative_file, kwargs)
+          end
+          unless sort_method == 'none'
+            @images.sort_by! sort_method
+          end
+        end
+
+        def name_and_hash
+          "#{path}-s#{uniqueness_hash}.png"
+        end
+
+        # The on-the-disk filename of the sprite
+        def filename
+          File.join(Compass.configuration.generated_images_path, name_and_hash)
+        end
+
+        def relativize(path)
+          Pathname.new(path).relative_path_from(Pathname.new(Dir.pwd)).to_s rescue path
+        end
+
+        # Generate a sprite image if necessary
+        def generate
+          if generation_required?
+            if kwargs.get_var('cleanup').value
+              cleanup_old_sprites
+            end
+            engine.construct_sprite
+            Compass.configuration.run_sprite_generated(engine.canvas)
+            save!
+          else
+            log :unchanged, filename
+          end
+        end
+        
+        def cleanup_old_sprites
+          Sass::Util.glob(File.join(Compass.configuration.generated_images_path, "#{path}-s*.png")).each do |file|
+            log :remove, file
+            FileUtils.rm file
+            Compass.configuration.run_sprite_removed(file)
+          end
+        end
+        
+        # Does this sprite need to be generated
+        def generation_required?
+          !File.exist?(filename) || outdated? || options[:force]
+        end
+
+        # Returns the uniqueness hash for this sprite object
+        def uniqueness_hash
+          @uniqueness_hash ||= begin
+            sum = Digest::MD5.new
+            sum << SPRITE_VERSION
+            sum << path
+            sum << layout
+            images.each do |image|
+              [:relative_file, :height, :width, :repeat, :spacing, :position, :digest].each do |attr|
+                sum << image.send(attr).to_s
+              end
+            end
+            sum.hexdigest[0...10]
+          end
+          @uniqueness_hash
+        end
+
+        # Saves the sprite engine
+        def save!
+          FileUtils.mkdir_p(File.dirname(filename))
+          saved = engine.save(filename)
+          log :create, filename
+          Compass.configuration.run_sprite_saved(filename)
+          @mtime = nil if saved
+          saved
+        end
+
+        # All the full-path filenames involved in this sprite
+        def image_filenames
+          @images.map(&:file)
+        end
+
+        # Checks whether this sprite is outdated
+        def outdated?
+          if File.exist?(filename)
+            return @images.any? {|image| image.mtime.to_i > self.mtime.to_i }
+          end
+          true
+        end
+
+        # Mtime of the sprite file
+        def mtime
+          @mtime ||= File.mtime(filename)
+        end
+        
+       # Calculate the size of the sprite
+        def size
+          [width, height]
+        end
+
+        def log(action, filename, *extra)
+          if options[:compass] && options[:compass][:logger] && !options[:quiet]
+            options[:compass][:logger].record(action, relativize(filename), *extra)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/compass/sass_extensions/sprites.rb

@@ -0,0 +1,21 @@
+require 'digest/md5'
+require 'compass/sprite_importer'
+
+module Compass
+  module SassExtensions
+    module Sprites
+    end
+  end
+end
+
+require 'compass/sass_extensions/sprites/images'
+require 'compass/sass_extensions/sprites/layout'
+require 'compass/sass_extensions/sprites/image_row'
+require 'compass/sass_extensions/sprites/row_fitter'
+require 'compass/sass_extensions/sprites/image'
+require 'compass/sass_extensions/sprites/layout_methods'
+require 'compass/sass_extensions/sprites/sprite_methods'
+require 'compass/sass_extensions/sprites/image_methods'
+require 'compass/sass_extensions/sprites/sprite_map'
+require 'compass/sass_extensions/sprites/engines'
+

data/lib/compass/sass_extensions.rb

@@ -0,0 +1,9 @@
+unless Sass::Script::Functions.methods.grep(/\Adeclare\Z/).any?
+  raise LoadError, "It looks like you've got an incompatible version of Sass. This often happens when you have an old haml gem installed. Please upgrade Haml to v3.1 or above."
+end
+
+module Compass::SassExtensions
+end
+
+require 'compass/sass_extensions/functions'
+require 'compass/sass_extensions/sprites'

data/lib/compass/sprite_importer/binding.rb

@@ -0,0 +1,11 @@
+require 'ostruct'
+module Compass
+  module Sprites
+    class Binding < OpenStruct
+      
+      def get_binding
+        binding
+      end
+    end
+  end
+end

data/lib/compass/sprite_importer/content.erb

@@ -0,0 +1,87 @@
+@import "compass/utilities/sprites/base";
+
+// General Sprite Defaults
+// You can override them before you import this file.
+$<%= name %>-sprite-dimensions : false !default;
+$<%= name %>-use-percentages   : false !default;
+$<%= name %>-position          : 0% !default;
+$<%= name %>-spacing           : 0 !default;
+$<%= name %>-repeat            : no-repeat !default;
+$<%= name %>-prefix            : '' !default;
+$<%= name %>-clean-up          : true !default;
+$<%= name %>-layout            : vertical !default;
+$<%= name %>-inline            : false !default;
+$<%= name %>-sort-by           : 'none' !default;
+$<%= name %>-class-separator   : $default-sprite-separator !default;
+$<%= name %>-sprite-base-class : ".<%= name %>#{$<%= name %>-class-separator}sprite" !default;
+
+<% if skip_overrides %> 
+  $<%= name %>-sprites: sprite-map("<%= uri %>", $layout: $<%= name %>-layout, $cleanup: $<%= name %>-clean-up, $spacing: $<%= name %>-spacing, $position : $<%= name %>-position);
+<% else %>  
+ // These variables control the generated sprite output
+ // You can override them selectively before you import this file.
+ <% sprite_names.each do |sprite_name| %>
+   $<%= name %>-<%= sprite_name %>-position: $<%= name %>-position !default;
+   $<%= name %>-<%= sprite_name %>-spacing:  $<%= name %>-spacing !default;
+   $<%= name %>-<%= sprite_name %>-repeat:   $<%= name %>-repeat !default;
+ <% end %>
+
+ $<%= name %>-sprites: sprite-map("<%= uri %>",
+ <% sprite_names.each do |sprite_name| %>
+   $<%= name %>-<%= sprite_name %>-position: $<%= name %>-<%= sprite_name %>-position, 
+   $<%= name %>-<%= sprite_name %>-spacing:  $<%= name %>-<%= sprite_name %>-spacing, 
+   $<%= name %>-<%= sprite_name %>-repeat:   $<%= name %>-<%= sprite_name %>-repeat,
+ <% end %>
+ $layout   : $<%= name %>-layout,
+ $cleanup  : $<%= name %>-clean-up,
+ $spacing  : $<%= name %>-spacing,
+ $position : $<%= name %>-position,
+ $sort-by  : $<%= name %>-sort-by
+ );
+<% end %>
+
+// All sprites should extend this class
+// The <%= name %>-sprite mixin will do so for you.
+@if $<%= name %>-inline {
+  #{$<%= name %>-sprite-base-class} {
+    background-image: inline-sprite($<%= name %>-sprites);
+  } 
+} @else {
+  #{$<%= name %>-sprite-base-class} {
+    background-image: sprite-url($<%= name %>-sprites);
+    background-repeat: no-repeat;
+  }
+}
+//sass functions to return the dimensions of a sprite image as units
+<% [:width, :height].each do |dimension| %>
+  @function <%= name %>-sprite-<%= dimension %>($name) {
+    @return sprite-<%= dimension %>($<%= name %>-sprites, $name);
+  }
+<% end %>
+
+// Use this to set the dimensions of an element
+// based on the size of the original image.
+@mixin <%= name %>-sprite-dimensions($name) {
+  @include sprite-dimensions($<%= name %>-sprites, $name)
+}
+
+// Move the background position to display the sprite.
+@mixin <%= name %>-sprite-position($name, $offset-x: 0, $offset-y: 0, $use-percentages: $<%= name %>-use-percentages) {
+  @include sprite-background-position($<%= name %>-sprites, $name, $offset-x, $offset-y, $use-percentages)
+}
+
+// Extends the sprite base class and set the background position for the desired sprite.
+// It will also apply the image dimensions if $dimensions is true.
+@mixin <%= name %>-sprite($name, $dimensions: $<%= name %>-sprite-dimensions, $offset-x: 0, $offset-y: 0, $use-percentages: $<%= name %>-use-percentages, $separator: $<%= name %>-class-separator) {
+  @extend #{$<%= name %>-sprite-base-class};
+  @include sprite($<%= name %>-sprites, $name, $dimensions, $offset-x, $offset-y, $use-percentages, $separator: $separator);
+}
+
+@mixin <%= name %>-sprites($sprite-names, $dimensions: $<%= name %>-sprite-dimensions, $prefix: sprite-map-name($<%= name %>-sprites), $offset-x: 0, $offset-y: 0, $use-percentages: $<%= name %>-use-percentages, $separator: $<%= name %>-class-separator) {
+  @include sprites($<%= name %>-sprites, $sprite-names, $<%= name %>-sprite-base-class, $dimensions, $prefix, $offset-x, $offset-y, $use-percentages, $separator: $separator)
+}
+
+// Generates a class for each sprited image.
+@mixin all-<%= name %>-sprites($dimensions: $<%= name %>-sprite-dimensions, $prefix: sprite-map-name($<%= name %>-sprites), $offset-x: 0, $offset-y: 0, $use-percentages: $<%= name %>-use-percentages, $separator: $<%= name %>-class-separator) {
+  @include <%= name %>-sprites(<%= sprite_names.join(" ") %>, $dimensions, $prefix, $offset-x, $offset-y, $use-percentages, $separator: $separator);
+}

data/lib/compass/sprite_importer.rb

@@ -0,0 +1,117 @@
+require 'erb'
+require 'compass/sprite_importer/binding'
+module Compass
+  class SpriteImporter < Sass::Importers::Base
+    VAILD_FILE_NAME       = /\A#{Sass::SCSS::RX::IDENT}\Z/
+    SPRITE_IMPORTER_REGEX = %r{((.+/)?([^\*.]+))/(.+?)\.png}
+    VALID_EXTENSIONS      = ['.png']
+    
+    TEMPLATE_FOLDER       = File.join(File.expand_path('../', __FILE__), 'sprite_importer')
+    CONTENT_TEMPLATE_FILE = File.join(TEMPLATE_FOLDER, 'content.erb')
+    CONTENT_TEMPLATE      = ERB.new(File.read(CONTENT_TEMPLATE_FILE))
+
+
+
+    # finds all sprite files
+    def self.find_all_sprite_map_files(path)
+      hex = "[0-9a-f]"
+      glob = "*-s#{hex*10}{#{VALID_EXTENSIONS.join(",")}}"
+      Sass::Util.glob(File.join(path, "**", glob))
+    end
+    
+    def find(uri, options)
+      if uri =~ SPRITE_IMPORTER_REGEX
+        return self.class.sass_engine(uri, self.class.sprite_name(uri), self, options)
+      end
+      nil
+    end
+    
+    def find_relative(uri, base, options)
+      nil
+    end
+    
+    def to_s
+      self.class.name
+    end
+    
+    def hash
+      self.class.name.hash
+    end
+	
+    def eql?(other)
+      other.class == self.class
+    end
+    
+    def mtime(uri, options)
+      self.class.files(uri).sort.inject(Time.at(0)) do |max_time, file|
+        (t = File.mtime(file)) > max_time ? t : max_time
+      end
+    end
+    
+    def key(uri, options={})
+      [self.class.name + ":sprite:" + File.dirname(File.expand_path(uri)), File.basename(uri)]
+    end
+
+    def public_url(*args)
+      nil
+    end
+
+    
+    def self.path_and_name(uri)
+      if uri =~ SPRITE_IMPORTER_REGEX
+        [$1, $3]
+      else
+        raise Compass::Error, "invalid sprite path"
+      end
+    end
+
+    # Name of this spite
+    def self.sprite_name(uri)
+      _, name = path_and_name(uri)
+      name
+    end
+
+    # The on-disk location of this sprite
+    def self.path(uri)
+      path, _ = path_and_name(uri)
+      path
+    end
+    
+    # Returns the Glob of image files for the uri
+    def self.files(uri)
+      Compass.configuration.sprite_load_path.compact.each do |folder|
+        files = Sass::Util.glob(File.join(folder, uri)).sort
+        next if files.empty?
+        return files
+      end
+
+      path = Compass.configuration.sprite_load_path.to_a.join(', ')
+      raise Compass::SpriteException, %Q{No files were found in the load path matching "#{uri}". Your current load paths are: #{path}}
+    end
+
+    # Returns an Array of image names without the file extension
+    def self.sprite_names(uri)
+      files(uri).collect do |file|
+        File.basename(file, '.png')
+      end
+    end
+    
+    # Returns the sass_options for this sprite
+    def self.sass_options(uri, importer, options)
+      options.merge!(:filename => uri.gsub(%r{\*/},"*\\/"), :syntax => :scss, :importer => importer)
+    end
+    
+    # Returns a Sass::Engine for this sprite object
+    def self.sass_engine(uri, name, importer, options)
+      content = content_for_images(uri, name, options[:skip_overrides])
+      Sass::Engine.new(content, sass_options(uri, importer, options))
+    end
+
+    # Generates the Sass for this sprite file
+    def self.content_for_images(uri, name, skip_overrides = false)
+      binder = Compass::Sprites::Binding.new(:name => name, :uri => uri, :skip_overrides => skip_overrides, :sprite_names => sprite_names(uri), :files => files(uri))
+      CONTENT_TEMPLATE.result(binder.get_binding)
+    end
+  end
+end
+

data/lib/compass/stats.rb

@@ -0,0 +1,99 @@
+module Compass
+  module Stats
+    class StatsVisitor
+      attr_accessor :rule_count, :prop_count, :mixin_def_count, :mixin_count
+      def initialize
+        self.rule_count = 0
+        self.prop_count = 0
+        self.mixin_def_count = 0
+        self.mixin_count = 0
+      end
+      def visit(node)
+        self.prop_count += 1 if node.is_a?(Sass::Tree::PropNode) && !node.children.any?
+        if node.is_a?(Sass::Tree::RuleNode)
+          self.rule_count += node.rule.reject{|r| r.is_a?(Sass::Script::Tree::Node)}.map{|r| r.split(/,/)}.flatten.compact.size
+        end
+        self.mixin_def_count += 1 if node.is_a?(Sass::Tree::MixinDefNode)
+        self.mixin_count += 1 if node.is_a?(Sass::Tree::MixinNode)
+      end
+      def up(node)
+      end
+      def down(node)
+      end
+      def import?(node)
+        return false
+        full_filename = node.send(:import)
+        full_filename != Compass.deprojectize(full_filename)
+      end
+    end
+    class CssFile
+      attr_accessor :path, :css
+      attr_accessor :selector_count, :prop_count
+      attr_accessor :file_size
+      def initialize(path)
+        require 'css_parser'
+        self.path = path
+        self.css = CssParser::Parser.new
+        self.css.add_block!(contents)
+        self.selector_count = 0
+        self.prop_count = 0
+      end
+      def contents
+        @contents ||= File.read(path)
+      end
+      def lines
+        contents.inject(0){|m,c| m + 1 }
+      end
+      def analyze!
+        self.file_size = File.size(path)
+        css.each_selector do |selector, declarations, specificity|
+          sels = selector.split(/,/).size
+          props = declarations.split(/;/).size
+          self.selector_count += sels
+          self.prop_count += props
+        end
+      end
+    end
+    class SassFile
+      attr_accessor :path
+      attr_reader :visitor
+      attr_accessor :file_size
+
+      def initialize(path)
+        self.path = path
+      end
+      def contents
+        @contents ||= File.read(path)
+      end
+      def tree
+        opts = Compass.configuration.to_sass_engine_options
+        opts[:syntax] = path[-4..-1].to_sym
+        @tree = Sass::Engine.new(contents, opts).to_tree
+      end
+      def visit_tree!
+        @visitor = StatsVisitor.new
+        tree.visit_depth_first(@visitor)
+        @visitor
+      end
+      def analyze!
+        self.file_size = File.size(path)
+        visit_tree!
+      end
+      def lines
+        contents.inject(0){|m,c| m + 1 }
+      end
+      def rule_count
+        visitor.rule_count
+      end
+      def prop_count
+        visitor.prop_count
+      end
+      def mixin_def_count
+        visitor.mixin_def_count
+      end
+      def mixin_count
+        visitor.mixin_count
+      end
+    end
+  end
+end

data/lib/compass/test_case.rb

@@ -0,0 +1,38 @@
+module Compass
+  # Write your unit test like this if you want to make sure all your stylesheets compile.
+  #
+  # require 'compass/test_case'
+  # class StylesheetsTest < Compass::TestCase
+  #   def test_stylesheets
+  #     my_sass_files.each do |sass_file|
+  #       assert_compiles(sass_file) do |result|
+  #         assert_not_blank result
+  #       end
+  #     end
+  #   end
+  #   protected
+  #   def my_sass_files
+  #     Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), "../..", "app/stylesheets/**/[^_]*.sass")))
+  #   end
+  # end
+  class TestCase < (defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase)
+
+    def setup
+      super
+      @last_compile = nil
+    end
+
+    def compile(stylesheet)
+      input =  open(stylesheet)
+      template = input.read()
+      input.close()
+      @last_compile = ::Sass::Engine.new(template, ::Sass::Plugin.engine_options(:filename => stylesheet)).render
+      yield @last_compile if block_given?
+    end
+
+    def assert_compiles(stylesheet, &block)
+      compile(stylesheet, &block)
+    end
+
+  end
+end

data/lib/compass/validator.rb

@@ -0,0 +1,16 @@
+begin
+  require 'rubygems'
+  require 'compass-validator'
+rescue LoadError => e
+  if e.message =~ /core_ext/
+    raise Compass::MissingDependency, <<-ERRORMSG
+The Compass CSS Validator is out of date. Please upgrade it:
+sudo gem install compass-validator --version ">= 3.0.1"
+ERRORMSG
+  else
+    raise Compass::MissingDependency, <<-ERRORMSG
+The Compass CSS Validator could not be loaded. Please install it:
+sudo gem install compass-validator
+ERRORMSG
+  end
+end

data/lib/compass/version.rb

@@ -0,0 +1,42 @@
+require 'compass/generated_version'
+module Compass
+  module Version
+    def scope(file) # :nodoc:
+      File.join(File.dirname(__FILE__), '..', '..', file)
+    end
+
+    def parse_version(version, name)
+      nil_or_int = lambda{|i| i.nil? ? nil : i.to_i}
+      segments = version.split(".")
+      {
+        :string => version,
+        :name => name,
+        :major => nil_or_int.call(segments.shift),
+        :minor => nil_or_int.call(segments.shift),
+        :patch => nil_or_int.call(segments.shift),
+        :state => segments.shift,
+        :iteration => nil_or_int.call(segments.shift)
+      }
+    end
+
+    # Returns a hash representing the version.
+    # The :major, :minor, and :teeny keys have their respective numbers.
+    # The :string key contains a human-readable string representation of the version.
+    # The :rev key will have the current revision hash.
+    #
+    # This method swiped from Haml and then modified, some credit goes to Nathan Weizenbaum
+    def version
+      Compass::VERSION_DETAILS
+    end
+  end
+
+  extend Compass::Version
+
+  unless defined?(::Compass::VERSION)
+    VERSION = File.read(scope("VERSION")).strip 
+    VERSION_NAME = File.read(scope("VERSION_NAME")).strip
+  end
+
+  VERSION_DETAILS = parse_version(VERSION, VERSION_NAME)
+
+end