sass 3.1.15 → 3.1.16

data/lib/sass/plugin/listener.rb

@@ -0,0 +1,59 @@
+# A wrapper around the Listen gem. Adds support for listening to individual
+# files, as well as a somewhat cleaner event dispatch API.
+#
+# @private
+class Sass::Plugin::Listener
+  def initialize
+    @directories = {}
+    yield self
+    begin
+      start!
+    rescue Exception => e
+      raise e unless e.is_a?(Interrupt)
+    end
+  end
+
+  def directory(path, events)
+    (@directories[path] ||= []) << events
+  end
+
+  def file(path, events)
+    file_base = File.basename(path)
+    directory(File.dirname(path), {
+        :modified => file_event_fn(events[:modified], file_base),
+        :added => file_event_fn(events[:added], file_base),
+        :removed => file_event_fn(events[:removed], file_base)
+      })
+  end
+
+  def start!
+    listener = Listen::MultiListener.new(*@directories.keys) do |modified, added, removed|
+      modified = modified.group_by {|path| File.dirname(path)}
+      added = added.group_by {|path| File.dirname(path)}
+      removed = removed.group_by {|path| File.dirname(path)}
+
+      @directories.each do |dir, events|
+        events.each do |e|
+          run_events(modified[dir], e[:modified], dir)
+          run_events(added[dir], e[:added], dir)
+          run_events(removed[dir], e[:removed], dir)
+        end
+      end
+    end.start
+  end
+
+  private
+
+  def file_event_fn(event, file_base)
+    lambda do |dir, base|
+      next unless event
+      next unless base == file_base
+      event.call
+    end
+  end
+
+  def run_events(paths, event, path)
+    return if paths.nil? || event.nil?
+    paths.each {|p| event[File.dirname(p), File.basename(p)]}
+  end
+end

data/lib/sass/script/lexer.rb

@@ -287,7 +287,7 @@ MESSAGE
       end
 
       def special_fun
