sass 3.3.0.alpha.69 → 3.3.0.alpha.88

data/REVISION

@@ -1 +1 @@
-2ada675414fd60b696703b85500d3528d482c64a
+c8154cc19b995b06961c60fb376d9c4821f8bde1

data/VERSION

@@ -1 +1 @@
-3.3.0.alpha.69
+3.3.0.alpha.88

data/VERSION_DATE

@@ -1 +1 @@
-05 January 2013 02:52:38 GMT
+18 February 2013 01:09:19 GMT

data/lib/sass/engine.rb

@@ -599,7 +599,7 @@ WARNING
           # which begin with ::,
           # as well as pseudo-classes
           # if we're using the new property syntax
-          Tree::RuleNode.new(parse_interp(line.text))
+          Tree::RuleNode.new(parse_interp(line.text), full_line_range(line))
         else
           name_start_offset = line.offset + 1 # +1 for the leading ':'
           name, value = line.text.scan(PROPERTY_OLD)[0]
@@ -626,12 +626,12 @@ WARNING
       when DIRECTIVE_CHAR
         parse_directive(parent, line, root)
       when ESCAPE_CHAR
-        Tree::RuleNode.new(parse_interp(line.text[1..-1]))
+        Tree::RuleNode.new(parse_interp(line.text[1..-1]), full_line_range(line))
       when MIXIN_DEFINITION_CHAR
         parse_mixin_definition(line)
       when MIXIN_INCLUDE_CHAR
         if line.text[1].nil? || line.text[1] == ?\s
-          Tree::RuleNode.new(parse_interp(line.text))
+          Tree::RuleNode.new(parse_interp(line.text), full_line_range(line))
         else
           parse_mixin_include(line, root)
         end
@@ -650,11 +650,12 @@ WARNING
         @line, to_parser_offset(offset))
 
       unless res = parser.parse_interp_ident
-        return Tree::RuleNode.new(parse_interp(line.text, line.offset))
+        parsed = parse_interp(line.text, line.offset)
+        return Tree::RuleNode.new(parsed, full_line_range(line))
       end
 
       ident_range = Sass::Source::Range.new(
-        Sass::Source::Position.new(@line, to_parser_offset(offset)),
+        Sass::Source::Position.new(@line, to_parser_offset(line.offset)),
         Sass::Source::Position.new(@line, parser.offset),
         @options[:filename], @options[:importer])
       offset = parser.offset - 1
@@ -672,7 +673,14 @@ WARNING
         property
       else
         res.pop if comment
-        Tree::RuleNode.new(res + parse_interp(scanner.rest))
+        scanner_start_pos = scanner.pos
+        interp_parsed = parse_interp(scanner.rest)
+        scanned_size = scanner.pos - scanner_start_pos
+        selector_range = Sass::Source::Range.new(
+          ident_range.start_pos,
+          Sass::Source::Position.new(@line, to_parser_offset(line.offset) + line.text.length),
+          @options[:filename], @options[:importer])
+        Tree::RuleNode.new(res + interp_parsed, selector_range)
       end
     end
 
@@ -733,7 +741,7 @@ WARNING
         type = if silent then :silent elsif loud then :loud else :normal end
         Tree::CommentNode.new(value, type)
       else
-        Tree::RuleNode.new(parse_interp(line.text))
+        Tree::RuleNode.new(parse_interp(line.text), full_line_range(line))
       end
     end
 
