sass 3.3.0.rc.1 → 3.3.0.rc.2

data/lib/sass/selector/sequence.rb

@@ -93,7 +93,7 @@ module Sass
           choices
         end
         weaves = Sass::Util.paths(extended_not_expanded).map {|path| weave(path)}
-        Sass::Util.flatten(trim(weaves), 1).map {|p| Sequence.new(p)}
+        trim(weaves).map {|p| Sequence.new(p)}
       end
 
       # Returns whether or not this selector matches all elements
@@ -137,32 +137,31 @@ module Sass
 
       private
 
-      # Conceptually, this expands "parenthesized selectors".
-      # That is, if we have `.A .B {@extend .C}` and `.D .C {...}`,
-      # this conceptually expands into `.D .C, .D (.A .B)`,
-      # and this function translates `.D (.A .B)` into `.D .A .B, .A.D .B, .D .A .B`.
+      # Conceptually, this expands "parenthesized selectors". That is, if we
+      # have `.A .B {@extend .C}` and `.D .C {...}`, this conceptually expands
+      # into `.D .C, .D (.A .B)`, and this function translates `.D (.A .B)` into
+      # `.D .A .B, .A .D .B`. For thoroughness, `.A.D .B` would also be
+      # required, but including merged selectors results in exponential output
+      # for very little gain.
       #
       # @param path [Array<Array<SimpleSequence or String>>]
       #   A list of parenthesized selector groups.
       # @return [Array<Array<SimpleSequence or String>>] A list of fully-expanded selectors.
       def weave(path)
         # This function works by moving through the selector path left-to-right,
-        # building all possible prefixes simultaneously. These prefixes are
-        # `befores`, while the remaining parenthesized suffixes is `afters`.
-        befores = [[]]
-        afters = path.dup
+        # building all possible prefixes simultaneously.
+        prefixes = [[]]
 
-        until afters.empty?
-          current = afters.shift.dup
+        path.each do |current|
+          current = current.dup
           last_current = [current.pop]
-          befores.map! do |before|
-            sub = subweave(before, current)
+          prefixes = Sass::Util.flatten(prefixes.map do |prefix|
+            sub = subweave(prefix, current)
             next [] unless sub
             sub.map {|seqs| seqs + last_current}
-          end
-          befores = Sass::Util.flatten(befores, 1)
+          end, 1)
         end
-        befores
+        prefixes
       end
 
       # This interweaves two lists of selectors,
@@ -455,11 +454,11 @@ module Sass
       # the other. The more specific selector is removed.
       #
       # @param seqses [Array<Array<Array<SimpleSequence or String>>>]
-      # @return [Array<Array<Array<SimpleSequence or String>>>]
+      # @return [Array<Array<SimpleSequence or String>>]
       def trim(seqses)
         # Avoid truly horrific quadratic behavior. TODO: I think there
         # may be a way to get perfect trimming without going quadratic.
-        return seqses if seqses.size > 100
+        return Sass::Util.flatten(seqses, 1) if seqses.size > 100
 
         # Keep the results in a separate array so we can be sure we aren't
         # comparing against an already-trimmed selector. This ensures that two
@@ -482,7 +481,7 @@ module Sass
             end
           end
         end
-        result
+        Sass::Util.flatten(result, 1)
       end
 
       def _hash

data/lib/sass/selector/simple_sequence.rb

@@ -107,18 +107,18 @@ module Sass
       #   by extending this selector with `extends`.
       # @see CommaSequence#do_extend
       def do_extend(extends, parent_directives, seen = Set.new)
-        groups = Sass::Util.group_by_to_a(extends.get(members.to_set)) {|ex, _| ex.extender}
+        groups = Sass::Util.group_by_to_a(extends[members.to_set]) {|ex| ex.extender}
         groups.map! do |seq, group|
-          sels = group.map {|_, s| s}.flatten
+          sels = group.map {|e| e.target}.flatten
           # If A {@extend B} and C {...},
           # seq is A, sels is B, and self is C
 
           self_without_sel = Sass::Util.array_minus(members, sels)
-          group.each {|e, _| e.result = :failed_to_unify unless e.result == :succeeded}
+          group.each {|e| e.result = :failed_to_unify unless e.result == :succeeded}
           unified = seq.members.last.unify(self_without_sel, subject?)
           next unless unified
