haml 3.0.0.beta.1 → 3.0.0.beta.2

data/lib/sass/environment.rb

@@ -23,7 +23,7 @@ module Sass
       @vars = {}
       @mixins = {}
       @parent = parent
-
+      @stack = [] unless parent
       set_var("important", Script::String.new("!important")) unless @parent
     end
 
@@ -35,6 +35,52 @@ module Sass
       @options || (parent && parent.options) || {}
     end
 
+    # Push a new stack frame onto the mixin/include stack.
+    #
+    # @param frame_info [{Symbol => Object}]
+    #   Frame information has the following keys:
+    #
+    #   `:filename`
+    #   : The name of the file in which the lexical scope changed.
+    #
+    #   `:mixin`
+    #   : The name of the mixin in which the lexical scope changed,
+    #     or `nil` if it wasn't within in a mixin.
+    #
+    #   `:line`
+    #   : The line of the file on which the lexical scope changed. Never nil.
+    def push_frame(frame_info)
+      if stack.last && stack.last[:prepared]
+        stack.last.delete(:prepared)
+        stack.last.merge!(frame_info)
+      else
+        stack.push(frame_info)
+      end
+    end
+
+    # Like \{#push\_frame}, but next time a stack frame is pushed,
+    # it will be merged with this frame.
+    #
+    # @param frame_info [{Symbol => Object}] Same as for \{#push\_frame}.
+    def prepare_frame(frame_info)
+      push_frame(frame_info.merge(:prepared => true))
+    end
+
+    # Pop a stack frame from the mixin/include stack.
+    def pop_frame
+      stack.pop if stack.last[:prepared]
+      stack.pop
+    end
+
+    # A list of stack frames in the mixin/include stack.
+    # The last element in the list is the most deeply-nested frame.
+    #
+    # @return [Array<{Symbol => Object}>] The stack frames,
+    #   of the form passed to \{#push\_frame}.
+    def stack
+      @stack ||= @parent.stack
+    end
+
     class << self
       private
 

data/lib/sass/files.rb

@@ -76,8 +76,11 @@ module Sass
         return filename
       end
 
-      new_filename   = find_full_path("#{filename}.sass", load_paths) unless was_scss
-      new_filename ||= find_full_path("#{filename}.scss", load_paths) unless was_sass
+      new_filename = nil
+      load_paths.each do |load_path|
+        new_filename ||= find_full_path("#{filename}.sass", load_path) unless was_scss
+        new_filename ||= find_full_path("#{filename}.scss", load_path) unless was_sass
+      end
 
       return new_filename if new_filename
       unless was_sass || was_scss
@@ -134,7 +137,7 @@ END
       end
     end
 
-    def find_full_path(filename, load_paths)
+    def find_full_path(filename, load_path)
       partial_name = File.join(File.dirname(filename), "_#{File.basename(filename)}")
 
       if Pathname.new(filename).absolute?
@@ -144,13 +147,9 @@ END
         return nil
       end
 
-      load_paths.each do |path|
-        [partial_name, filename].each do |name|
-          full_path = File.join(path, name)
-          if File.readable?(full_path)
-            return full_path
-          end
-        end
+      [partial_name, filename].each do |name|
+        full_path = File.join(load_path, name)
+        return full_path if File.readable?(full_path)
       end
       nil
     end

data/lib/sass/plugin.rb

@@ -3,6 +3,7 @@ require 'rbconfig'
 
 require 'sass'
 require 'sass/callbacks'
+require 'sass/plugin/staleness_checker'
 
 module Sass
   # This module handles the compilation of Sass/SCSS files.
@@ -211,6 +212,8 @@ module Sass
       individual_files.each {|t, c| update_stylesheet(t, c)}
 
       @checked_for_updates = true
+      staleness_checker = StalenessChecker.new
+
       template_locations.zip(css_locations).each do |template_location, css_location|
 
         Dir.glob(File.join(template_location, "**", "*.s[ca]ss")).each do |file|
@@ -219,7 +222,7 @@ module Sass
           css = css_filename(name, css_location)
 
           next if forbid_update?(name)
-          if options[:always_update] || stylesheet_needs_update?(css, file)
+          if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
             update_stylesheet file, css
           else
             run_not_updating_stylesheet file, css
