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

data/lib/sass/util/subset_map.rb

@@ -72,7 +72,8 @@ module Sass
       # @see #[]
       def get(set)
         res = set.map do |k|
-          next unless subsets = @hash[k]
+          subsets = @hash[k]
+          next unless subsets
           subsets.map do |subenum, subset, index|
             next unless subset.subset?(set)
             [index, subenum]
@@ -83,7 +84,7 @@ module Sass
         res.uniq!
         res.sort!
         res.map! {|i, s| [@vals[i], s]}
-        return res
+        res
       end
 
       # Same as \{#get}, but doesn't return the subsets of the argument

data/lib/sass/util/test.rb

@@ -3,7 +3,6 @@ module Sass
     module Test
       def skip(msg = nil, bt = caller)
         super if defined?(super)
-        return
       end
     end
   end

data/lib/sass/version.rb

@@ -14,7 +14,8 @@ module Sass
     # The `:name` key has the name of the version.
     # The `:string` key contains a human-readable string representation of the version.
     # The `:number` key is the major, minor, and teeny keys separated by periods.
-    # The `:date` key, which is not guaranteed to be defined, is the `DateTime` at which this release was cut.
+    # The `:date` key, which is not guaranteed to be defined, is the `DateTime`
+    #   at which this release was cut.
     # If Sass is checked out from Git, the `:rev` key will have the revision hash.
     # For example:
     #
@@ -43,6 +44,8 @@ module Sass
     #     }
     #
     # @return [{Symbol => String/Fixnum}] The version hash
+    # @comment
+    #   rubocop:disable ClassVars
     def version
       return @@version if defined?(@@version)
 
@@ -56,7 +59,7 @@ module Sass
         :name => name
       }
 
-      if date = version_date
+      if (date = version_date)
         @@version[:date] = date
       end
 
@@ -69,7 +72,7 @@ module Sass
       @@version[:number] = numbers.join('.')
       @@version[:string] = @@version[:number].dup
 