-          group.each {|e, _| e.result = :succeeded}
-          group.each {|e, _| check_directives_match!(e, parent_directives)}
+          group.each {|e| e.result = :succeeded}
+          group.each {|e| check_directives_match!(e, parent_directives)}
           new_seq = Sequence.new(seq.members[0...-1] + [unified])
           new_seq.add_sources!(sources + [seq])
           [sels, new_seq]

data/lib/sass/source/map.rb

@@ -104,7 +104,7 @@ module Sass::Source
       css_uri ||= css_path.relative_path_from(sourcemap_path.dirname).to_s
 
       result = "{\n"
-      write_json_field(result, "version", "3", true)
+      write_json_field(result, "version", 3, true)
 
       source_uri_to_id = {}
       id_to_source_uri = {}

data/lib/sass/tree/node.rb

@@ -30,6 +30,31 @@ module Sass
     class Node
       include Enumerable
 
+      def self.inherited(base)
+        node_name = base.name.gsub(/.*::(.*?)Node$/, '\\1').downcase
+        base.instance_eval <<-METHODS
+          # @return [Symbol] The name that is used for this node when visiting.
+          def node_name
+            :#{node_name}
+          end
+
+          # @return [Symbol] The method that is used on the visitor to visit nodes of this type.
+          def visit_method
+            :visit_#{node_name}
+          end
+
+          # @return [Symbol] The method name that determines if the parent is invalid.
+          def invalid_child_method_name
+            :"invalid_#{node_name}_child?"
+          end
+
+          # @return [Symbol] The method name that determines if the node is an invalid parent.
+          def invalid_parent_method_name
+            :"invalid_#{node_name}_parent?"
+          end
+        METHODS
+      end
+
       # The child nodes of this node.
       #
       # @return [Array<Tree::Node>]

data/lib/sass/tree/variable_node.rb

@@ -20,6 +20,11 @@ module Sass
       # @return [Boolean]
       attr_reader :global
 
+      # Whether we've warned about deprecated global variable
+      # assignment yet for this node.
+      # @return [Boolean]
+      attr_accessor :global_warning_given
+
       # @param name [String] The name of the variable
       # @param expr [Script::Tree::Node] See \{#expr}
       # @param guarded [Boolean] See \{#guarded}

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

@@ -32,9 +32,8 @@ module Sass::Tree::Visitors
     # @param node [Tree::Node] The node to visit.
     # @return [Object] The return value of the `visit_*` method for this node.
     def visit(node)
-      method = "visit_#{self.class.node_name node}"
-      if respond_to?(method, true)
-        send(method, node) {visit_children(node)}
+      if respond_to?(node.class.visit_method, true)
+        send(node.class.visit_method, node) {visit_children(node)}
       else
         visit_children(node)
       end
@@ -53,15 +52,13 @@ module Sass::Tree::Visitors
       parent.children.map {|c| visit(c)}
     end
 
-    NODE_NAME_RE = /.*::(.*?)Node$/
-
     # Returns the name of a node as used in the `visit_*` method.
     #
     # @param [Tree::Node] node The node.
     # @return [String] The name.
     def self.node_name(node)
-      @node_names ||= {}
-      @node_names[node.class.name] ||= node.class.name.gsub(NODE_NAME_RE, '\\1').downcase
+      Sass::Util.deprecated(self, "Call node.class.node_name instead.")
+      node.class.node_name
     end
 
     # `yield`s, then runs the visitor on the `@else` clause if the node has one.

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

@@ -9,8 +9,8 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
 
   def visit(node)
     if (error = @parent && (
-        try_send("invalid_#{self.class.node_name @parent}_child?", @parent, node) ||
-        try_send("invalid_#{self.class.node_name node}_parent?", @parent, node)))
+        try_send(@parent.class.invalid_child_method_name, @parent, node) ||
+        try_send(node.class.invalid_parent_method_name, @parent, node)))
       raise Sass::SyntaxError.new(error)
     end
     super

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

@@ -99,7 +99,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     # @api private
     # @return [Sass::Script::Value::ArgList]
     def perform_splat(splat, performed_keywords, kwarg_splat, environment)
-      args, kwargs, separator = [], Sass::Util.ordered_hash, :comma
+      args, kwargs, separator = [], nil, :comma
 
       if splat
         splat = splat.perform(environment)
