haml-edge 2.3.209 → 2.3.210

data/lib/sass/engine.rb

@@ -9,12 +9,14 @@ require 'sass/tree/directive_node'
 require 'sass/tree/variable_node'
 require 'sass/tree/mixin_def_node'
 require 'sass/tree/mixin_node'
+require 'sass/tree/extend_node'
 require 'sass/tree/if_node'
 require 'sass/tree/while_node'
 require 'sass/tree/for_node'
 require 'sass/tree/debug_node'
 require 'sass/tree/warn_node'
 require 'sass/tree/import_node'
+require 'sass/selector'
 require 'sass/environment'
 require 'sass/script'
 require 'sass/scss'
@@ -79,60 +81,49 @@ module Sass
     end
 
     # The character that begins a CSS property.
-    # @private
     PROPERTY_CHAR  = ?:
 
     # The character that designates that
     # a property should be assigned to a SassScript expression.
-    # @private
     SCRIPT_CHAR     = ?=
 
     # The character that designates the beginning of a comment,
     # either Sass or CSS.
-    # @private
     COMMENT_CHAR = ?/
 
     # The character that follows the general COMMENT_CHAR and designates a Sass comment,
     # which is not output as a CSS comment.
-    # @private
     SASS_COMMENT_CHAR = ?/
 
     # The character that follows the general COMMENT_CHAR and designates a CSS comment,
     # which is embedded in the CSS document.
-    # @private
     CSS_COMMENT_CHAR = ?*
 
     # The character used to denote a compiler directive.
-    # @private
     DIRECTIVE_CHAR = ?@
 
     # Designates a non-parsed rule.
-    # @private
     ESCAPE_CHAR    = ?\\
 
     # Designates block as mixin definition rather than CSS rules to output
-    # @private
     MIXIN_DEFINITION_CHAR = ?=
 
     # Includes named mixin declared using MIXIN_DEFINITION_CHAR
-    # @private
     MIXIN_INCLUDE_CHAR    = ?+
 
     # The regex that matches properties of the form `name: prop`.