-      if rev = revision_number
+      if (rev = revision_number)
         @@version[:rev] = rev
         unless rev[0] == ?(
           @@version[:string] << "." << rev[0...7]
@@ -79,6 +82,7 @@ module Sass
       @@version[:string] << " (#{name})"
       @@version
     end
+    # rubocop:enable ClassVars
 
     private
 
@@ -104,12 +108,12 @@ module Sass
           return sha
         end
       end
-      return nil
+      nil
     end
 
     def version_date
       return unless File.exists?(scope('VERSION_DATE'))
-      return DateTime.parse(File.read(scope('VERSION_DATE')).strip)
+      DateTime.parse(File.read(scope('VERSION_DATE')).strip)
     end
   end
 

data/test/rubocop_extensions.rb

@@ -0,0 +1,70 @@
+require "rubocop/cop/style/surrounding_space"
+
+module Rubocop
+  module Cop
+    module Style
+      # Common functionality for checking surrounding space.
+      # This is monkeypatching an existing class.
+      class SpaceAroundBlockBraces < Cop
+        MSG_RIGHT_SPACE = "Space found to the left of '}'."
+        MSG_LEFT_SPACE = "Space found to the right of '{'."
+        def investigate(processed_source)
+          return unless processed_source.ast
+          @processed_source = processed_source
+
+          processed_source.tokens.each_cons(2) do |t1, t2|
+            next if ([t1.pos, t2.pos] - positions_not_to_check).size < 2
+
+            type1, type2 = t1.type, t2.type
+            check(t1, t2, MSG_LEFT) if type2 == :tLCURLY
+            if type1 == :tLCURLY
+              if type2 == :tPIPE && cop_config['NoSpaceBeforeBlockParameters']
+                check_no_space(t1, t2, MSG_PIPE)
+              elsif cop_config['NoSpaceAfterOpeningCurly']
+                check_no_space(t1, t2, MSG_LEFT_SPACE)
+              else
+                check(t1, t2, MSG_LEFT)
+              end
+            end
+            if type2 == :tRCURLY
+              if cop_config['NoSpaceBeforeClosingCurly']
+                check_no_space(t1, t2, MSG_RIGHT_SPACE)
+              else
+                check(t1, t2, MSG_RIGHT) 
+              end
+            end
+          end
+        end
+
+        def check_no_space(t1, t2, msg)
+          convention(nil, t1.pos, msg) if space_between?(t1, t2)
+        end
+      end
+
+      # This is monkeypatching an existing class.
+      class RedundantReturn < Cop
+        def check(node)
+          return unless node
+
+          if node.type == :return
+            convention(node, :keyword)
+          elsif node.type == :begin
+            expressions = *node
+            last_expr = expressions.last
+
+            if last_expr && last_expr.type == :return
+              if cop_config['AllowMultipleReturnValues']
+                return if last_expr.children.size > 1
+              end
+              convention(last_expr, :keyword)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Rubocop::Config.default_configuration["SpaceAroundBlockBraces"]["NoSpaceBeforeClosingCurly"] = false
+Rubocop::Config.default_configuration["SpaceAroundBlockBraces"]["NoSpaceAfterOpeningCurly"] = false
+Rubocop::Config.default_configuration["RedundantReturn"]["AllowMultipleReturnValues"] = false

data/test/sass/functions_test.rb

@@ -163,7 +163,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_min
-    #assert_equal("1", evaluate("min(1, 2, 3)"))
+    assert_equal("1", evaluate("min(1, 2, 3)"))
     assert_equal("1", evaluate("min(3px, 2px, 1)"))
     assert_equal("4em", evaluate("min(4em)"))
     assert_equal("10cm", evaluate("min(10cm, 6in)"))
@@ -1038,6 +1038,7 @@ MSG
     assert_equal("3", evaluate("nth(1 2 3, -1)"))
     assert_equal("1", evaluate("nth(1 2 3, -3)"))
     assert_equal("3", evaluate("nth((1, 2, 3), 3)"))
+    assert_equal("3", evaluate("nth($list: (1, 2, 3), $n: 3)"))
     assert_equal("foo", evaluate("nth(foo, 1)"))
     assert_equal("bar baz", evaluate("nth(foo (bar baz) bang, 2)"))
     assert_error_message("List index 0 must be a non-zero integer for `nth'", "nth(foo, 0)")
@@ -1052,6 +1053,24 @@ MSG
     assert_equal("bar baz", evaluate("nth((foo: bar, bar: baz), 2)"))
   end
 
+  def test_set_nth
+    assert_equal("a 2 3", evaluate("set-nth(1 2 3, 1, a)"))
+    assert_equal("1 a 3", evaluate("set-nth(1 2 3, 2, a)"))
+    assert_equal("1 2 a", evaluate("set-nth(1 2 3, -1, a)"))
+    assert_equal("a 2 3", evaluate("set-nth(1 2 3, -3, a)"))
+    assert_equal("a 2 3", evaluate("set-nth($list: 1 2 3, $n: -3, $value: a)"))
+    assert_equal("1, 2, a", evaluate("set-nth((1, 2, 3), 3, a)"))
+    assert_equal("a", evaluate("set-nth(foo, 1, a)"))
+    assert_equal("foo, a b, baz", evaluate("set-nth((foo, bar, baz), 2, (a b))"))
+    assert_error_message("List index 0 must be a non-zero integer for `set-nth'", "set-nth(foo, 0, a)")
+    assert_error_message("List index is -10 but list is only 1 item long for `set-nth'", "set-nth(foo, -10, a)")
+    assert_error_message("List index 1.5 must be a non-zero integer for `set-nth'", "set-nth(foo, 1.5, a)")
+    assert_error_message("List index is 5 but list is only 4 items long for `set-nth'", "set-nth(1 2 3 4, 5, a)")
+    assert_error_message("List index is 2 but list is only 1 item long for `set-nth'", "set-nth(foo, 2, a)")
+    assert_error_message("List index is 1 but list has no items for `set-nth'", "set-nth((), 1, a)")
+    assert_error_message("$n: \"foo\" is not a number for `set-nth'", "set-nth(1 2 3, foo, a)")
+  end
+
   def test_join
     assert_equal("1 2 3", evaluate("join(1 2, 3)"))
     assert_equal("1 2 3", evaluate("join(1, 2 3)"))

data/test/sass/importer_test.rb

@@ -8,7 +8,8 @@ class ImporterTest < Test::Unit::TestCase
   
   class FruitImporter < Sass::Importers::Base
     def find(name, context = nil)
-      return unless fruit = parse(name)
+      fruit = parse(name)
+      return unless fruit
       color = case fruit
       when "apple"
         "red"

data/test/sass/script_test.rb

@@ -681,4 +681,8 @@ SASS
     assert_equal "-Infinity", eval("-1.0/0.0")
     assert_equal "NaN", eval("0.0/0.0")
   end
+
+  def test_null_is_a_singleton
+    assert_same Sass::Script::Value::Null.new, Sass::Script::Value::Null.new
+  end
 end

data/test/sass/source_map_test.rb

@@ -753,7 +753,7 @@ CSS
     start_positions = {}
     text.split("\n").each_with_index do |line_text, line|
       line += 1 # lines shoud be 1-based
-      while match = line_text.match(ANNOTATION_REGEX)
+      while (match = line_text.match(ANNOTATION_REGEX))
         closing = !match[1].empty?
         name = match[2]
         match_offsets = match.offset(0)

data/test/sass/util_test.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
 require 'pathname'
+require 'tmpdir'
 
 class UtilTest < Test::Unit::TestCase
   include Sass::Util
@@ -351,4 +352,52 @@ class UtilTest < Test::Unit::TestCase
     assert_equal vlq, vlq_from_decimal_array
     assert_equal decimal_array, decimal_array_from_vlq
   end
+
+  def test_atomic_writes
+    # when using normal writes, this test fails about 90% of the time.
+    filename = File.join(Dir.tmpdir, "test_atomic")
+    5.times do
+      writes_to_perform = %w(1 2 3 4 5 6 7 8 9).map {|i| "#{i}\n" * 100_000}
+      threads = writes_to_perform.map do |to_write|
+        Thread.new do
+          # To see this test fail with a normal write,
+          # change to the standard file open mechanism:
+          # open(filename, "w") do |f|
+          atomic_create_and_write_file(filename) do |f|
+            f.write(to_write)
+          end
+        end
+      end
+      loop do
+        contents = File.exist?(filename) ? File.read(filename) : nil
+        next if contents.nil? || contents.size == 0
+        unless writes_to_perform.include?(contents)
+          if contents.size != writes_to_perform.first.size
+            fail "Incomplete write detected: was #{contents.size} characters, " +
+                 "should have been #{writes_to_perform.first.size}"
+          else
+            fail "Corrupted read/write detected"
+          end
+        end
+        break if threads.all? {|t| !t.alive?}
+      end
+      threads.each {|t| t.join}
+    end
+  end
+
+  class FakeError < RuntimeError; end
+
+  def test_atomic_writes_handles_exceptions
+    filename = File.join(Dir.tmpdir, "test_atomic_exception")
+    FileUtils.rm_f(filename)
+    tmp_filename = nil
+    assert_raises FakeError do
+      atomic_create_and_write_file(filename) do |f|
+        tmp_filename = f.path
+        raise FakeError.new "Borken"
+      end
+    end
+    assert !File.exist?(filename)
+    assert !File.exist?(tmp_filename)
+  end
 end

data/test/sass/value_helpers_test.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ValueHelpersTest < Test::Unit::TestCase
+  include Sass::Script
+  include Sass::Script::Value::Helpers
+
+  def test_bool
+    assert_same Value::Bool::TRUE, bool(true)
+    assert_same Value::Bool::FALSE, bool(false)
+    assert_same Value::Bool::FALSE, bool(nil)
+    assert_same Value::Bool::TRUE, bool(Object.new)
+  end
+
+  def test_hex_color_with_three_digits
+    color = hex_color("F07")
+    assert_equal 255, color.red
+    assert_equal 0, color.green
+    assert_equal 119, color.blue
+    assert_equal 1, color.alpha
+  end
+
+  def test_hex_color_without_hash
+    color_without_hash = hex_color("FF007F")
+    assert_equal 255, color_without_hash.red
+    assert_equal 0, color_without_hash.green
+    assert_equal 127, color_without_hash.blue
+    assert_equal 1, color_without_hash.alpha
+  end
+
+  def test_hex_color_with_hash
+    color_with_hash = hex_color("#FF007F")
+    assert_equal 255, color_with_hash.red
+    assert_equal 0, color_with_hash.green
+    assert_equal 127, color_with_hash.blue
+    assert_equal 1, color_with_hash.alpha
+  end
+
+  def test_malformed_hex_color
+    assert_raises ArgumentError do
+      hex_color("green")
+    end
+    assert_raises ArgumentError do
+      hex_color("#abcd")
+    end
+  end
+
+
+  def test_hex_color_with_alpha
+    color_with_alpha = hex_color("FF007F", 0.5)
+    assert_equal 0.5, color_with_alpha.alpha
+  end
+
+  def test_hex_color_alpha_enforces_0_to_1
+    assert_raises ArgumentError do
+      hex_color("FF007F", 50)
+    end
+  end
+
+  def test_hsl_color_without_alpha
+    no_alpha = hsl_color(1, 0.5, 1)
+    assert_equal 1, no_alpha.hue
+    assert_equal 0.5, no_alpha.saturation
+    assert_equal 1, no_alpha.lightness
+    assert_equal 1, no_alpha.alpha
+  end
+
+  def test_hsl_color_with_alpha
+    has_alpha = hsl_color(1, 0.5, 1, 0.5)
+    assert_equal 1, has_alpha.hue
+    assert_equal 0.5, has_alpha.saturation
+    assert_equal 1, has_alpha.lightness
+    assert_equal 0.5, has_alpha.alpha
+  end
+
+  def test_rgb_color_without_alpha
+    no_alpha = rgb_color(255, 0, 0)
+    assert_equal 255, no_alpha.red
+    assert_equal 0, no_alpha.green
+    assert_equal 0, no_alpha.blue
+    assert_equal 1, no_alpha.alpha
+  end
+
+  def test_rgb_color_with_alpha
+    has_alpha = rgb_color(255, 255, 255, 0.5)
+    assert_equal 255, has_alpha.red
+    assert_equal 255, has_alpha.green
+    assert_equal 255, has_alpha.blue
+    assert_equal 0.5, has_alpha.alpha
+  end
+
+  def test_number
+    n = number(1)
+    assert_equal 1, n.value
+    assert_equal "1", n.to_sass
+  end
+
+  def test_number_with_single_unit
+    n = number(1, "px")
+    assert_equal 1, n.value
+    assert_equal "1px", n.to_sass
+  end
+
+  def test_number_with_singal_numerator_and_denominator
+    ratio = number(1, "px/em")
+    assert_equal "1px/em", ratio.to_sass
+  end
+
+  def test_number_with_many_numerator_and_denominator_units
+    complex = number(1, "px*in/em*%")
+    assert_equal "1in*px/%*em", complex.to_sass
+  end
+
+  def test_number_with_many_numerator_and_denominator_units_with_spaces
+    complex = number(1, "px * in / em * %")
+    assert_equal "1in*px/%*em", complex.to_sass
+  end
+
+  def test_number_with_malformed_units
+    assert_raises ArgumentError do
+      number(1, "px/em/%")
+    end
+    assert_raises ArgumentError do
+      number(1, "/")
+    end
+    assert_raises ArgumentError do
+      number(1, "px/")
+    end
+  end
+
+  def test_space_list
+    l = list(number(1, "px"), hex_color("#f71"), :space)
+    l.options = {}
+    assert_kind_of Sass::Script::Value::List, l
+    assert_equal "1px #ff7711", l.to_sass
+  end
+
+  def test_comma_list
+    l = list(number(1, "px"), hex_color("#f71"), :comma)
+    l.options = {}
+    assert_kind_of Sass::Script::Value::List, l
+    assert_equal "1px, #ff7711", l.to_sass
+  end
+
+  def test_missing_list_type
+    assert_raises ArgumentError do
+      list(number(1, "px"), hex_color("#f71"))
+    end
+  end
+
+  def test_null
+    assert_kind_of Sass::Script::Value::Null, null
+  end
+
+  def test_quoted_string
+    s = quoted_string("sassy string")
+    s.options = {}
+    assert_kind_of Sass::Script::Value::String, s
+    assert_equal "sassy string", s.value
+    assert_equal :string, s.type
+    assert_equal '"sassy string"', s.to_sass
+  end
+
+  def test_identifier
+    s = identifier("a-sass-ident")
+    s.options = {}
+    assert_kind_of Sass::Script::Value::String, s
+    assert_equal "a-sass-ident", s.value
+    assert_equal :identifier, s.type
+    assert_equal "a-sass-ident", s.to_sass
+  end
+
+  def test_unquoted_string
+    s = unquoted_string("a-sass-ident")
+    s.options = {}
+    assert_kind_of Sass::Script::Value::String, s
+    assert_equal "a-sass-ident", s.value
+    assert_equal :identifier, s.type
+    assert_equal "a-sass-ident", s.to_sass
+  end
+end