@@ -113,8 +113,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
           args = splat.to_a
         end
       end
-
-      kwargs = kwargs.merge(performed_keywords)
+      kwargs ||= Sass::Util.ordered_hash
+      kwargs.update(performed_keywords)
 
       if kwarg_splat
         kwarg_splat = kwarg_splat.perform(environment)
@@ -122,7 +122,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
           raise Sass::SyntaxError.new("Variable keyword arguments must be a map " +
                                       "(was #{kwarg_splat.inspect}).")
         end
-        kwargs = kwargs.merge(arg_hash(kwarg_splat))
+        kwargs.update(arg_hash(kwarg_splat))
       end
 
       Sass::Script::Value::ArgList.new(args, kwargs, separator)
@@ -195,7 +195,11 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Prints the expression to STDERR.
   def visit_debug(node)
     res = node.expr.perform(@environment)
-    res = res.value if res.is_a?(Sass::Script::Value::String)
+    if res.is_a?(Sass::Script::Value::String)
+      res = res.value
+    else
+      res = res.to_sass
+    end
     if node.filename
       Sass::Util.sass_warn "#{node.filename}:#{node.line} DEBUG: #{res}"
     else
@@ -325,7 +329,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       end
 
       args = node.args.map {|a| a.perform(@environment)}
-      keywords = Sass::Util.map_hash(node.keywords) {|k, v| [k, v.perform(@environment)]}
+      keywords = Sass::Util.map_vals(node.keywords) {|v| v.perform(@environment)}
       splat = self.class.perform_splat(node.splat, keywords, node.kwarg_splat, @environment)
 
       self.class.perform_arguments(mixin, args, splat) do |env|
@@ -419,7 +423,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     env = @environment
     if node.global
       env = env.global_env
-    elsif env.parent && env.is_var_global?(node.name)
+    elsif env.parent && env.is_var_global?(node.name) && !node.global_warning_given
+      node.global_warning_given = true
       var_expr = "$#{node.name}: #{node.expr.to_sass(env.options)} !global"
       var_expr << " !default" if node.guarded
       location = "on line #{node.line}"

data/lib/sass/util.rb

@@ -31,36 +31,6 @@ module Sass
       File.join(Sass::ROOT_DIR, file)
     end
 
-    # Converts a hash or a list of pairs into an order-preserving hash.
-    #
-    # On Ruby 1.8.7, this uses the orderedhash gem to simulate an
-    # order-preserving hash. On Ruby 1.9 and up, it just uses the native Hash
-    # class, since that preserves the order itself.
-    #
-    # @overload ordered_hash(hash)
-    #   @param hash [Hash] a normal hash to convert to an ordered hash
-    #   @return [Hash]
-    # @overload ordered_hash(*pairs)
-    #   @example
-    #     ordered_hash([:foo, "bar"], [:baz, "bang"])
-    #       #=> {:foo => "bar", :baz => "bang"}
-    #     ordered_hash #=> {}
-    #   @param pairs [Array<(Object, Object)>] the list of key/value pairs for
-    #     the hash.
-    #   @return [Hash]
-    def ordered_hash(*pairs_or_hash)
-      require 'sass/util/ordered_hash' if ruby1_8?
-
-      if pairs_or_hash.length == 1 && pairs_or_hash.first.is_a?(Hash)
-        hash = pairs_or_hash.first
-        return hash unless ruby1_8?
-        return OrderedHash.new.merge hash
-      end
-
-      return Hash[pairs_or_hash] unless ruby1_8?
-      OrderedHash[*flatten(pairs_or_hash, 1)]
-    end
-
     # Converts an array of `[key, value]` pairs to a hash.
     #
     # @example
@@ -85,7 +55,7 @@ module Sass
     # @see #map_vals
     # @see #map_hash
     def map_keys(hash)
-      to_hash(hash.map {|k, v| [yield(k), v]})
+      map_hash(hash) {|k, v| [yield(k), v]}
     end
 
     # Maps the values in a hash according to a block.
@@ -101,7 +71,13 @@ module Sass
     # @see #map_keys
     # @see #map_hash
     def map_vals(hash)
-      to_hash(hash.map {|k, v| [k, yield(v)]})
+      # We don't delegate to map_hash for performance here
+      # because map_hash does more than is necessary.
+      rv = hash.class.new
+      hash.each do |k, v|
+        rv[k] = yield(v)
+      end
+      rv
     end
 
     # Maps the key-value pairs of a hash according to a block.