@@ -374,33 +377,9 @@ module Sass
       name.sub(/^.*\//, '')[0] == ?_
     end
 
+    # Compass expects this to exist
     def stylesheet_needs_update?(css_file, template_file)
-      return true unless File.exists?(css_file) && File.exists?(template_file)
-
-      css_mtime = File.mtime(css_file)
-      File.mtime(template_file) > css_mtime ||
-        dependencies(template_file).any?(&dependency_updated?(css_mtime))
-    end
-
-    def dependency_updated?(css_mtime)
-      lambda do |dep|
-        begin
-          File.mtime(dep) > css_mtime ||
-            dependencies(dep).any?(&dependency_updated?(css_mtime))
-        rescue Sass::SyntaxError
-          # If there's an error finding depenencies, default to recompiling.
-          true
-        end
-      end
-    end
-
-    def dependencies(filename)
-      Files.tree_for(filename, engine_options).select {|n| n.is_a?(Tree::ImportNode)}.map do |n|
-        next if n.full_filename =~ /\.css$/
-        n.full_filename
-      end.compact
-    rescue Sass::SyntaxError => e
-      [] # If the file has an error, we assume it has no dependencies
+      StalenessChecker.stylesheet_needs_update?(css_file, template_file)
     end
   end
 end

data/lib/sass/plugin/merb.rb

@@ -14,6 +14,7 @@ unless defined?(Sass::MERB_LOADED)
                               :css_location      => root + '/public/stylesheets',
                               :cache_location    => root + '/tmp/sass-cache',
                               :always_check      => env != "production",
+                              :quiet             => env != "production",
                               :full_exception    => env != "production")
   config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
 

data/lib/sass/plugin/rails.rb

@@ -5,6 +5,7 @@ unless defined?(Sass::RAILS_LOADED)
                               :css_location      => Haml::Util.rails_root + '/public/stylesheets',
                               :cache_location    => Haml::Util.rails_root + '/tmp/sass-cache',
                               :always_check      => Haml::Util.rails_env != "production",
+                              :quiet             => Haml::Util.rails_env != "production",
                               :full_exception    => Haml::Util.rails_env != "production")
 
   if defined?(Rails.configuration) && defined?(Rails.configuration.middleware)

data/lib/sass/plugin/staleness_checker.rb

@@ -0,0 +1,123 @@
+module Sass
+  module Plugin
+    # The class handles `.s[ca]ss` file staleness checks via their mtime timestamps.
+    #
+    # To speed things up two level of caches are employed:
+    #
+    # * A class-level dependency cache which stores @import paths for each file.
+    #   This is a long-lived cache that is reused by every StalenessChecker instance.
+    # * Two short-lived instance-level caches, one for file mtimes
+    #   and one for whether a file is stale during this particular run.
+    #   These are only used by a single StalenessChecker instance.
+    #
+    # Usage:
+    #
+    # * For a one-off staleness check of a single `.s[ca]ss` file,
+    #   the class-level {stylesheet_needs_update?} method
+    #   should be used.
+    # * For a series of staleness checks (e.g. checking all files for staleness)
+    #   a StalenessChecker instance should be created,
+    #   and the instance-level \{#stylesheet\_needs\_update?} method should be used.
+    #   the caches should make the whole process significantly faster.
+    #   *WARNING*: It is important not to retain the instance for too long,
+    #   as its instance-level caches are never explicitly expired.
+    class StalenessChecker
+      @dependencies_cache = {}
+
+      class << self
+        # @private
+        attr_accessor :dependencies_cache
+      end
+
+      # Creates a new StalenessChecker
+      # for checking the staleness of several stylesheets at once.
+      def initialize
+        @dependencies = self.class.dependencies_cache
+
+        # Entries in the following instance-level caches are never explicitly expired.
+        # Instead they are supposed to automaticaly go out of scope when a series of staleness checks
+        # (this instance of StalenessChecker was created for) is finished.
+        @mtimes, @dependencies_stale = {}, {}
+      end
+
+      # Returns whether or not a given CSS file is out of date
+      # and needs to be regenerated.
+      #
+      # @param css_file [String] The location of the CSS file to check.
+      # @param template_file [String] The location of the Sass or SCSS template
+      #   that is compiled to `css_file`.
+      def stylesheet_needs_update?(css_file, template_file)
+        template_file = File.expand_path(template_file)
+
+        unless File.exists?(css_file) && File.exists?(template_file)
+          @dependencies.delete(template_file)
+          true
+        else
+          css_mtime = mtime(css_file)
+          mtime(template_file) > css_mtime || dependencies_stale?(template_file, css_mtime)
+        end
+      end
+
+      # Returns whether or not a given CSS file is out of date
+      # and needs to be regenerated.
+      #
+      # The distinction between this method and the instance-level \{#stylesheet\_needs\_update?}
+      # is that the instance method preserves mtime and stale-dependency caches,
+      # so it's better to use when checking multiple stylesheets at once.
+      #
+      # @param css_file [String] The location of the CSS file to check.
+      # @param template_file [String] The location of the Sass or SCSS template
+      #   that is compiled to `css_file`.
+      def self.stylesheet_needs_update?(css_file, template_file)
+        new.stylesheet_needs_update?(css_file, template_file)
+      end
+
+      private
+
+      def dependencies_stale?(template_file, css_mtime)
+        timestamps = @dependencies_stale[template_file] ||= {}
+        timestamps.each_pair do |checked_css_mtime, is_stale|
+          if checked_css_mtime <= css_mtime && !is_stale
+            return false
+          elsif checked_css_mtime > css_mtime && is_stale
+            return true
+          end
+        end
+        timestamps[css_mtime] = dependencies(template_file).any?(&dependency_updated?(css_mtime))
+      end
+
+      def mtime(filename)
+        @mtimes[filename] ||= File.mtime(filename)
+      end
+
+      def dependencies(filename)
+        stored_mtime, dependencies = @dependencies[filename]
+
+        if !stored_mtime || stored_mtime < mtime(filename)
+          @dependencies[filename] = [mtime(filename), dependencies = compute_dependencies(filename)]
+        end
+
+        dependencies
+      end
+
+      def dependency_updated?(css_mtime)
+        lambda do |dep|
+          begin
+            mtime(dep) > css_mtime || dependencies_stale?(dep, css_mtime)
+          rescue Sass::SyntaxError
+            # If there's an error finding depenencies, default to recompiling.
+            true
+          end
+        end
+      end
+
+      def compute_dependencies(filename)
+        Files.tree_for(filename, Plugin.engine_options).grep(Tree::ImportNode) do |n|
+          File.expand_path(n.full_filename) unless n.full_filename =~ /\.css$/
+        end.compact
+      rescue Sass::SyntaxError => e
+        [] # If the file has an error, we assume it has no dependencies
+      end
+    end
+  end
+end