@@ -778,7 +786,13 @@ WARNING
           :line => @line + 1) unless line.children.empty?
         optional = !!value.gsub!(/\s+#{Sass::SCSS::RX::OPTIONAL}$/, '')
         offset = line.offset + line.text.index(value).to_i
-        Tree::ExtendNode.new(parse_interp(value, offset), optional)
+        interp_parsed = parse_interp(value, offset)
+        selector_range = Sass::Source::Range.new(
+          Sass::Source::Position.new(@line, to_parser_offset(offset)),
+          Sass::Source::Position.new(@line, to_parser_offset(line.offset) + line.text.length),
+          @options[:filename], @options[:importer]
+        )
+        Tree::ExtendNode.new(interp_parsed, optional, selector_range)
       when 'warn'
         raise SyntaxError.new("Invalid warn directive '@warn': expected expression.") unless value
         raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath warn directives.",
@@ -1030,6 +1044,13 @@ WARNING
       offset + 1
     end
 
+    def full_line_range(line)
+      Sass::Source::Range.new(
+        Sass::Source::Position.new(@line, to_parser_offset(line.offset)),
+        Sass::Source::Position.new(@line, to_parser_offset(line.offset) + line.text.length),
+        @options[:filename], @options[:importer])
+    end
+
     # It's important that this have strings (at least)
     # at the beginning, the end, and between each Script::Node.
     #

data/lib/sass/script/functions.rb

@@ -4,7 +4,7 @@ module Sass::Script
   #
   #     $color = hsl(120deg, 100%, 50%)
   #
-  # and it will call {Sass::Script::Functions#hsl}.
+  # and it will call {Functions#hsl}.
   #
   # The following functions are provided:
   #
@@ -110,6 +110,24 @@ module Sass::Script
   # \{#quote quote($string)}
   # : Adds quotes to a string.
   #
+  # \{#str_length str-length($string)}
+  # : Returns the number of characters in a string.
+  #
+  # \{#str_insert str-insert($string, $insert, $index)}
+  # : Inserts the second string into the first string at the specified index.
+  #
+  # \{#str_index str-index($string, $substring)}
+  # : Returns the index where a substring is found in another string or 0 if not found.
+  #
+  # \{#str_extract str-slice($string, $start, $end)}
+  # : Extracts a substring of characters from $string
+  #
+  # \{#to_upper_case to-upper-case($string)}
+  # : Converts a string to upper case.
+  #
+  # \{#to_lower_case to-lower-case($string)}
+  # : Converts a string to lower case.
+  #
   # ## Number Functions
   #
   # \{#percentage percentage($value)}
@@ -184,14 +202,14 @@ module Sass::Script
   # {declare} can also allow your function to take arbitrary keyword arguments.
   #
   # There are a few things to keep in mind when modifying this module.
-  # First of all, the arguments passed are {Sass::Script::Literal} objects.
+  # First of all, the arguments passed are {Literal} objects.
   # Literal objects are also expected to be returned.
   # This means that Ruby values must be unwrapped and wrapped.
   #
-  # Most Literal objects support the {Sass::Script::Literal#value value} accessor
+  # Most Literal objects support the {Literal#value value} accessor
   # for getting their Ruby values.
-  # Color objects, though, must be accessed using {Sass::Script::Color#rgb rgb},
-  # {Sass::Script::Color#red red}, {Sass::Script::Color#blue green}, or {Sass::Script::Color#blue blue}.
+  # Color objects, though, must be accessed using {Color#rgb rgb},
+  # {Color#red red}, {Color#blue green}, or {Color#blue blue}.
   #
   # Second, making Ruby functions accessible from Sass introduces the temptation
   # to do things like database access within stylesheets.
@@ -250,7 +268,7 @@ module Sass::Script
     #   Whether the function accepts other keyword arguments
     #   in addition to those in `:args`.
     #   If this is true, the Ruby function will be passed a hash from strings
-    #   to {Sass::Script::Literal}s as the last argument.
+    #   to {Literal}s as the last argument.
     #   In addition, if this is true and `:var_args` is not,
     #   Sass will ensure that the last argument passed is a hash.
     #
@@ -329,15 +347,63 @@ module Sass::Script
       # @example
       #   assert_type value, :String
       #   assert_type value, :Number
-      # @param value [Sass::Script::Literal] A SassScript value
+      # @param value [Literal] A SassScript value
       # @param type [Symbol] The name of the type the value is expected to be
       # @param name [String, nil] The name of the argument.
+      # @raise [ArgumentError] if value is not of the correct type.
       def assert_type(value, type, name = nil)
         return if value.is_a?(Sass::Script.const_get(type))
         err = "#{value.inspect} is not a #{type.to_s.downcase}"
         err = "$#{name}: " + err if name
         raise ArgumentError.new(err)
       end
+
+      # Asserts that the unit of the number is as expected.
+      #
+      # @example
+      #   assert_unit number, "px"
+      #   assert_unit number, nil
+      # @param number [Number] The number to be validated.
+      # @param unit [::String]
+      #   The unit that the number must have.
+      #   If nil, the number must be unitless.
+      # @param name [::String] The name of the parameter being validated.
+      # @raise [ArgumentError] if number is not of the correct unit or is not a number.
+      def assert_unit(number, unit, name = nil)
+        assert_type number, :Number, name
+        return if number.is_unit?(unit)
+        if unit
+          if name
+            raise ArgumentError.new("Expected $#{name} to have a unit of #{unit} but got #{number}")
+          else
+            raise ArgumentError.new("Expected #{number} to have a unit of #{unit}")
+          end
+        else
+          if name
+            raise ArgumentError.new("Expected $#{name} to be unitless but got #{number}")
+          else
+            raise ArgumentError.new("Expected #{number} to be unitless")
+          end
+        end
+      end
+
+      # Asserts that the value is an integer.
+      #
+      # @example
+      #   assert_unit number, "px"
+      #   assert_unit number, nil
+      # @param number [Literal] The literal to be validated.
+      # @param name [::String] The name of the parameter being validated.
+      # @raise [ArgumentError] if number is not an integer or is not a number.
+      def assert_integer(number, name = nil)
+        assert_type number, :Number, name
+        return if number.int?
+        if name
+          raise ArgumentError.new("Expected $#{name} to be an integer but got #{number}")
+        else
+          raise ArgumentError.new("Expected #{number} to be an integer")
+        end
+      end
     end
 
     class << self
@@ -377,11 +443,13 @@ module Sass::Script
 
       Color.new([red, green, blue].map do |c|
           v = c.value
-          if c.numerator_units == ["%"] && c.denominator_units.empty?
+          if c.is_unit?("%")
             v = Sass::Util.check_range("Color value", 0..100, c, '%')
             v * 255 / 100.0
-          else
+          elsif c.unitless?
             Sass::Util.check_range("Color value", 0..255, c)
+          else
+            raise ArgumentError.new("Expected #{c} to be unitless or have a unit of % but got #{c}")
           end
         end)
     end
@@ -874,11 +942,8 @@ module Sass::Script
 
         next unless val = kwargs.delete(name)
         assert_type val, :Number, name
-        if !(val.numerator_units == ['%'] && val.denominator_units.empty?)
-          raise ArgumentError.new("$#{name}: Amount #{val} must be a % (e.g. #{val.value}%)")
-        else
-          Sass::Util.check_range("$#{name}: Amount", -100..100, val, '%')
-        end
+        assert_unit val, '%', name
+        Sass::Util.check_range("$#{name}: Amount", -100..100, val, '%')
 
         current = color.send(name)
         scale = val.value/100.0
@@ -1083,6 +1148,138 @@ module Sass::Script
     end
     declare :quote, [:string]
 
+    # Returns the number of characters in a string.
+    #
+    # @return [Number]
+    # @raise [ArgumentError] if `string` isn't a string
+    # @example
+    #   str-length("foo") => 3
+    def str_length(string)
+      assert_type string, :String
+      Sass::Script::Number.new(string.value.size)
+    end
+    declare :str_length, [:string]
+
+    # Inserts a string into another string.
+    #
+    # Inserts the `$insert` string into the `$original` before the character at
+    # the given `$index`.
+    #
+    # @param [String] original The string that will receive the insertion.
+    # @param [String] insert The string that will be inserted.
+    # @param [Number] index
+    #   The position where inserted string will start.
+    #   Negative indices count from the end of the original string.
+    #
+    # @return [String] A new string
+    # @raise [ArgumentError] if `$original` isn't a string, `$insert` isn't a string, or `$index` isn't a number.
+    # @example
+    #   str-insert("abcd", "X", 1) => "Xabcd"
+    #   str-insert("abcd", "X", 4) => "abcXd"
+    #   str-insert("abcd", "X", 100) => "abcdX"
+    #   str-insert("abcd", "X", -100) => "Xabcd"
+    def str_insert(original, insert, index)
+      assert_type original, :String, "original"
+      assert_type insert, :String, "insert"
+      assert_integer index, "index"
+      assert_unit index, nil, "index"
+      insertion_point = index.value > 0 ? [index.value - 1, original.value.size].min : [index.value, -original.value.size - 1].max
+      Sass::Script::String.new(original.value.dup.insert(insertion_point, insert.value), original.type)
+    end
+    declare :str_insert, [:original, :insert, :index]
+
+    # Starting at the left, finds the index of the first location
+    # where `substring` is found in `string`.
+    #
+    # @return [Number] The index of the substring, or 0 if not found.
+    # @raise [ArgumentError] if `original` isn't a string, `insert` isn't a string, or `index` isn't a number.
+    # @param string The string to search
+    # @param substring The string to search for
+    # @example
+    #   str-index(abcd, a)  => 1
+    #   str-index(abcd, ab) => 1
+    #   str-index(abcd, X)  => 0
+    #   str-index(abcd, c)  => 3
+    def str_index(string, substring)
+      assert_type string, :String
+      assert_type substring, :String
+      index = string.value.index(substring.value) || -1
+      Sass::Script::Number.new(index + 1)
+    end
+    declare :str_index, [:string, :substring]
+
+
+    # Slice a substring from `string` from `start-at` index to `end-at` index.
+    #
+    # @return [String] A new string
+    # @param start_at
+    #   The index (inclusive) of the first character to slice out of the string.
+    #   If negative, counts from the end of the string.
+    # @param end_at
+    #   The index (inclusive) of the last character to slice out of the string.
+    # @overload str_slice(string, start_at)
+    #   Slice starting at `start_at` to the end of the string.
+    # @overload str_slice(string, start_at, end_at)
+    #   Slice starting at `start_at` to `end_at`
+    # @raise [ArgumentError] if `string` isn't a string or `start_at` and `end_at` aren't unitless numbers
+    # @example
+    #  str-slice(abcd,    2,   3) => bc
+    #  str-slice(abcd,    2     ) => bcd
+    #  str-slice(abcd,   -2     ) => cd
+    #  str-slice(abcd,    2,  -2) => bc
+    #  str-slice("abcd",  3,  -3) => ""
+    #  str-slice(abcd,    1,   1) => a
+    #  str-slice(abcd,    1,   2) => ab
+    #  str-slice(abcd,    1,   4) => abcd
+    #  str-slice(abcd, -100,   4) => abcd
+    #  str-slice(abcd,    1, 100) => abcd
+    #  str-slice("abcd",  2,   1) => ""
+    #  str-slice("abcd",  2,   3) => "bc"
+    def str_slice(string, start_at, end_at = nil)
+      assert_type string, :String
+      assert_unit start_at, nil, "start-at"
+
+      end_at = Sass::Script::Number.new(-1)if end_at.nil?
+      assert_unit end_at, nil, "end-at"
+
+      s = start_at.value > 0 ? start_at.value - 1 : start_at.value
+      e = end_at.value > 0 ? end_at.value - 1 : end_at.value
+      s = string.value.length + s if s < 0
+      s = 0 if s < 0
+      e = string.value.length + e if e < 0
+      e = 0 if s < 0
+      extracted = string.value.slice(s..e)
+      Sass::Script::String.new(extracted || "", string.type)
+    end
+    declare :str_slice, [:string, :start_at]
+    declare :str_slice, [:string, :start_at, :end_at]
+
+    # Convert a string to upper case
+    #
+    # @return [String]
+    # @raise [ArgumentError] if `string` isn't a string
+    # @example
+    #   to-upper-case(abcd) => ABCD
+    #   to-upper-case("abcd") => "ABCD"
+    def to_upper_case(string)
+      assert_type string, :String
+      Sass::Script::String.new(string.value.upcase, string.type)
+    end
+    declare :to_upper_case, [:string]
+
+    # Convert a string to lower case
+    #
+    # @return [String]
+    # @raise [ArgumentError] if `string` isn't a string
+    # @example
+    #   to-lower-case(ABCD) => abcd
+    #   to-lower-case("ABCD") => "abcd"
+    def to_lower_case(string)
+      assert_type string, :String
+      Sass::Script::String.new(string.value.downcase, string.type)
+    end
+    declare :to_lower_case, [:string]
+
     # Inspects the type of the argument, returning it as an unquoted string.
     #
     # @example

data/lib/sass/script/number.rb

@@ -57,9 +57,11 @@ module Sass::Script
     NO_UNITS  = []
 
     # @param value [Numeric] The value of the number
-    # @param numerator_units [Array<String>] See \{#numerator\_units}
-    # @param denominator_units [Array<String>] See \{#denominator\_units}
+    # @param numerator_units [::String, Array<::String>] See \{#numerator\_units}
+    # @param denominator_units [::String, Array<::String>] See \{#denominator\_units}
     def initialize(value, numerator_units = NO_UNITS, denominator_units = NO_UNITS)
+      numerator_units = [numerator_units] if numerator_units.is_a?(::String)
+      denominator_units = [denominator_units] if denominator_units.is_a?(::String)
       super(value)
       @numerator_units = numerator_units
       @denominator_units = denominator_units
@@ -285,6 +287,24 @@ module Sass::Script
       @numerator_units.empty? && @denominator_units.empty?
     end
 
+    # Checks whether the number has the numerator unit specified.
+    #
+    # @example
+    #   number = Sass::Script::Number.new(10, "px")
+    #   number.is_unit?("px") => true
+    #   number.is_unit?(nil) => false
+    #
+    # @param number [Number] The number to check
+    # @param unit [::String, nil] The unit the number should have or nil if the number should be unitless.
+    # @see Number#unitless? The unitless? method may be more readable.
+    def is_unit?(unit)
+      if unit
+        denominator_units.size == 0 && numerator_units.size == 1 && numerator_units.first == unit
+      else
+        unitless?
+      end
+    end
+
     # @return [Boolean] Whether or not this number has units that can be represented in CSS
     #   (that is, zero or one \{#numerator\_units}).
     def legal_units?

data/lib/sass/scss/parser.rb

@@ -311,10 +311,10 @@ module Sass
       end
 
       def extend_directive(start_pos)
-        selector = expr!(:selector_sequence)
+        selector, selector_range = expr!(:selector_sequence)
         optional = tok(OPTIONAL)
         ss
-        node(Sass::Tree::ExtendNode.new(selector, !!optional), start_pos)
+        node(Sass::Tree::ExtendNode.new(selector, !!optional, selector_range), start_pos)
       end
 
       def import_directive(start_pos)
@@ -536,8 +536,9 @@ module Sass
 
       def ruleset
         start_pos = source_position
-        return unless rules = selector_sequence
-        block(node(Sass::Tree::RuleNode.new(rules.flatten.compact), start_pos), :ruleset)
+        rules, source_range = selector_sequence
+        return unless rules
+        block(node(Sass::Tree::RuleNode.new(rules.flatten.compact, source_range), start_pos), :ruleset)
       end
 
       def block(node, context)
@@ -607,8 +608,9 @@ module Sass
       end
 
       def selector_sequence
+        start_pos = source_position
         if sel = tok(STATIC_SELECTOR, true)
-          return [sel]
+          return [sel], range(start_pos)
         end
 
         rules = []
@@ -624,7 +626,7 @@ module Sass
             ws = ''
           end
         end
-        rules
+        return rules, range(start_pos)
       end
 
       def selector
@@ -680,6 +682,8 @@ module Sass
       def simple_selector_sequence
         # Returning expr by default allows for stuff like
         # http://www.w3.org/TR/css3-animations/#keyframes-
+
+        start_pos = source_position
         return expr(!:allow_var) unless e = element_name || id_selector ||
           class_selector || placeholder_selector || attrib || pseudo ||
           parent_selector || interpolation_selector
@@ -708,7 +712,7 @@ module Sass
           end
         end
 
-        Selector::SimpleSequence.new(res, tok(/!/))
+        Selector::SimpleSequence.new(res, tok(/!/), range(start_pos))
       end
 
       def parent_selector
@@ -1038,7 +1042,7 @@ MESSAGE
       def self.sass_script_parser; @sass_script_parser; end
 
       def sass_script(*args)
-        parser = self.class.sass_script_parser.new(@scanner, @line, @offset, :filename => @filename)
+        parser = self.class.sass_script_parser.new(@scanner, @line, @offset, :filename => @filename, :importer => @importer)
         result = parser.send(*args)
         unless @strs.empty?
           # Convert to CSS manually so that comments are ignored.