sass 3.2.0.alpha.74 → 3.2.0.alpha.75

data/REVISION

@@ -1 +1 @@
-db51415a323a4fc284f38881ac839f3bbf5e7e31
+b551f92303175e7651794dcf5a70f6148042bf69

data/VERSION

@@ -1 +1 @@
-3.2.0.alpha.74
+3.2.0.alpha.75

data/lib/sass/css.rb

@@ -77,14 +77,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
@@ -102,13 +117,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
@@ -116,22 +132,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
@@ -144,28 +145,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
@@ -176,32 +180,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
@@ -238,7 +267,7 @@ module Sass
       end
     end
 
-    # Flattens a single rule
+    # Flattens a single rule.
     #
     # @param rule [Tree::RuleNode] The candidate for flattening
     # @see #flatten_rules
@@ -246,10 +275,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
@@ -282,7 +311,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
 
@@ -292,5 +321,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/scss/parser.rb

@@ -835,11 +835,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

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.
       #
@@ -64,6 +65,14 @@ module Sass
         @has_placeholder ||=
           members.any? {|m| m.is_a?(AbstractSequence) ? m.has_placeholder? : m.is_a?(Placeholder)}
       end
+
+      # 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/node.rb

@@ -159,9 +159,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

@@ -143,9 +143,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/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.
@@ -211,11 +212,11 @@ module Sass
     # @yieldreturn [Object, nil] If the two values register as equal,
     #   this will return the value to use in the LCS array.
     # @return [Array] The LCS
-    def lcs(x, y, &block)
+    def lcs(x, y)
       x = [nil, *x]
       y = [nil, *y]
       block ||= proc {|a, b| a == b && a}
-      lcs_backtrace(lcs_table(x, y, &block), x, y, x.size-1, y.size-1, &block)
+      lcs_backtrace(lcs_table(x, y) {|a, b| yield a, b}, x, y, x.size-1, y.size-1) {|a, b| yield a, b}
     end
 
     # Converts a Hash to an Array. This is usually identical to `Hash#to_a`,
@@ -762,14 +763,14 @@ MSG
 
     # Computes a single longest common subsequence for arrays x and y.
     # Algorithm from [Wikipedia](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Reading_out_an_LCS)
-    def lcs_backtrace(c, x, y, i, j, &block)
+    def lcs_backtrace(c, x, y, i, j)
       return [] if i == 0 || j == 0
       if v = yield(x[i], y[j])
-        return lcs_backtrace(c, x, y, i-1, j-1, &block) << v
+        return lcs_backtrace(c, x, y, i-1, j-1) {|a, b| yield a, b} << v
       end
 
-      return lcs_backtrace(c, x, y, i, j-1, &block) if c[i][j-1] > c[i-1][j]
-      return lcs_backtrace(c, x, y, i-1, j, &block)
+      return lcs_backtrace(c, x, y, i, j-1) {|a, b| yield a, b} if c[i][j-1] > c[i-1][j]
+      return lcs_backtrace(c, x, y, i-1, j) {|a, b| yield a, b}
     end
   end
 end

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

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  hash: 592302985
+  hash: 592302987
   prerelease: 6
   segments: 
   - 3
   - 2
   - 0
   - alpha
-  - 74
-  version: 3.2.0.alpha.74
+  - 75
+  version: 3.2.0.alpha.75
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -86,7 +86,7 @@ files:
 - lib/sass/logger.rb
 - lib/sass/logger/base.rb
 - lib/sass/logger/log_level.rb
-- lib/sass/media.rb
+- lib/sass/util.rb
 - lib/sass/plugin.rb
 - lib/sass/plugin/compiler.rb
 - lib/sass/plugin/configuration.rb
@@ -151,6 +151,7 @@ files:
 - lib/sass/tree/root_node.rb
 - lib/sass/tree/rule_node.rb
 - lib/sass/tree/content_node.rb
+- lib/sass/tree/trace_node.rb
 - lib/sass/tree/variable_node.rb
 - lib/sass/tree/visitors/base.rb
 - lib/sass/tree/visitors/check_nesting.rb
@@ -162,8 +163,7 @@ files:
 - lib/sass/tree/visitors/to_css.rb
 - lib/sass/tree/warn_node.rb
 - lib/sass/tree/while_node.rb
-- lib/sass/tree/trace_node.rb
-- lib/sass/util.rb
+- lib/sass/media.rb
 - lib/sass/util/multibyte_string_scanner.rb
 - lib/sass/util/subset_map.rb
 - lib/sass/version.rb