data/lib/sass/script/bool.rb

@@ -10,7 +10,7 @@ module Sass::Script
     alias_method :to_bool, :value
 
     # @return [String] "true" or "false"
-    def to_s
+    def to_s(opts = {})
       @value.to_s
     end
     alias_method :to_sass, :to_s

data/lib/sass/script/color.rb

@@ -375,7 +375,7 @@ END
     # but if the color has a name that's used instead.
     #
     # @return [String] The string representation
-    def to_s
+    def to_s(opts = {})
       return rgba_str if alpha?
       return smallest if options[:style] == :compressed
       return HTML4_COLORS_REVERSE[rgb] if HTML4_COLORS_REVERSE[rgb]

data/lib/sass/script/css_lexer.rb

@@ -7,10 +7,7 @@ module Sass
 
       def string(*args)
         return unless scan(STRING)
-        str = (@scanner[1] || @scanner[2]).
-          gsub(/\\([^0-9a-f])/, '\1').
-          gsub(/\\([0-9a-f]{1,4})/, "\\\\\\1")
-        [:string, Script::String.new(str, :string)]
+        [:string, Script::String.new((@scanner[1] || @scanner[2]).gsub(/\\(['"])/, '\1'), :string)]
       end
 
       def important

data/lib/sass/script/funcall.rb

@@ -31,8 +31,8 @@ module Sass
       end
 
       # @see Node#to_sass
-      def to_sass
-        "#{name}(#{args.map {|a| a.to_sass}.join(', ')})"
+      def to_sass(opts = {})
+        "#{dasherize(name, opts)}(#{args.map {|a| a.to_sass(opts)}.join(', ')})"
       end
 
       # Returns the arguments to the function.

data/lib/sass/script/functions.rb

@@ -105,6 +105,20 @@ module Sass::Script
   # \{#abs}
   # : Returns the absolute value of a number.
   #
+  # ## Introspection Functions
+  #
+  # \{#type_of}
+  # : Returns the type of a value.
+  #
+  # \{#unit}
+  # : Returns the units associated with a number.
+  #
+  # \{#unitless}
+  # : Returns whether a number has units or not.
+  #
+  # \{#comparable}
+  # : Returns whether two numbers can be added or compared.
+  #
   # These functions are described in more detail below.
   #
   # ## Adding Custom Functions
@@ -388,17 +402,38 @@ module Sass::Script
       Sass::Script::Number.new(color.lightness, ["%"])
     end
 
+    # Returns the alpha component (opacity) of a color.
+    # This is 1 unless otherwise specified.
+    #
+    # This function also supports the proprietary Microsoft
+    # `alpha(opacity=20)` syntax.
+    #
+    # @overload def alpha(color)
+    # @param color [Color]
+    # @return [Number]
+    # @raise [ArgumentError] If `color` isn't a color
+    def alpha(*args)
+      if args.all? do |a|
+          a.is_a?(Sass::Script::String) && a.type == :identifier &&
+            a.value =~ /^[a-zA-Z]+\s*=/
+        end
+        # Support the proprietary MS alpha() function
+        return Sass::Script::String.new("alpha(#{args.map {|a| a.to_s}.join(", ")})")
+      end
+
+      opacity(*args)
+    end
+
     # Returns the alpha component (opacity) of a color.
     # This is 1 unless otherwise specified.
     #
     # @param color [Color]
     # @return [Number]
     # @raise [ArgumentError] If `color` isn't a color
-    def alpha(color)
+    def opacity(color)
       assert_type color, :Color
       Sass::Script::Number.new(color.alpha)
     end
-    alias_method :opacity, :alpha
 
     # Makes a color more opaque.
     # Takes a color and an amount between 0 and 1,
@@ -648,6 +683,71 @@ module Sass::Script
       Sass::Script::String.new(str.value, :string)
     end
 
+    # Inspects the type of the argument, returning it as an unquoted string.
+    # For example:
+    #
+    #     type-of(100px)  => number
+    #     type-of(asdf)   => string
+    #     type-of("asdf") => string
+    #     type-of(true)   => bool
+    #     type-of(#fff)   => color
+    #     type-of(blue)   => color
+    #
+    # @param obj [Literal] The object to inspect
+    # @return [String] The unquoted string name of the literal's type
+    def type_of(obj)
+      Sass::Script::String.new(obj.class.name.gsub(/Sass::Script::/,'').downcase)
+    end
+
+    # Inspects the unit of the number, returning it as a quoted string.
+    # Complex units are sorted in alphabetical order by numerator and denominator.
+    # For example:
+    #
+    #     unit(100) => ""
+    #     unit(100px) => "px"
+    #     unit(3em) => "em"
+    #     unit(10px * 5em) => "em*px"
+    #     unit(10px * 5em / 30cm / 1rem) => "em*px/cm*rem"
+    #
+    # @param number [Literal] The number to inspect
+    # @return [String] The unit(s) of the number
+    # @raise [ArgumentError] if `number` isn't a number
+    def unit(number)
+      assert_type number, :Number
+      Sass::Script::String.new(number.unit_str, :string)
+    end
+
+    # Inspects the unit of the number, returning a boolean indicating if it is unitless.
+    # For example:
+    #
+    #     unitless(100) => true
+    #     unitless(100px) => false
+    #
+    # @param number [Literal] The number to inspect
+    # @return [Bool] Whether or not the number is unitless
+    # @raise [ArgumentError] if `number` isn't a number
+    def unitless(number)
+      assert_type number, :Number
+      Sass::Script::Bool.new(number.unitless?)
+    end
+
+    # Returns true if two numbers are similar enough to be added, subtracted, or compared.
+    # For example:
+    #
+    #     comparable(2px, 1px) => true
+    #     comparable(100px, 3em) => false
+    #     comparable(10cm, 3mm) => true
+    #
+    # @param number1 [Number]
+    # @param number2 [Number]
+    # @return [Bool] indicating if the numbers can be compared.
+    # @raise [ArgumentError] if `number1` or `number2` aren't numbers
+    def comparable(number1, number2)
+      assert_type number1, :Number
+      assert_type number2, :Number
+      Sass::Script::Bool.new(number1.comparable_to?(number2))
+    end
+
     # Converts a decimal number to a percentage.
     # For example:
     #
@@ -715,11 +815,6 @@ module Sass::Script
       numeric_transformation(value) {|n| n.abs}
     end
 
-    def unquote(value)
-      assert_type value, :String
-      Sass::Script::String.new(value.value)
-    end
-
     private
 
     # This method implements the pattern of transforming a numeric value into