@@ -118,8 +94,15 @@ module Sass
     # @see #map_keys
     # @see #map_vals
     def map_hash(hash)
-      # Using &block here completely hoses performance on 1.8.
-      to_hash(hash.map {|k, v| yield k, v})
+      # Copy and modify is more performant than mapping to an array and using
+      # to_hash on the result.
+      rv = hash.class.new
+      hash.each do |k, v|
+        new_key, new_value = yield(k, v)
+        rv.delete(k)
+        rv[new_key] = new_value
+      end
+      rv
     end
 
     # Computes the powerset of the given array.
@@ -272,12 +255,12 @@ module Sass
     #
     # @param enum [Enumerable]
     # @return [Array<[Object, Array]>] An array of pairs.
-    def group_by_to_a(enum, &block)
-      return enum.group_by(&block).to_a unless ruby1_8?
+    def group_by_to_a(enum)
+      return enum.group_by {|e| yield(e)}.to_a unless ruby1_8?
       order = {}
       arr = []
       groups = enum.group_by do |e|
-        res = block[e]
+        res = yield(e)
         unless order.include?(res)
           order[res] = order.size
         end
@@ -415,6 +398,17 @@ module Sass
       raise NotImplementedError.new("#{obj.class} must implement ##{caller_info[2]}")
     end
 
+    # Prints a deprecation warning for the caller method.
+    #
+    # @param obj [Object] `self`
+    # @param message [String] A message describing what to do instead.
+    def deprecated(obj, message = nil)
+      obj_class = obj.is_a?(Class) ? "#{obj}." : "#{obj.class}#"
+      full_message = "DEPRECATION WARNING: #{obj_class}#{caller_info[2]} " +
+        "will be removed in a future version of Sass.#{("\n" + message) if message}"
+      Sass::Util.sass_warn full_message
+    end
+
     # Silence all output to STDERR within a block.
     #
     # @yield A block in which no output will be printed to STDERR
@@ -507,33 +501,40 @@ module Sass
     end
 
     ## Cross-OS Compatibility
+    #
+    # These methods are cached because some of them are called quite frequently
+    # and even basic checks like String#== are too costly to be called repeatedly.
 
     # Whether or not this is running on Windows.
     #
     # @return [Boolean]
     def windows?
-      RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i
+      return @windows if defined?(@windows)
+      @windows = (RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i)
     end
 
     # Whether or not this is running on IronRuby.
     #
     # @return [Boolean]
     def ironruby?
-      RUBY_ENGINE == "ironruby"
+      return @ironruby if defined?(@ironruby)
+      @ironruby = RUBY_ENGINE == "ironruby"
     end
 
     # Whether or not this is running on Rubinius.
     #
     # @return [Boolean]
     def rbx?
-      RUBY_ENGINE == "rbx"
+      return @rbx if defined?(@rbx)
+      @rbx = RUBY_ENGINE == "rbx"
     end
 
     # Whether or not this is running on JRuby.
     #
     # @return [Boolean]
     def jruby?
-      RUBY_PLATFORM =~ /java/
+      return @jruby if defined?(@jruby)
+      @jruby = RUBY_PLATFORM =~ /java/
     end
 
     # @see #jruby_version-class_method
@@ -551,9 +552,13 @@ module Sass
     # Like `Dir.glob`, but works with backslash-separated paths on Windows.
     #
     # @param path [String]
-    def glob(path, &block)
+    def glob(path)
       path = path.gsub('\\', '/') if windows?
-      Dir.glob(path, &block)
+      if block_given?
+        Dir.glob(path) {|f| yield(f)}
+      else
+        Dir.glob(path)
+      end
     end
 
     # Prepare a value for a destructuring assignment (e.g. `a, b =
@@ -575,7 +580,8 @@ module Sass
     #
     # @return [Boolean]
     def ruby1?
-      Sass::Util::RUBY_VERSION[0] <= 1
+      return @ruby1 if defined?(@ruby1)
+      @ruby1 = Sass::Util::RUBY_VERSION[0] <= 1
     end
 
     # Whether or not this is running under Ruby 1.8 or lower.
@@ -587,7 +593,9 @@ module Sass
     def ruby1_8?
       # IronRuby says its version is 1.9, but doesn't support any of the encoding APIs.
       # We have to fall back to 1.8 behavior.
