sass 3.1.15 → 3.1.16

data/README.md

@@ -175,16 +175,15 @@ See `sass-convert --help` for further information and options.
 
 Sass was envisioned by [Hampton Catlin](http://hamptoncatlin.com) (hcatlin).
 However, Hampton doesn't even know his way around the code anymore and now
-occasionally consults on the language issues. Hampton lives in Jacksonville,
-Florida and is the lead mobile developer for Wikimedia.
+occasionally consults on the language issues. Hampton lives in Cambridge, UK and
+is the owner of [Catlin Software](http://www.catlinsoftware.com/).
 
 [Nathan Weizenbaum](http://nex-3.com) is the primary developer and architect of
 Sass. His hard work has kept the project alive by endlessly answering forum
 posts, fixing bugs, refactoring, finding speed improvements, writing
 documentation, implementing new features, and getting Hampton coffee (a fitting
-task for a boy-genius). Nathan lives in Seattle, Washington and while not being
-a student at the University of Washington or working at an internship, he
-consults for Unspace Interactive.
+task for a boy-genius). Nathan lives in Seattle, Washington and works on
+[Dart](http://dartlang.org) application libraries at Google.
 
 [Chris Eppstein](http://acts-as-architect.blogspot.com) is a core contributor to
 Sass and the creator of Compass, the first Sass-based framework. Chris focuses

data/Rakefile

@@ -115,9 +115,9 @@ task :submodules do
   if File.exist?(File.dirname(__FILE__) + "/.git")
     sh %{git submodule sync}
     sh %{git submodule update --init}
-  elsif !File.exist?(File.dirname(__FILE__) + "/vendor/fssm/lib")
+  elsif !File.exist?(File.dirname(__FILE__) + "/vendor/listen/lib")
     warn <<WARN
-WARNING: vendor/fssm doesn't exist, and this isn't a git repository so
+WARNING: vendor/listen doesn't exist, and this isn't a git repository so
 I can't get it automatically!
 WARN
   end

data/VERSION

@@ -1 +1 @@
-3.1.15
+3.1.16

data/lib/sass/css.rb

@@ -75,14 +75,29 @@ module Sass
     # @return [Tree::Node] The root node of the parsed tree
     def build_tree
       root = Sass::SCSS::CssParser.new(@template, @options[:filename]).parse
+      parse_selectors    root
       expand_commas      root
+      nest_seqs          root
       parent_ref_rules   root
-      remove_parent_refs root
       flatten_rules      root
       fold_commas        root
+      dump_selectors     root
       root
     end
 
+    # Parse all the selectors in the document and assign them to
+    # {Sass::Tree::RuleNode#parsed_rules}.
+    #
+    # @param root [Tree::Node] The parent node
+    def parse_selectors(root)
+      root.children.each do |child|
+        next parse_selectors(child) if child.is_a?(Tree::DirectiveNode)
+        next unless child.is_a?(Tree::RuleNode)
+        parser = Sass::SCSS::CssParser.new(child.rule.first, child.filename, child.line)
+        child.parsed_rules = parser.parse_selector
+      end
+    end
+
     # Transform
     #
     #     foo, bar, baz
@@ -100,13 +115,14 @@ module Sass
     # @param root [Tree::Node] The parent node
     def expand_commas(root)
       root.children.map! do |child|
-        unless child.is_a?(Tree::RuleNode) && child.rule.first.include?(',')
+        # child.parsed_rules.members.size > 1 iff the rule contains a comma
+        unless child.is_a?(Tree::RuleNode) && child.parsed_rules.members.size > 1
           expand_commas(child) if child.is_a?(Tree::DirectiveNode)
           next child
         end
-        child.rule.first.split(',').map do |rule|
-          next if rule.strip.empty?
-          node = Tree::RuleNode.new([rule.strip])
+        child.parsed_rules.members.map do |seq|
+          node = Tree::RuleNode.new([])
+          node.parsed_rules = make_cseq(seq)
           node.children = child.children
           node
         end
@@ -114,22 +130,7 @@ module Sass
       root.children.flatten!
     end
 
-    # Make rules use parent refs so that
-    #
-    #     foo
-    #       color: green
-    #     foo.bar
-    #       color: blue
-    #
-    # becomes
-    #
-    #     foo
-    #       color: green
-    #       &.bar
-    #         color: blue
-    #
-    # This has the side effect of nesting rules,
-    # so that
+    # Make rules use nesting so that
     #
     #     foo
     #       color: green
@@ -142,28 +143,31 @@ module Sass
     #
     #     foo
     #       color: green
-    #       & bar
+    #       bar
     #         color: red
-    #       & baz
+    #       baz
     #         color: blue
     #
     # @param root [Tree::Node] The parent node
-    def parent_ref_rules(root)
+    def nest_seqs(root)
       current_rule = nil
       root.children.map! do |child|
         unless child.is_a?(Tree::RuleNode)
-          parent_ref_rules(child) if child.is_a?(Tree::DirectiveNode)
+          nest_seqs(child) if child.is_a?(Tree::DirectiveNode)
           next child
         end
 
-        first, rest = child.rule.first.scan(/\A(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?\Z/m).first
+        seq = first_seq(child)
+        seq.members.reject! {|sseq| sseq == "\n"}
+        first, rest = seq.members.first, seq.members[1..-1]
 
-        if current_rule.nil? || current_rule.rule.first != first
-          current_rule = Tree::RuleNode.new([first])
+        if current_rule.nil? || first_sseq(current_rule) != first
+          current_rule = Tree::RuleNode.new([])
+          current_rule.parsed_rules = make_seq(first)
         end
 
-        if rest
-          child.rule = ["&" + rest]
+        unless rest.empty?
+          child.parsed_rules = make_seq(*rest)
           current_rule << child
         else
           current_rule.children += child.children
@@ -174,32 +178,57 @@ module Sass
       root.children.compact!
       root.children.uniq!
 
-      root.children.each { |v| parent_ref_rules(v) }
+      root.children.each {|v| nest_seqs(v)}
     end
 
-    # Remove useless parent refs so that
+    # Make rules use parent refs so that
     #
     #     foo
-    #       & bar
-    #         color: blue
+    #       color: green
+    #     foo.bar
+    #       color: blue
     #
     # becomes
     #
     #     foo
-    #       bar
+    #       color: green
+    #       &.bar
     #         color: blue
     #
     # @param root [Tree::Node] The parent node
-    def remove_parent_refs(root)
-      root.children.each do |child|
-        case child
-        when Tree::RuleNode
-          child.rule.first.gsub! /^& +/, ''
-          remove_parent_refs child
-        when Tree::DirectiveNode
-          remove_parent_refs child
+    def parent_ref_rules(root)
+      current_rule = nil
+      root.children.map! do |child|
+        unless child.is_a?(Tree::RuleNode)
+          parent_ref_rules(child) if child.is_a?(Tree::DirectiveNode)
+          next child
+        end
+
+        sseq = first_sseq(child)
+        next child unless sseq.is_a?(Sass::Selector::SimpleSequence)
+
+        firsts, rest = [sseq.members.first], sseq.members[1..-1]
+        firsts.push rest.shift if firsts.first.is_a?(Sass::Selector::Parent)
+
+        if current_rule.nil? || first_sseq(current_rule).members != firsts
+          current_rule = Tree::RuleNode.new([])
+          current_rule.parsed_rules = make_sseq(*firsts)
+        end
+
+        unless rest.empty?
+          rest.unshift Sass::Selector::Parent.new
+          child.parsed_rules = make_sseq(*rest)
+          current_rule << child
+        else
+          current_rule.children += child.children
         end
+
+        current_rule
       end
+      root.children.compact!
+      root.children.uniq!
+
+      root.children.each {|v| parent_ref_rules(v)}
     end
 
     # Flatten rules so that
@@ -236,7 +265,7 @@ module Sass
       end
     end
 
-    # Flattens a single rule
+    # Flattens a single rule.
     #
     # @param rule [Tree::RuleNode] The candidate for flattening
     # @see #flatten_rules
@@ -244,10 +273,10 @@ module Sass
       while rule.children.size == 1 && rule.children.first.is_a?(Tree::RuleNode)
         child = rule.children.first
 
-        if child.rule.first[0] == ?&
-          rule.rule = [child.rule.first.gsub(/^&/, rule.rule.first)]
+        if first_simple_sel(child).is_a?(Sass::Selector::Parent)
+          rule.parsed_rules = child.parsed_rules.resolve_parent_refs(rule.parsed_rules)
         else
-          rule.rule = ["#{rule.rule.first} #{child.rule.first}"]
+          rule.parsed_rules = make_seq(first_sseq(rule), *first_seq(child).members)
         end
 
         rule.children = child.children
@@ -280,7 +309,7 @@ module Sass
         end
 
         if prev_rule && prev_rule.children == child.children
-          prev_rule.rule.first << ", #{child.rule.first}"
+          prev_rule.parsed_rules.members << first_seq(child)
           next nil
         end
 
@@ -290,5 +319,72 @@ module Sass
       end
       root.children.compact!
     end
+
+    # Dump all the parsed {Sass::Tree::RuleNode} selectors to strings.
+    #
+    # @param root [Tree::Node] The parent node
+    def dump_selectors(root)
+      root.children.each do |child|
+        next dump_selectors(child) if child.is_a?(Tree::DirectiveNode)
+        next unless child.is_a?(Tree::RuleNode)
+        child.rule = [child.parsed_rules.to_s]
+        dump_selectors(child)
+      end
+    end
+
+    # Create a {Sass::Selector::CommaSequence}.
+    #
+    # @param seqs [Array<Sass::Selector::Sequence>]
+    # @return [Sass::Selector::CommaSequence]
+    def make_cseq(*seqs)
+      Sass::Selector::CommaSequence.new(seqs)
+    end
+
+    # Create a {Sass::Selector::CommaSequence} containing only a single
+    # {Sass::Selector::Sequence}.
+    #
+    # @param sseqs [Array<Sass::Selector::Sequence, String>]
+    # @return [Sass::Selector::CommaSequence]
+    def make_seq(*sseqs)
+      make_cseq(Sass::Selector::Sequence.new(sseqs))
+    end
+
+    # Create a {Sass::Selector::CommaSequence} containing only a single
+    # {Sass::Selector::Sequence} which in turn contains only a single
+    # {Sass::Selector::SimpleSequence}.
+    #
+    # @param sseqs [Array<Sass::Selector::Sequence, String>]
+    # @return [Sass::Selector::CommaSequence]
+    def make_sseq(*sseqs)
+      make_seq(Sass::Selector::SimpleSequence.new(sseqs))
+    end
+
+    # Return the first {Sass::Selector::Sequence} in a {Sass::Tree::RuleNode}.
+    #
+    # @param rule [Sass::Tree::RuleNode]
+    # @return [Sass::Selector::Sequence]
+    def first_seq(rule)
+      rule.parsed_rules.members.first
+    end
+
+    # Return the first {Sass::Selector::SimpleSequence} in a
+    # {Sass::Tree::RuleNode}.
+    #
+    # @param rule [Sass::Tree::RuleNode]
+    # @return [Sass::Selector::SimpleSequence, String]
+    def first_sseq(rule)
+      first_seq(rule).members.first
+    end
+
+    # Return the first {Sass::Selector::Simple} in a {Sass::Tree::RuleNode},
+    # unless the rule begins with a combinator.
+    #
+    # @param rule [Sass::Tree::RuleNode]
+    # @return [Sass::Selector::Simple?]
+    def first_simple_sel(rule)
+      sseq = first_sseq(rule)
+      return unless sseq.is_a?(Sass::Selector::SimpleSequence)
+      sseq.members.first
+    end
   end
 end

data/lib/sass/engine.rb

@@ -777,8 +777,10 @@ WARNING
 
       val = scanner[1] || scanner[2]
       scanner.scan(/\s*/)
-      if media = scanner.scan(/[^,;].*/)
+      if media = scanner.scan(/[a-zA-Z].*/)
         Tree::DirectiveNode.new("@import #{str || uri} #{media}")
+      elsif !scanner.match?(/[,;]|$/)
+        raise SyntaxError.new("Invalid @import: \"#{str || uri} #{scanner.rest}\"")
       elsif uri
         Tree::DirectiveNode.new("@import #{uri}")
       elsif val =~ /^http:\/\//

data/lib/sass/plugin/compiler.rb

@@ -5,6 +5,7 @@ require 'sass'
 require 'sass/callbacks'
 require 'sass/plugin/configuration'
 require 'sass/plugin/staleness_checker'
+require 'sass/plugin/listener'
 
 module Sass::Plugin
 
@@ -218,10 +219,10 @@ module Sass::Plugin
     #
     # Before the watching starts in earnest, `watch` calls \{#update\_stylesheets}.
     #
-    # Note that `watch` uses the [FSSM](http://github.com/ttilley/fssm) library
+    # Note that `watch` uses the [Listen](http://github.com/guard/listen) library
     # to monitor the filesystem for changes.
-    # FSSM isn't loaded until `watch` is run.
-    # The version of FSSM distributed with Sass is loaded by default,
+    # Listen isn't loaded until `watch` is run.
+    # The version of Listen distributed with Sass is loaded by default,
     # but if another version has already been loaded that will be used instead.
     #
     # @param individual_files [Array<(String, String)>]
@@ -234,15 +235,15 @@ module Sass::Plugin
       update_stylesheets(individual_files)
 
       begin
-        require 'fssm'
+        require 'listen'
       rescue LoadError => e
-        dir = Sass::Util.scope("vendor/fssm/lib")
+        dir = Sass::Util.scope("vendor/listen/lib")
         if $LOAD_PATH.include?(dir)
           e.message << "\n" <<
             if File.exists?(scope(".git"))
               'Run "git submodule update --init" to get the recommended version.'
             else
-              'Run "gem install fssm" to get it.'
+              'Run "gem install listen" to get it.'
             end
           raise e
         else
@@ -251,59 +252,51 @@ module Sass::Plugin
         end
       end
 
-      unless individual_files.empty? && FSSM::Backends::Default.name == "FSSM::Backends::FSEvents"
-        # As of FSSM 0.1.4, it doesn't support FSevents on individual files,
-        # but it also isn't smart enough to switch to polling itself.
-        require 'fssm/backends/polling'
-        Sass::Util.silence_warnings do
-          FSSM::Backends.const_set(:Default, FSSM::Backends::Polling)
-        end
-      end
-
       # TODO: Keep better track of what depends on what
       # so we don't have to run a global update every time anything changes.
-      FSSM.monitor do |mon|
+      Sass::Plugin::Listener.new do |l|
         template_location_array.each do |template_location, css_location|
-          mon.path template_location do |path|
-            path.glob '**/*.s[ac]ss'
-
-            path.update do |base, relative|
+          l.directory(template_location, {
+              :modified => lambda do |base, relative|
+              next if relative !~ /\.s[ac]ss$/
               run_template_modified File.join(base, relative)
               update_stylesheets(individual_files)
-            end
+            end,
 
-            path.create do |base, relative|
+            :added => lambda do |base, relative|
+              next if relative !~ /\.s[ac]ss$/
               run_template_created File.join(base, relative)
               update_stylesheets(individual_files)
-            end
+            end,
 
-            path.delete do |base, relative|
+            :removed => lambda do |base, relative|
+              next if relative !~ /\.s[ac]ss$/
               run_template_deleted File.join(base, relative)
               css = File.join(css_location, relative.gsub(/\.s[ac]ss$/, '.css'))
               try_delete_css css
               update_stylesheets(individual_files)
             end
-          end
+          })
         end
 
         individual_files.each do |template, css|
-          mon.file template do |path|
-            path.update do
+          l.file(template, {
+            :modified => lambda do
               run_template_modified template
               update_stylesheets(individual_files)
-            end
+            end,
 
-            path.create do
+            :added => lambda do
               run_template_created template
               update_stylesheets(individual_files)
-            end
+            end,
 
-            path.delete do
+            :removed => lambda do
               run_template_deleted template
               try_delete_css css
               update_stylesheets(individual_files)
             end
-          end
+          })
         end
       end
     end