-    # @private
     PROPERTY_NEW_MATCHER = /^[^\s:"\[]+\s*[=:](\s|$)/
 
     # The regex that matches and extracts data from
     # properties of the form `name: prop`.
-    # @private
     PROPERTY_NEW = /^([^\s=:"]+)\s*(=|:)(?:\s+|$)(.*)/
 
     # The regex that matches and extracts data from
     # properties of the form `:name prop`.
-    # @private
     PROPERTY_OLD = /^:([^\s=:"]+)\s*(=?)(?:\s+|$)(.*)/
 
     # The default options for Sass::Engine.
+    # @api public
     DEFAULT_OPTIONS = {
       :style => :nested,
       :load_paths => ['.'],
@@ -382,7 +373,10 @@ WARNING
           # if we're using the new property syntax
           Tree::RuleNode.new(parse_interp(line.text))
         else
-          parse_property(line, PROPERTY_OLD)
+          name, eq, value = line.text.scan(PROPERTY_OLD)[0]
+          raise SyntaxError.new("Invalid property: \"#{line.text}\".",
+            :line => @line) if name.nil? || value.nil?
+          parse_property(name, parse_interp(name), eq, value, :old, line)
         end
       when ?!, ?$
         parse_variable(line)
@@ -401,20 +395,29 @@ WARNING
           parse_mixin_include(line, root)
         end
       else
-        if line.text =~ PROPERTY_NEW_MATCHER
-          parse_property(line, PROPERTY_NEW)
-        else
-          Tree::RuleNode.new(parse_interp(line.text))
-        end
+        parse_property_or_rule(line)
       end
     end
 
-    def parse_property(line, property_regx)
-      name, eq, value = line.text.scan(property_regx)[0]
+    def parse_property_or_rule(line)
+      scanner = StringScanner.new(line.text)
+      hack_char = scanner.scan(/[:\*\.]|\#(?!\{)/)
+      parser = Sass::SCSS::SassParser.new(scanner, @line)
 
-      raise SyntaxError.new("Invalid property: \"#{line.text}\".",
-        :line => @line) if name.nil? || value.nil?
+      unless res = parser.parse_interp_ident
+        return Tree::RuleNode.new(parse_interp(line.text))
+      end
+      res.unshift(hack_char) if hack_char
+
+      name = line.text[0...scanner.pos]
+      if scanner.scan(/\s*([:=])(?:\s|$)/)
+        parse_property(name, res, scanner[1], scanner.rest, :new, line)
+      else
+        Tree::RuleNode.new(res + parse_interp(scanner.rest))
+      end
+    end
 
+    def parse_property(name, parsed_name, eq, value, prop, line)
       if value.strip.empty?
         expr = Sass::Script::String.new("")
       else
@@ -427,9 +430,7 @@ WARNING
             @line, line.offset + 1, @options[:filename])
         end
       end
-      Tree::PropNode.new(
-        parse_interp(name), expr,
-        property_regx == PROPERTY_OLD ? :old : :new)
+      Tree::PropNode.new(parse_interp(name), expr, prop)
     end
 
     def parse_variable(line)
@@ -500,6 +501,12 @@ WARNING
           :line => @line + 1) unless line.children.empty?
         offset = line.offset + line.text.index(value).to_i
         Tree::DebugNode.new(parse_script(value, :offset => offset))
+      elsif directive == "extend"
+        raise SyntaxError.new("Invalid extend directive '@extend': expected expression.") unless value
+        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath extend directives.",
+          :line => @line + 1) unless line.children.empty?
+        offset = line.offset + line.text.index(value).to_i
+        Tree::ExtendNode.new(parse_interp(value, offset))
       elsif directive == "warn"
         raise SyntaxError.new("Invalid warn directive '@warn': expected expression.") unless value
         raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath warn directives.",
@@ -552,7 +559,6 @@ WARNING
       nil
     end
 
-    # @private
     MIXIN_DEF_RE = /^(?:=|@mixin)\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
     def parse_mixin_definition(line)
       name, arg_string = line.text.scan(MIXIN_DEF_RE).first
@@ -565,7 +571,6 @@ WARNING
       Tree::MixinDefNode.new(name, args)
     end
 
-    # @private
     MIXIN_INCLUDE_RE = /^(?:\+|@include)\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
     def parse_mixin_include(line, root)
       name, arg_string = line.text.scan(MIXIN_INCLUDE_RE).first
@@ -605,15 +610,15 @@ WARNING
       end
     end
 
-    def parse_interp(text)
-      self.class.parse_interp(text, @line, :filename => @filename)
+    def parse_interp(text, offset = 0)
+      self.class.parse_interp(text, @line, offset, :filename => @filename)
     end
 
     # It's important that this have strings (at least)
     # at the beginning, the end, and between each Script::Node.
     #
     # @private
-    def self.parse_interp(text, line, options)
+    def self.parse_interp(text, line, offset, options)
       res = []
       rest = Haml::Shared.handle_interpolation text do |scan|
         escapes = scan[2].size
@@ -623,7 +628,7 @@ WARNING
         else
           res << "\\" * [0, escapes - 1].max
           res << Script::Parser.new(
-            scan, line, scan.pos - scan.matched_size, options).
+            scan, line, offset + scan.pos - scan.matched_size, options).
             parse_interpolated
         end
       end

data/lib/sass/files.rb

@@ -20,7 +20,7 @@ module Sass
       options = Sass::Engine::DEFAULT_OPTIONS.merge(options)
       text = File.read(filename)
 
-      if options[:cache]
+      if options[:cache] || options[:read_cache]
         compiled_filename = sassc_filename(filename, options)
         sha = Digest::SHA1.hexdigest(text)
 

data/lib/sass/plugin/staleness_checker.rb

@@ -22,6 +22,7 @@ module Sass
     #   *WARNING*: It is important not to retain the instance for too long,
     #   as its instance-level caches are never explicitly expired.
     class StalenessChecker
+      DELETED             = 1.0/0.0 # positive Infinity
       @dependencies_cache = {}
 
       class << self
@@ -47,15 +48,9 @@ module Sass
       # @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)
+        template_file, css_mtime = File.expand_path(template_file), mtime(css_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
+        css_mtime == DELETED || dependency_updated?(css_mtime).call(template_file)
       end
 
       # Returns whether or not a given CSS file is out of date
@@ -87,7 +82,12 @@ module Sass
       end
 
       def mtime(filename)
-        @mtimes[filename] ||= File.mtime(filename)
+        @mtimes[filename] ||= begin
+          File.mtime(filename).to_i
+        rescue Errno::ENOENT
+          @dependencies.delete(filename)
+          DELETED
+        end
       end
 
       def dependencies(filename)

data/lib/sass/plugin.rb

@@ -231,6 +231,27 @@ module Sass
       end
     end
 
+    # Updates all stylesheets, even those that aren't out-of-date.
+    # Ignores the cache.
+    #
+    # @param individual_files [Array<(String, String)>]
+    #   A list of files to check for updates
+    #   **in addition to those specified by the
+    #   {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
+    #   The first string in each pair is the location of the Sass/SCSS file,
+    #   the second is the location of the CSS file that it should be compiled to.
+    # @see #update_stylesheets
+    def force_update_stylesheets(individual_files = [])
+      old_options = options
+      self.options = options.dup
+      options[:never_update] = false
+      options[:always_update] = true
+      options[:cache] = false
+      update_stylesheets(individual_files)
+    ensure
+      self.options = old_options
+    end
+
     # Watches the template directory (or directories)
     # and updates the CSS files whenever the related Sass/SCSS files change.
     # `watch` never returns.

data/lib/sass/script/color.rb

@@ -19,7 +19,6 @@ module Sass::Script
     class << self; include Haml::Util; end
 
     # A hash from color names to `[red, green, blue]` value arrays.
-    # @private
     HTML4_COLORS = map_vals({
         'black'   => 0x000000,
         'silver'  => 0xc0c0c0,
@@ -39,7 +38,6 @@ module Sass::Script
         'aqua'    => 0x00ffff
       }) {|color| (0..2).map {|n| color >> (n << 3) & 0xff}.reverse}
     # A hash from `[red, green, blue]` value arrays to color names.
-    # @private
     HTML4_COLORS_REVERSE = map_hash(HTML4_COLORS) {|k, v| [v, k]}
 
     # Constructs an RGB or HSL color object,
@@ -108,7 +106,10 @@ module Sass::Script
       end
 
       [:saturation, :lightness].each do |k|
-        next if @attrs[k].nil? || (0..100).include?(@attrs[k])
+        next if @attrs[k].nil?
+        @attrs[k] = 0 if @attrs[k] < 0.00001 && @attrs[k] > -0.00001
+        @attrs[k] = 100 if @attrs[k] - 100 < 0.00001 && @attrs[k] - 100 > -0.00001
+        next if (0..100).include?(@attrs[k])
         raise Sass::SyntaxError.new("#{k.to_s.capitalize} must be between 0 and 100")
       end
 

data/lib/sass/script/css_lexer.rb

@@ -1,11 +1,21 @@
 module Sass
   module Script
+    # This is a subclass of {Lexer} for use in parsing plain CSS properties.
+    #
+    # @see Sass::SCSS::CssParser
     class CssLexer < Lexer
+      private
+
       def token
         important || super
       end
 
-      def string(*args)
+      def string(re, *args)
+        if re == :uri
+          return unless uri = scan(URI)
+          return [:string, Script::String.new(uri)]
+        end
+
         return unless scan(STRING)
         [:string, Script::String.new((@scanner[1] || @scanner[2]).gsub(/\\(['"])/, '\1'), :string)]
       end

data/lib/sass/script/css_parser.rb

@@ -3,6 +3,9 @@ require 'sass/script/css_lexer'
 
 module Sass
   module Script
+    # This is a subclass of {Parser} for use in parsing plain CSS properties.
+    #
+    # @see Sass::SCSS::CssParser
     class CssParser < Parser
       private
 
@@ -21,7 +24,7 @@ module Sass
       # Short-circuit all the SassScript-only productions
       alias_method :interpolation, :concat
       alias_method :or_expr, :div
-      alias_method :unary_div, :funcall
+      alias_method :unary_div, :ident
       alias_method :paren, :string
     end
   end

data/lib/sass/script/funcall.rb

@@ -17,6 +17,15 @@ module Sass
       # @return [Array<Script::Node>]
       attr_reader :args
 
+      # Don't set the context for child nodes if this is `url()`,
+      # since `url()` allows quoted strings.
+      #
+      # @param context [Symbol]
+      # @see Node#context=
+      def context=(context)
+        super unless @name == "url"
+      end
+
       # @param name [String] See \{#name}
       # @param name [Array<Script::Node>] See \{#args}
       def initialize(name, args)

data/lib/sass/script/interpolation.rb

@@ -1,5 +1,15 @@
 module Sass::Script
+  # A SassScript object representing `#{}` interpolation outside a string.
+  #
+  # @see StringInterpolation
   class Interpolation < Node
+    # Interpolation in a property is of the form `before #{mid} after`.
+    #
+    # @param before [Node] The SassScript before the interpolation
+    # @param mid [Node] The SassScript within the interpolation
+    # @param after [Node] The SassScript after the interpolation
+    # @param wb [Boolean] Whether there was whitespace between `before` and `#{`
+    # @param wa [Boolean] Whether there was whitespace between `}` and `after`
     def initialize(before, mid, after, wb, wa)
       @before = before
       @mid = mid
@@ -8,10 +18,12 @@ module Sass::Script
       @whitespace_after = wa
     end
 
+    # @return [String] A human-readable s-expression representation of the interpolation
     def inspect
       "(interpolation #{@before.inspect} #{@mid.inspect} #{@after.inspect})"
     end
 
+    # @see Node#to_sass
     def to_sass(opts = {})
       res = ""
       res << @before.to_sass(opts) if @before
@@ -22,12 +34,21 @@ module Sass::Script
       res
     end
 
+    # Returns the three components of the interpolation, `before`, `mid`, and `after`.
+    #
+    # @return [Array<Node>]
+    # @see #initialize
+    # @see Node#children
     def children
       [@before, @mid, @after].compact
     end
 
     protected
 
+    # Evaluates the interpolation.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Sass::Script::String] The SassScript string that is the value of the interpolation
     def _perform(environment)
       res = ""
       res << @before.perform(environment).to_s if @before

data/lib/sass/script/lexer.rb

@@ -40,7 +40,6 @@ module Sass
       attr_reader :offset
 
       # A hash from operator strings to the corresponding token types.
-      # @private
       OPERATORS = {
         '+' => :plus,
         '-' => :minus,
@@ -67,10 +66,8 @@ module Sass
         '{' => :lcurly,
       }
 
-      # @private
       OPERATORS_REVERSE = Haml::Util.map_hash(OPERATORS) {|k, v| [v, k]}
 
-      # @private
       TOKEN_NAMES = Haml::Util.map_hash(OPERATORS_REVERSE) {|k, v| [k, v.inspect]}.merge({
           :const => "variable (e.g. $foo)",
           :ident => "identifier (e.g. middle)",
@@ -79,22 +76,19 @@ module Sass
 
       # A list of operator strings ordered with longer names first
       # so that `>` and `<` don't clobber `>=` and `<=`.
-      # @private
       OP_NAMES = OPERATORS.keys.sort_by {|o| -o.size}
 
       # A sub-list of {OP_NAMES} that only includes operators
       # with identifier names.
-      # @private
       IDENT_OP_NAMES = OP_NAMES.select {|k, v| k =~ /^\w+/}
 
       # A hash of regular expressions that are used for tokenizing.
-      # @private
       REGULAR_EXPRESSIONS = {
         :whitespace => /\s+/,
         :comment => COMMENT,
         :single_line_comment => SINGLE_LINE_COMMENT,
         :variable => /([!\$])(#{IDENT})/,
-        :ident => IDENT,
+        :ident => /(#{IDENT})(\()?/,
         :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
         :color => HEXCOLOR,
         :bool => /(true|false)\b/,
@@ -120,6 +114,8 @@ module Sass
         [:single, false] => string_re("'", "'"),
         [:double, true] => string_re('', '"'),
         [:single, true] => string_re('', "'"),
+        [:uri, false] => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|(?=#\{))/,
+        [:uri, true] => /(#{URLCHAR}*?)(#{W}\)|(?=#\{))/,
       }
 
       # @param str [String, StringScanner] The source text to lex
@@ -179,11 +175,24 @@ module Sass
         @scanner.eos? && @tok.nil?
       end
 
+      # Raise an error to the effect that `name` was expected in the input stream
+      # and wasn't found.
+      #
+      # This calls \{#unpeek!} to rewind the scanner to immediately after
+      # the last returned token.
+      #
+      # @param name [String] The name of the entity that was expected but not found
+      # @raise [Sass::SyntaxError]
       def expected!(name)
         unpeek!
         Sass::SCSS::Parser.expected(@scanner, name, @line)
       end
 
+      # Records all non-comment text the lexer consumes within the block
+      # and returns it as a string.
+      #
+      # @yield A block in which text is recorded
+      # @return [String]
       def str
         old_pos = @tok ? @tok.pos : @scanner.pos
         yield
@@ -216,8 +225,8 @@ module Sass
         end
 
         variable || string(:double, false) || string(:single, false) || number ||
-          color || bool || raw(URI) || raw(UNICODERANGE) || special_fun ||
-          ident_op || ident || op
+          color || bool || string(:uri, false) || raw(UNICODERANGE) ||
+          special_fun || ident_op || ident || op
       end
 
       def variable
@@ -236,14 +245,20 @@ module Sass
       end
 
       def ident
-        return unless s = scan(REGULAR_EXPRESSIONS[:ident])
-        [:ident, s]
+        return unless scan(REGULAR_EXPRESSIONS[:ident])
+        [@scanner[2] ? :funcall : :ident, @scanner[1]]
       end
 
       def string(re, open)
         return unless scan(STRING_REGULAR_EXPRESSIONS[[re, open]])
         @interpolation_stack << re if @scanner[2].empty? # Started an interpolated section
-        [:string, Script::String.new(@scanner[1].gsub(/\\(['"]|\#\{)/, '\1'), :string)]
+        str =
+          if re == :uri
+            Script::String.new("#{'url(' unless open}#{@scanner[1]}#{')' unless @scanner[2].empty?}")
+          else
+            Script::String.new(@scanner[1].gsub(/\\(['"]|\#\{)/, '\1'), :string)
+          end
+        [:string, str]
       end
 
       def number
@@ -269,11 +284,13 @@ module Sass
         return unless str1 = scan(/(calc|expression|progid:[a-z\.]*)\(/i)
         str2, _ = Haml::Shared.balance(@scanner, ?(, ?), 1)
         c = str2.count("\n")
+        old_line = @line
+        old_offset = @offset
         @line += c
         @offset = (c == 0 ? @offset + str2.size : str2[/\n(.*)/, 1].size)
         [:special_fun,
           Haml::Util.merge_adjacent_strings(
-            [str1] + Sass::Engine.parse_interp(str2, @line, @options)),
+            [str1] + Sass::Engine.parse_interp(str2, old_line, old_offset, @options)),
           str1.size + str2.size]
       end
 

data/lib/sass/script/node.rb

@@ -35,7 +35,7 @@ module Sass::Script
       children.each {|c| c.options = options}
     end
 
-    # Sets the options hash for this node,
+    # Sets the context for this node,
     # as well as for all child nodes.
     #
     # @param context [Symbol]

data/lib/sass/script/number.rb

@@ -30,6 +30,7 @@ module Sass::Script
     # The precision with which numbers will be printed to CSS files.
     # For example, if this is `1000.0`,
     # `3.1415926` will be printed as `3.142`.
+    # @api public
     PRECISION = 1000.0
 
     # @param value [Numeric] The value of the number
@@ -115,7 +116,7 @@ module Sass::Script
     # @raise [NoMethodError] if `other` is an invalid type
     def times(other)
       if other.is_a? Number
-        self.operate(other, :*)
+        operate(other, :*)
       elsif other.is_a? Color
         other.times(self)
       else
@@ -303,7 +304,7 @@ module Sass::Script
     # @return [Boolean] Whether or not this number can be compared with the other.
     def comparable_to?(other)
       begin
-        self.operate(other, :+)
+        operate(other, :+)
         true
       rescue Sass::UnitConversionError
         false
@@ -323,7 +324,7 @@ module Sass::Script
       rv
     end
 
-    protected
+    private
 
     def operate(other, operation)
       this = self
@@ -381,9 +382,7 @@ module Sass::Script
     end
 
     # A hash of unit names to their index in the conversion table
-    # @private
     CONVERTABLE_UNITS = {"in" => 0,        "cm" => 1,    "pc" => 2,    "mm" => 3,   "pt" => 4}
-    # @private
     CONVERSION_TABLE = [[ 1,                2.54,         6,            25.4,        72        ], # in
                         [ nil,              1,            2.36220473,   10,          28.3464567], # cm
                         [ nil,              nil,          1,            4.23333333,  12        ], # pc

data/lib/sass/script/parser.rb

@@ -120,7 +120,6 @@ module Sass
         new(*args).parse
       end
 
-      # @private
       PRECEDENCE = [
         :comma, :single_eq, :concat, :or, :and,
         [:eq, :neq],
@@ -214,24 +213,24 @@ RUBY
       unary :plus, :unary_minus
       unary :minus, :unary_div
       unary :div, :unary_not # For strings, so /foo/bar works
-      unary :not, :funcall
+      unary :not, :ident
 
-      def funcall
-        return raw unless @lexer.peek && @lexer.peek.type == :ident
+      def ident
+        return funcall unless @lexer.peek && @lexer.peek.type == :ident
         return if @stop_at && @stop_at.include?(@lexer.peek.value)
 
         name = @lexer.next
-        # An identifier without arguments is just a string
-        unless try_tok(:lparen)
-          if color = Color::HTML4_COLORS[name.value]
-            return node(Color.new(color))
-          end
-          node(Script::String.new(name.value, :identifier))
-        else
-          args = fn_arglist || []
-          assert_tok(:rparen)
-          node(Script::Funcall.new(name.value, args))
+        if color = Color::HTML4_COLORS[name.value]
+          return node(Color.new(color))
         end
+        node(Script::String.new(name.value, :identifier))
+      end
+
+      def funcall
+        return raw unless tok = try_tok(:funcall)
+        args = fn_arglist || []
+        assert_tok(:rparen)
+        node(Script::Funcall.new(tok.value, args))
       end
 
       def defn_arglist!(must_have_default)

data/lib/sass/script/string.rb

@@ -15,6 +15,10 @@ module Sass::Script
     # @return [Symbol] `:string` or `:identifier`
     attr_reader :type
 
+    # In addition to setting the \{#context} of the string,
+    # this sets the string to be an identifier if the context is `:equals`.
+    #
+    # @see Node#context=
     def context=(context)
       super
       @type = :identifier if context == :equals
@@ -29,6 +33,7 @@ module Sass::Script
       @type = type
     end
 
+    # @see Literal#plus
     def plus(other)
       other_str = other.is_a?(Sass::Script::String) ? other.value : other.to_s
       Sass::Script::String.new(self.value + other_str, self.type)
@@ -47,12 +52,13 @@ module Sass::Script
     def to_sass(opts = {})
       type = opts[:type] || self.type
       if type == :identifier
-        if context == :equals && Sass::SCSS::RX.escape_ident(self.value).include?(?\\)
+        if context == :equals && self.value !~ Sass::SCSS::RX::URI &&
+            Sass::SCSS::RX.escape_ident(self.value).include?(?\\)
           return "unquote(#{Sass::Script::String.new(self.value, :string).to_sass})"
         elsif context == :equals && self.value.size == 0
           return %q{""}
         end
-        return self.value
+        return self.value.gsub("\n", " ")
       end
 
       return "\"#{value.gsub('"', "\\\"")}\"" if opts[:quote] == %q{"}