-        return unless str1 = scan(/((-[\w-]+-)?calc|expression|progid:[a-z\.]*)\(/i)
+        return unless str1 = scan(/((-[\w-]+-)?(calc|element)|expression|progid:[a-z\.]*)\(/i)
         str2, _ = Sass::Shared.balance(@scanner, ?(, ?), 1)
         c = str2.count("\n")
         old_line = @line

data/lib/sass/script/list.rb

@@ -46,6 +46,7 @@ module Sass::Script
 
     # @see Node#to_sass
     def to_sass(opts = {})
+      return "()" if value.empty?
       precedence = Sass::Script::Parser.precedence_of(separator)
       value.map do |v|
         if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence

data/lib/sass/scss/parser.rb

@@ -114,7 +114,9 @@ module Sass
       end
 
       DIRECTIVES = Set[:mixin, :include, :function, :return, :debug, :warn, :for,
-        :each, :while, :if, :else, :extend, :import, :media, :charset]
+        :each, :while, :if, :else, :extend, :import, :media, :charset, :_moz_document]
+
+      PREFIXED_DIRECTIVES = Set[:supports]
 
       def directive
         return unless tok(/@/)
@@ -123,13 +125,19 @@ module Sass
 
         if dir = special_directive(name)
           return dir
+        elsif dir = prefixed_directive(name)
+          return dir
         end
 
         # Most at-rules take expressions (e.g. @import),
         # but some (e.g. @page) take selector-like arguments
         val = str {break unless expr}
         val ||= CssParser.new(@scanner, @line).parse_selector_string
-        node = node(Sass::Tree::DirectiveNode.new("@#{name} #{val}".strip))
+        directive_body("@#{name} #{val}")
+      end
+
+      def directive_body(value)
+        node = node(Sass::Tree::DirectiveNode.new(value.strip))
 
         if tok(/\{/)
           node.has_children = true
@@ -145,6 +153,11 @@ module Sass
         DIRECTIVES.include?(sym) && send("#{sym}_directive")
       end
 
+      def prefixed_directive(name)
+        sym = name.gsub(/^-[a-z0-9]+-/i, '').gsub('-', '_').to_sym
+        PREFIXED_DIRECTIVES.include?(sym) && send("#{sym}_directive", name)
+      end
+
       def mixin_directive
         name = tok! IDENT
         args = sass_script(:parse_mixin_definition_arglist)
@@ -346,6 +359,76 @@ module Sass
         node(Sass::Tree::CharsetNode.new(name))
       end
 
+      # The document directive is specified in
+      # http://www.w3.org/TR/css3-conditional/, but Gecko allows the
+      # `url-prefix` and `domain` functions to omit quotation marks, contrary to
+      # the standard.
+      #
+      # We could parse all document directives according to Mozilla's syntax,
+      # but if someone's using e.g. @-webkit-document we don't want them to
+      # think WebKit works sans quotes.
+      def _moz_document_directive
+        value = str do
+          begin
+            ss
+            expr!(:moz_document_function)
+          end while tok(/,/)
+        end
+        directive_body("@-moz-document #{value}")
+      end
+
+      def moz_document_function
+        return unless tok(URI) || tok(URL_PREFIX) || tok(DOMAIN) || function
+        ss
+      end
+
+      # http://www.w3.org/TR/css3-conditional/
+      def supports_directive(name)
+        value = str {expr!(:supports_condition)}
+        directive_body("@#{name} #{value}")
+      end
+
+      def supports_condition
+        supports_negation || supports_operator || supports_declaration_condition
+      end
+
+      def supports_negation
+        return unless tok(/not/i)
+        ss
+        expr!(:supports_condition_in_parens)
+      end
+
+      def supports_operator
+        return unless supports_condition_in_parens
+        tok!(/and|or/i)
+        begin
+          ss
+          expr!(:supports_condition_in_parens)
+        end while tok(/and|or/i)
+        true
+      end
+
+      def supports_condition_in_parens
+        return unless tok(/\(/); ss
+        if supports_condition
+          tok!(/\)/); ss
+        else
+          supports_declaration_body
+        end
+      end
+
+      def supports_declaration_condition
+        return unless tok(/\(/); ss
+        supports_declaration_body
+      end
+
+      def supports_declaration_body
+        tok!(IDENT); ss
+        tok!(/:/); ss
+        expr!(:expr); ss
+        tok!(/\)/); ss
+      end
+
       def variable
         return unless tok(/\$/)
         name = tok!(IDENT)
@@ -792,11 +875,11 @@ MESSAGE
         @strs.pop
       end
 
-      def str?(&block)
+      def str?
         pos = @scanner.pos
         line = @line
         @strs.push ""
-        throw_error(&block) && @strs.last
+        throw_error {yield} && @strs.last
       rescue Sass::SyntaxError => e
         @scanner.pos = pos
         @line = line
@@ -841,6 +924,9 @@ MESSAGE
         :selector_comma_sequence => "selector",
         :simple_selector_sequence => "selector",
         :import_arg => "file to import (string or url())",
+        :moz_document_function => "matching function (e.g. url-prefix(), domain())",
+        :supports_condition => "@supports condition (e.g. (display: flexbox))",
+        :supports_condition_in_parens => "@supports condition (e.g. (display: flexbox))",
       }
 
       TOK_NAMES = Sass::Util.to_hash(

data/lib/sass/scss/rx.rb

@@ -107,6 +107,11 @@ module Sass
       TILDE = /#{W}~/
       NOT = quote(":not(", Regexp::IGNORECASE)
 
+      # Defined in https://developer.mozilla.org/en/CSS/@-moz-document as a
+      # non-standard version of http://www.w3.org/TR/css3-conditional/
+      URL_PREFIX = /url-prefix\(#{W}(?:#{STRING}|#{URL})#{W}\)/i
+      DOMAIN = /domain\(#{W}(?:#{STRING}|#{URL})#{W}\)/i
+
       # Custom
       HEXCOLOR = /\#[0-9a-fA-F]+/
       INTERP_START = /#\{/

data/lib/sass/scss/static_parser.rb

@@ -32,7 +32,7 @@ module Sass
       def use_css_import?; true; end
 
       def special_directive(name)
-        return unless  %w[media import charset].include?(name)
+        return unless %w[media import charset -moz-document].include?(name)
         super
       end
     end

data/lib/sass/selector/abstract_sequence.rb

@@ -2,8 +2,9 @@ module Sass
   module Selector
     # The abstract parent class of the various selector sequence classes.
     #
-    # All subclasses should implement a `members` method
-    # that returns an array of object that respond to `#line=` and `#filename=`.
+    # All subclasses should implement a `members` method that returns an array
+    # of object that respond to `#line=` and `#filename=`, as well as a `to_a`
+    # method that returns an array of strings and script nodes.
     class AbstractSequence
       # The line of the Sass template on which this selector was declared.
       #
@@ -57,6 +58,14 @@ module Sass
         other.class == self.class && other.hash == self.hash && _eql?(other)
       end
       alias_method :==, :eql?
+
+      # Converts the selector into a string. This is the standard selector
+      # string, along with any SassScript interpolation that may exist.
+      #
+      # @return [String]
+      def to_s
+        to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
+      end
     end
   end
 end

data/lib/sass/selector/simple.rb

@@ -33,6 +33,12 @@ module Sass
         to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
       end
 
+      # @see \{#inspect}
+      # @return [String]
+      def to_s
+        inspect
+      end
+
       # Returns a hash code for this selector object.
       #
       # By default, this is based on the value of \{#to\_a},

data/lib/sass/tree/comment_node.rb

@@ -81,7 +81,7 @@ module Sass::Tree
       pre = str.split("\n").inject(str[/^[ \t]*/].split("")) do |pre, line|
         line[/^[ \t]*/].split("").zip(pre).inject([]) do |arr, (a, b)|
           break arr if a != b
-          arr + [a]
+          arr << a
         end
       end.join
       str.gsub(/^#{pre}/, '')

data/lib/sass/tree/node.rb

@@ -158,9 +158,9 @@ module Sass
       #
       # @yield node
       # @yieldparam node [Node] a node in the tree
-      def each(&block)
+      def each
         yield self
-        children.each {|c| c.each(&block)}
+        children.each {|c| c.each {|n| yield n}}
       end
 
       # Converts a node to Sass code that will generate it.

data/lib/sass/tree/visitors/check_nesting.rb

@@ -125,9 +125,9 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
     return false
   end
 
-  def try_send(method, *args, &block)
+  def try_send(method, *args)
     return unless respond_to?(method)
-    send(method, *args, &block)
+    send(method, *args)
   end
 end
 

data/lib/sass/tree/visitors/cssize.rb

@@ -17,7 +17,7 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
   # If an exception is raised, this adds proper metadata to the backtrace.
   def visit(node)
-    super(node.dup)
+    super(node)
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:filename => node.filename, :line => node.line)
     raise e

data/lib/sass/util.rb

@@ -85,8 +85,9 @@ module Sass
     # @return [Hash] The mapped hash
     # @see #map_keys
     # @see #map_vals
-    def map_hash(hash, &block)
-      to_hash(hash.map(&block))
+    def map_hash(hash)
+      # Using &block here completely hoses performance on 1.8.
+      to_hash(hash.map {|k, v| yield k, v})
     end
 
     # Computes the powerset of the given array.

data/test/sass/conversion_test.rb

@@ -1158,6 +1158,16 @@ SASS
 SCSS
   end
 
+  ## Regression Tests
+
+  def test_empty_lists
+    assert_renders(<<SASS, <<SCSS)
+$foo: ()
+SASS
+$foo: ();
+SCSS
+  end
+
   private
 
   def assert_sass_to_sass(sass, options = {})

data/test/sass/css2sass_test.rb

@@ -277,6 +277,30 @@ foo, , bar { a: b }
 CSS
   end
 
+  def test_selector_splitting
+    assert_equal(<<SASS, css2sass(<<CSS))
+.foo >
+  .bar
+    a: b
+  .baz
+    c: d
+SASS
+.foo>.bar {a: b}
+.foo>.baz {c: d}
+CSS
+
+    assert_equal(<<SASS, css2sass(<<CSS))
+.foo
+  &::bar
+    a: b
+  &::baz
+    c: d
+SASS
+.foo::bar {a: b}
+.foo::baz {c: d}
+CSS
+  end
+
   # Error reporting
 
   def test_error_reporting

data/test/sass/engine_test.rb

@@ -140,6 +140,7 @@ MSG
     "$var: true\n@while $var\n  @extend .bar\n  $var: false" => ["Extend directives may only be used within rules.", 3],
     "@for $i from 0 to 1\n  @extend .bar" => ["Extend directives may only be used within rules.", 2],
     "@mixin foo\n  @extend .bar\n@include foo" => ["Extend directives may only be used within rules.", 2],
+    "@import \"foo\" // bar" => "Invalid @import: \"\"foo\" // bar\"",
 
     # Regression tests
     "a\n  b:\n    c\n    d" => ["Illegal nesting: Only properties may be nested beneath properties.", 3],

data/test/sass/scss/css_test.rb

@@ -412,6 +412,15 @@ foo {
 SCSS
   end
 
+  def test_element_function
+    assert_parses <<SCSS
+foo {
+  a: -moz-element(#foo);
+  b: -webkit-element(#foo);
+  b: -foobar-element(#foo); }
+SCSS
+  end
+
   def test_unary_ops
     assert_equal <<CSS, render(<<SCSS)
 foo {
@@ -586,6 +595,50 @@ CSS
 SCSS
   end
 
+  def test_moz_document_directive
+    assert_equal <<CSS, render(<<SCSS)
+@-moz-document url(http://www.w3.org/),
+               url-prefix(http://www.w3.org/Style/),
+               domain(mozilla.org),
+               regexp("^https:.*") {
+  .foo {
+    a: b; } }
+CSS
+@-moz-document url(http://www.w3.org/),
+               url-prefix(http://www.w3.org/Style/),
+               domain(mozilla.org),
+               regexp("^https:.*") {
+  .foo {a: b}
+}
+SCSS
+  end
+
+  def test_supports
+    assert_equal <<CSS, render(<<SCSS)
+@supports (a: b) and (c: d) or (not (d: e)) and ((not (f: g)) or (not ((h: i) and (j: k)))) {
+  .foo {
+    a: b; } }
+CSS
+@supports (a: b) and (c: d) or (not (d: e)) and ((not (f: g)) or (not ((h: i) and (j: k)))) {
+  .foo {
+    a: b;
+  }
+}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+@-prefix-supports (a: b) and (c: d) or (not (d: e)) and ((not (f: g)) or (not ((h: i) and (j: k)))) {
+  .foo {
+    a: b; } }
+CSS
+@-prefix-supports (a: b) and (c: d) or (not (d: e)) and ((not (f: g)) or (not ((h: i) and (j: k)))) {
+  .foo {
+    a: b;
+  }
+}
+SCSS
+  end
+
   ## Selectors
 
   # Taken from http://www.w3.org/TR/css3-selectors/#selectors