-      ironruby? || (Sass::Util::RUBY_VERSION[0] == 1 && Sass::Util::RUBY_VERSION[1] < 9)
+      return @ruby1_8 if defined?(@ruby1_8)
+      @ruby1_8 = ironruby? ||
+                   (Sass::Util::RUBY_VERSION[0] == 1 && Sass::Util::RUBY_VERSION[1] < 9)
     end
 
     # Whether or not this is running under Ruby 1.8.6 or lower.
@@ -595,21 +603,55 @@ module Sass
     #
     # @return [Boolean]
     def ruby1_8_6?
-      ruby1_8? && Sass::Util::RUBY_VERSION[2] < 7
+      return @ruby1_8_6 if defined?(@ruby1_8_6)
+      @ruby1_8_6 = ruby1_8? && Sass::Util::RUBY_VERSION[2] < 7
     end
 
     # Wehter or not this is running under JRuby 1.6 or lower.
     def jruby1_6?
-      jruby? && jruby_version[0] == 1 && jruby_version[1] < 7
+      return @jruby1_6 if defined?(@jruby1_6)
+      @jruby1_6 = jruby? && jruby_version[0] == 1 && jruby_version[1] < 7
     end
 
     # Whether or not this is running under MacRuby.
     #
     # @return [Boolean]
     def macruby?
-      RUBY_ENGINE == 'macruby'
+      return @macruby if defined?(@macruby)
+      @macruby = RUBY_ENGINE == 'macruby'
     end
 
+    require 'sass/util/ordered_hash' if ruby1_8?
+
+    # Converts a hash or a list of pairs into an order-preserving hash.
+    #
+    # On Ruby 1.8.7, this uses the orderedhash gem to simulate an
+    # order-preserving hash. On Ruby 1.9 and up, it just uses the native Hash
+    # class, since that preserves the order itself.
+    #
+    # @overload ordered_hash(hash)
+    #   @param hash [Hash] a normal hash to convert to an ordered hash
+    #   @return [Hash]
+    # @overload ordered_hash(*pairs)
+    #   @example
+    #     ordered_hash([:foo, "bar"], [:baz, "bang"])
+    #       #=> {:foo => "bar", :baz => "bang"}
+    #     ordered_hash #=> {}
+    #   @param pairs [Array<(Object, Object)>] the list of key/value pairs for
+    #     the hash.
+    #   @return [Hash]
+    def ordered_hash(*pairs_or_hash)
+      if pairs_or_hash.length == 1 && pairs_or_hash.first.is_a?(Hash)
+        hash = pairs_or_hash.first
+        return hash unless ruby1_8?
+        return OrderedHash.new.merge hash
+      end
+
+      return Hash[pairs_or_hash] unless ruby1_8?
+      (pairs_or_hash.is_a?(NormalizedMap) ? NormalizedMap : OrderedHash)[*flatten(pairs_or_hash, 1)]
+    end
+
+
     # Checks that the encoding of a string is valid in Ruby 1.9
     # and cleans up potential encoding gotchas like the UTF-8 BOM.
     # If it's not, yields an error string describing the invalid character
@@ -1011,8 +1053,8 @@ MSG
       #
       # @param name [Symbol] The name of the variable
       # @return [Boolean]
-      def method_missing(name, *args, &block)
-        super unless args.empty? && block.nil?
+      def method_missing(name, *args)
+        super unless args.empty? && !block_given?
         @set.include?(name)
       end
     end
@@ -1053,6 +1095,7 @@ MSG
     # Calculates the memoization table for the Least Common Subsequence algorithm.
     # Algorithm from [Wikipedia](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Computing_the_length_of_the_LCS)
     def lcs_table(x, y)
+      # This method does not take a block as an explicit parameter for performance reasons.
       # rubocop:enable LineLength
       c = Array.new(x.size) {[]}
       x.size.times {|i| c[i][0] = 0}
@@ -1085,6 +1128,8 @@ MSG
       return lcs_backtrace(c, x, y, i, j - 1, &block) if c[i][j - 1] > c[i - 1][j]
       lcs_backtrace(c, x, y, i - 1, j, &block)
     end
+
+    (Sass::Util.methods - Module.methods).each {|method| module_function method}
   end
 end