sass 3.3.0.alpha.256 → 3.3.0.alpha.353

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

@@ -63,7 +63,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       @offset -= chars
     end
   end
-  
+
   # Avoid allocating lots of new strings for `#output`. This is important
   # because `#output` is called all the time.
   NEWLINE = "\n"
@@ -157,11 +157,17 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     spaces = ('  ' * [@tabs - node.resolved_value[/^ */].size, 0].max)
 
     content = node.resolved_value.gsub(/^/, spaces)
-    content.gsub!(%r{^(\s*)//(.*)$}) {|md| "#{$1}/*#{$2} */"} if node.type == :silent
-    content.gsub!(/\n +(\* *(?!\/))?/, ' ') if (node.style == :compact || node.style == :compressed) && node.type != :loud
+    if node.type == :silent
+      content.gsub!(%r{^(\s*)//(.*)$}) {|md| "#{$1}/*#{$2} */"}
+    end
+    if (node.style == :compact || node.style == :compressed) && node.type != :loud
+      content.gsub!(/\n +(\* *(?!\/))?/, ' ')
+    end
     for_node(node) {output(content)}
   end
 
+  # @comment
+  #   rubocop:disable MethodLength
   def visit_directive(node)
     was_in_directive = @in_directive
     tab_str = '  ' * @tabs
@@ -224,6 +230,8 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
   ensure
     @in_directive = was_in_directive
   end
+  # @comment
+  #   rubocop:enable MethodLength
 
   def visit_media(node)
     with_tabs(@tabs + node.tabs) {visit_directive(node)}
@@ -244,7 +252,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     output(tab_str)
     for_node(node, :name) {output(node.resolved_name)}
     if node.style == :compressed
-      output(":");
+      output(":")
       for_node(node, :value) {output(node.resolved_value)}
     else
       output(": ")
@@ -253,17 +261,23 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     end
   end
 
+  # @comment
+  #   rubocop:disable MethodLength
   def visit_rule(node)
     with_tabs(@tabs + node.tabs) do
       rule_separator = node.style == :compressed ? ',' : ', '
       line_separator =
         case node.style
-          when :nested, :expanded; "\n"
-          when :compressed; ""
-          else; " "
+        when :nested, :expanded; "\n"
+        when :compressed; ""
+        else; " "
         end
       rule_indent = '  ' * @tabs
-      per_rule_indent, total_indent = [:nested, :expanded].include?(node.style) ? [rule_indent, ''] : ['', rule_indent]
+      per_rule_indent, total_indent = if [:nested, :expanded].include?(node.style)
+                                        [rule_indent, '']
+                                      else
+                                        ['', rule_indent]
+                                      end
 
       joined_rules = node.resolved_rules.members.map do |seq|
         next if seq.has_placeholder?
@@ -293,13 +307,13 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
           if node.filename
             relative_filename = if node.options[:css_filename]
-              begin
-                Pathname.new(node.filename).relative_path_from(
-                  Pathname.new(File.dirname(node.options[:css_filename]))).to_s
-              rescue ArgumentError
-                nil
-              end
-            end
+                                  begin
+                                    Pathname.new(node.filename).relative_path_from(
+                                      Pathname.new(File.dirname(node.options[:css_filename]))).to_s
+                                  rescue ArgumentError
+                                    nil
+                                  end
+                                end
             relative_filename ||= node.filename
             output(", #{relative_filename}")
           end
@@ -335,6 +349,8 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       output("}" + trailer)
     end
   end
+  # @comment
+  #   rubocop:enable MethodLength
 
   private
 
@@ -355,7 +371,9 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       rule << prop
       node << rule
     end
-    node.options = options.merge(:debug_info => false, :line_comments => false, :style => :compressed)
+    node.options = options.merge(:debug_info => false,
+                                 :line_comments => false,
+                                 :style => :compressed)
     node
   end
 end

data/lib/sass/util.rb

@@ -4,6 +4,7 @@ require 'enumerator'
 require 'stringio'
 require 'rbconfig'
 require 'uri'
+require 'thread'
 
 require 'sass/root'
 require 'sass/util/subset_map'
@@ -57,7 +58,7 @@ module Sass
       end
 
       return Hash[pairs_or_hash] unless ruby1_8?
-      return OrderedHash[*flatten(pairs_or_hash, 1)]
+      OrderedHash[*flatten(pairs_or_hash, 1)]
     end
 
     # Converts an array of `[key, value]` pairs to a hash.
@@ -195,8 +196,8 @@ module Sass
       res = ary.dup
       i = 0
       while i < res.size
-        if res[i...i+from.size] == from
-          res[i...i+from.size] = to
+        if res[i...i + from.size] == from
+          res[i...i + from.size] = to
         end
         i += 1
       end
@@ -247,7 +248,7 @@ module Sass
       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, &block), x, y, x.size - 1, y.size - 1, &block)
     end
 
     # Converts a Hash to an Array. This is usually identical to `Hash#to_a`,
@@ -261,7 +262,7 @@ module Sass
     # @return [Array]
     def hash_to_a(hash)
       return hash.to_a unless ruby1_8? || defined?(Test::Unit)
-      return hash.sort_by {|k, v| k}
+      hash.sort_by {|k, v| k}
     end
 
     # Performs the equivalent of `enum.group_by.to_a`, but with a guaranteed
@@ -275,13 +276,14 @@ module Sass
       return enum.group_by(&block).to_a unless ruby1_8?
       order = {}
       arr = []
-      enum.group_by do |e|
+      groups = enum.group_by do |e|
         res = block[e]
         unless order.include?(res)
           order[res] = order.size
         end
         res
-      end.each do |key, vals|
+      end
+      groups.each do |key, vals|
         arr[order[key]] = [key, vals]
       end
       arr
@@ -311,7 +313,7 @@ module Sass
       # JRuby (as of 1.7.2) doesn't have an error_char field on
       # Encoding::UndefinedConversionError.
       return e.error_char.dump unless jruby?
-      e.message[/^"[^"]+"/] #"
+      e.message[/^"[^"]+"/] # "
     end
 
     # Asserts that `value` falls within `range` (inclusive), leaving
@@ -323,7 +325,7 @@ module Sass
     # @param unit [String] The unit of the value. Used in error reporting.
     # @return [Numeric] `value` adjusted to fall within range, if it
     #   was outside by a floating-point margin.
-    def check_range(name, range, value, unit='')
+    def check_range(name, range, value, unit = '')
       grace = (-0.00001..0.00001)
       str = value.to_s
       value = value.value if value.is_a?(Sass::Script::Value::Number)
@@ -354,7 +356,8 @@ module Sass
     # Returns information about the caller of the previous method.
     #
     # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
-    # @return [[String, Fixnum, (String, nil)]] An array containing the filename, line, and method name of the caller.
+    # @return [[String, Fixnum, (String, nil)]]
+    #   An array containing the filename, line, and method name of the caller.
     #   The method name may be nil
     def caller_info(entry = nil)
       # JRuby evaluates `caller` incorrectly when it's in an actual default argument.
@@ -422,7 +425,6 @@ module Sass
       $stderr = the_real_stderr
     end
 
-    @@silence_warnings = false
     # Silences all Sass warnings within a block.
     #
     # @yield A block in which no Sass warnings will be printed
@@ -454,7 +456,7 @@ module Sass
         raise "ERROR: Rails.root is nil!"
       end
       return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
-      return nil
+      nil
     end
 
     # Returns the environment of the Rails application,
@@ -465,7 +467,7 @@ module Sass
     def rails_env
       return ::Rails.env.to_s if defined?(::Rails.env)
       return RAILS_ENV.to_s if defined?(RAILS_ENV)
-      return nil
+      nil
     end
 
     # Returns whether this environment is using ActionPack
@@ -501,7 +503,7 @@ module Sass
     #   or `ActionView::Template::Error`.
     def av_template_class(name)
       return ActionView.const_get("Template#{name}") if ActionView.const_defined?("Template#{name}")
-      return ActionView::Template.const_get(name.to_s)
+      ActionView::Template.const_get(name.to_s)
     end
 
     ## Cross-OS Compatibility
@@ -534,11 +536,16 @@ module Sass
       RUBY_PLATFORM =~ /java/
     end
 
+    # @see #jruby_version-class_method
+    def jruby_version
+      Sass::Util.jruby_version
+    end
+
     # Returns an array of ints representing the JRuby version number.
     #
     # @return [Array<Fixnum>]
-    def jruby_version
-      $jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
+    def self.jruby_version
+      @jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
     end
 
     # Like `Dir.glob`, but works with backslash-separated paths on Windows.
@@ -636,7 +643,7 @@ Invalid #{encoding.name} character #{undefined_conversion_error_char(e)}
 MSG
         end
       end
-      return str
+      str
     end
 
     # Like {\#check\_encoding}, but also checks for a `@charset` declaration
@@ -669,7 +676,7 @@ MSG
       charset, bom = $1, $2
       if charset
         charset = charset.force_encoding(encoding).encode("UTF-8")
-        if endianness = encoding[/[BL]E$/]
+        if (endianness = encoding[/[BL]E$/])
           begin
             Encoding.find(charset + endianness)
             charset << endianness
@@ -816,8 +823,9 @@ MSG
       set1.to_a.uniq.sort_by {|e| e.hash}.eql?(set2.to_a.uniq.sort_by {|e| e.hash})
     end
 
-    # Like `Object#inspect`, but preserves non-ASCII characters rather than escaping them under Ruby 1.9.2.
-    # This is necessary so that the precompiled Haml template can be `#encode`d into `@options[:encoding]`
+    # Like `Object#inspect`, but preserves non-ASCII characters rather than
+    # escaping them under Ruby 1.9.2.  This is necessary so that the
+    # precompiled Haml template can be `#encode`d into `@options[:encoding]`
     # before being evaluated.
     #
     # @param obj {Object}
@@ -843,11 +851,12 @@ MSG
     # @return [(String, Array)] The resulting string, and an array of extracted values.
     def extract_values(arr)
       values = []
-      return arr.map do |e|
+      mapped = arr.map do |e|
         next e.gsub('{', '{{') if e.is_a?(String)
         values << e
         next "{#{values.count - 1}}"
-      end.join, values
+      end
+      return mapped.join, values
     end
 
     # Undoes \{#extract\_values} by transforming a string with escape sequences
@@ -962,7 +971,7 @@ MSG
         value <<= 1
       end
 
-      result = String.new
+      result = ''
       begin
         digit = value & VLQ_BASE_MASK
         value >>= VLQ_BASE_SHIFT
@@ -974,6 +983,21 @@ MSG
       result
     end
 
+    # This is a hack around the fact that you can't instantiate a URI parser on
+    # 1.8, so we have to have this hacky stuff to work around it. When 1.8
+    # support is dropped, we can remove this method.
+    #
+    # @private
+    URI_ESCAPE = URI.const_defined?("DEFAULT_PARSER") ? URI::DEFAULT_PARSER : URI
+
+    # URI-escape `string`.
+    #
+    # @param string [String]
+    # @return [String]
+    def escape_uri(string)
+      URI_ESCAPE.escape string
+    end
+
     ## Static Method Stuff
 
     # The context in which the ERB for \{#def\_static\_method} will be run.
@@ -993,20 +1017,43 @@ MSG
       end
     end
 
-
-    URI_ESCAPE = URI.const_defined?(:DEFAULT_PARSER) ?
-                   URI::DEFAULT_PARSER :
-                   URI
-
-    def escape_uri(uri)
-      URI_ESCAPE.escape uri
+    # @private
+    ATOMIC_WRITE_MUTEX = Mutex.new
+
+    # This creates a temp file and yields it for writing. When the
+    # write is complete, the file is moved into the desired location.
+    # The atomicity of this operation is provided by the filesystem's
+    # rename operation.
+    #
+    # @param filename [String] The file to write to.
+    # @yieldparam tmpfile [Tempfile] The temp file that can be written to.
+    # @return The value returned by the block.
+    def atomic_create_and_write_file(filename)
+      require 'tempfile'
+      tmpfile = Tempfile.new(File.basename(filename), File.dirname(filename))
+      tmpfile.binmode if tmpfile.respond_to?(:binmode)
+      result = yield tmpfile
+      tmpfile.close
+      ATOMIC_WRITE_MUTEX.synchronize do
+        File.rename tmpfile.path, filename
+      end
+      result
+    ensure
+      # close and remove the tempfile if it still exists,
+      # presumably due to an error during write
+      tmpfile.close if tmpfile
+      tmpfile.unlink if tmpfile
     end
 
     private
 
+    # rubocop:disable LineLength
+
+
     # 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)
+      # rubocop:enable LineLength
       c = Array.new(x.size) {[]}
       x.size.times {|i| c[i][0] = 0}
       y.size.times {|j| c[0][j] = 0}
@@ -1014,25 +1061,29 @@ MSG
         (1...y.size).each do |j|
           c[i][j] =
             if yield x[i], y[j]
-              c[i-1][j-1] + 1
+              c[i - 1][j - 1] + 1
             else
-              [c[i][j-1], c[i-1][j]].max
+              [c[i][j - 1], c[i - 1][j]].max
             end
         end
       end
-      return c
+      c
     end
 
+    # rubocop:disable ParameterLists, LineLength
+
+
     # 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)
+      # rubocop:enable ParameterList, LineLengths
       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
+      if (v = yield(x[i], y[j]))
+        return lcs_backtrace(c, x, y, i - 1, j - 1, &block) << 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, &block) if c[i][j - 1] > c[i - 1][j]
+      lcs_backtrace(c, x, y, i - 1, j, &block)
     end
   end
 end

data/lib/sass/util/multibyte_string_scanner.rb

@@ -1,7 +1,9 @@
 require 'strscan'
 
 if Sass::Util.ruby1_8?
+  # rubocop:disable ConstantName
   Sass::Util::MultibyteStringScanner = StringScanner
+  # rubocop:enable ConstantName
 else
   if Sass::Util.rbx?
     # Rubinius's StringScanner class implements some of its methods in terms of

data/lib/sass/util/ordered_hash.rb

@@ -1,5 +1,5 @@
 # Copyright (c) 2005-2013 David Heinemeier Hansson
-# 
+#
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
@@ -7,10 +7,10 @@
 # distribute, sublicense, and/or sell copies of the Software, and to
 # permit persons to whom the Software is furnished to do so, subject to
 # the following conditions:
-# 
+#
 # The above copyright notice and this permission notice shall be
 # included in all copies or substantial portions of the Software.
-# 
+#
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -39,21 +39,21 @@ class OrderedHash < ::Hash
   def self.[](*args)
     ordered_hash = new
 
-    if (args.length == 1 && args.first.is_a?(Array))
+    if args.length == 1 && args.first.is_a?(Array)
       args.first.each do |key_value_pair|
-        next unless (key_value_pair.is_a?(Array))
+        next unless key_value_pair.is_a?(Array)
         ordered_hash[key_value_pair[0]] = key_value_pair[1]
       end
 
       return ordered_hash
     end
 
-    unless (args.size % 2 == 0)
+    unless args.size.even?
       raise ArgumentError.new("odd number of arguments for Hash")
     end
 
     args.each_with_index do |val, ind|
-      next if (ind % 2 != 0)
+      next if ind.odd?
       ordered_hash[val] = args[ind + 1]
     end
 
@@ -100,7 +100,7 @@ class OrderedHash < ::Hash
   end
 
   def values
-    @keys.collect { |key| self[key] }
+    @keys.map {|key| self[key]}
   end
 
   def to_hash
@@ -108,18 +108,18 @@ class OrderedHash < ::Hash
   end
 
   def to_a
-    @keys.map { |key| [ key, self[key] ] }
+    @keys.map {|key| [key, self[key]]}
   end
 
   def each_key
     return to_enum(:each_key) unless block_given?
-    @keys.each { |key| yield key }
+    @keys.each {|key| yield key}
     self
   end
 
   def each_value
     return to_enum(:each_value) unless block_given?
-    @keys.each { |key| yield self[key]}
+    @keys.each {|key| yield self[key]}
     self
   end
 
@@ -151,9 +151,9 @@ class OrderedHash < ::Hash
 
   def merge!(other_hash)
     if block_given?
-      other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
+      other_hash.each {|k, v| self[k] = key?(k) ? yield(k, self[k], v) : v}
     else
-      other_hash.each { |k, v| self[k] = v }
+      other_hash.each {|k, v| self[k] = v}
     end
     self
   end
@@ -164,7 +164,8 @@ class OrderedHash < ::Hash
     dup.merge!(other_hash, &block)
   end
 
-  # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+  # When replacing with another hash, the initial order of our keys must come from the other hash --
+  # ordered or not.
   def replace(other)
     super
     @keys = other.keys
@@ -172,7 +173,7 @@ class OrderedHash < ::Hash
   end
 
   def invert
-    OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
+    OrderedHash[to_a.map! {|key_value_pair| key_value_pair.reverse}]
   end
 
   def inspect
@@ -180,7 +181,8 @@ class OrderedHash < ::Hash
   end
 
   private
-    def sync_keys!
-      @keys.delete_if {|k| !has_key?(k)}
-    end
+
+  def sync_keys!
+    @keys.delete_if {|k| !has_key?(k)}
+  end
 end