sass 3.7.4 → 4.0.0.alpha.1

data/lib/sass/util/cross_platform_random.rb

@@ -0,0 +1,19 @@
+module Sass
+  module Util
+    # Ruby 1.8 doesn't support an actual Random class with a settable seed.
+    class CrossPlatformRandom
+      def initialize(seed = nil)
+        if Sass::Util.ruby1_8?
+          srand(seed) if seed
+        else
+          @random = seed ? ::Random.new(seed) : ::Random.new
+        end
+      end
+
+      def rand(*args)
+        return @random.rand(*args) if @random
+        Kernel.rand(*args)
+      end
+    end
+  end
+end

data/lib/sass/util/multibyte_string_scanner.rb

@@ -1,151 +1,157 @@
 require 'strscan'
 
-if Sass::Util.rbx?
-  # Rubinius's StringScanner class implements some of its methods in terms of
-  # others, which causes us to double-count bytes in some cases if we do
-  # straightforward inheritance. To work around this, we use a delegate class.
-  require 'delegate'
-  class Sass::Util::MultibyteStringScanner < DelegateClass(StringScanner)
-    def initialize(str)
-      super(StringScanner.new(str))
-      @mb_pos = 0
-      @mb_matched_size = nil
-      @mb_last_pos = nil
+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
+    # others, which causes us to double-count bytes in some cases if we do
+    # straightforward inheritance. To work around this, we use a delegate class.
+    require 'delegate'
+    class Sass::Util::MultibyteStringScanner < DelegateClass(StringScanner)
+      def initialize(str)
+        super(StringScanner.new(str))
+        @mb_pos = 0
+        @mb_matched_size = nil
+        @mb_last_pos = nil
+      end
+
+      def is_a?(klass)
+        __getobj__.is_a?(klass) || super
+      end
     end
-
-    def is_a?(klass)
-      __getobj__.is_a?(klass) || super
+  else
+    class Sass::Util::MultibyteStringScanner < StringScanner
+      def initialize(str)
+        super
+        @mb_pos = 0
+        @mb_matched_size = nil
+        @mb_last_pos = nil
+      end
     end
   end
-else
-  class Sass::Util::MultibyteStringScanner < StringScanner
-    def initialize(str)
+
+  # A wrapper of the native StringScanner class that works correctly with
+  # multibyte character encodings. The native class deals only in bytes, not
+  # characters, for methods like [#pos] and [#matched_size]. This class deals
+  # only in characters, instead.
+  class Sass::Util::MultibyteStringScanner
+    def self.new(str)
+      return StringScanner.new(str) if str.ascii_only?
       super
-      @mb_pos = 0
-      @mb_matched_size = nil
-      @mb_last_pos = nil
     end
-  end
-end
 
-# A wrapper of the native StringScanner class that works correctly with
-# multibyte character encodings. The native class deals only in bytes, not
-# characters, for methods like [#pos] and [#matched_size]. This class deals
-# only in characters, instead.
-class Sass::Util::MultibyteStringScanner
-  def self.new(str)
-    return StringScanner.new(str) if str.ascii_only?
-    super
-  end
+    alias_method :byte_pos, :pos
+    alias_method :byte_matched_size, :matched_size
+
+    def check(pattern); _match super; end
+    def check_until(pattern); _matched super; end
+    def getch; _forward _match super; end
+    def match?(pattern); _size check(pattern); end
+    def matched_size; @mb_matched_size; end
+    def peek(len); string[@mb_pos, len]; end
+    alias_method :peep, :peek
+    def pos; @mb_pos; end
+    alias_method :pointer, :pos
+    def rest_size; rest.size; end
+    def scan(pattern); _forward _match super; end
+    def scan_until(pattern); _forward _matched super; end
+    def skip(pattern); _size scan(pattern); end
+    def skip_until(pattern); _matched _size scan_until(pattern); end
+
+    def get_byte
+      raise "MultibyteStringScanner doesn't support #get_byte."
+    end
 
-  alias_method :byte_pos, :pos
-  alias_method :byte_matched_size, :matched_size
-
-  def check(pattern); _match super; end
-  def check_until(pattern); _matched super; end
-  def getch; _forward _match super; end
-  def match?(pattern); _size check(pattern); end
-  def matched_size; @mb_matched_size; end
-  def peek(len); string[@mb_pos, len]; end
-  alias_method :peep, :peek
-  def pos; @mb_pos; end
-  alias_method :pointer, :pos
-  def rest_size; rest.size; end
-  def scan(pattern); _forward _match super; end
-  def scan_until(pattern); _forward _matched super; end
-  def skip(pattern); _size scan(pattern); end
-  def skip_until(pattern); _matched _size scan_until(pattern); end
-
-  def get_byte
-    raise "MultibyteStringScanner doesn't support #get_byte."
-  end
+    def getbyte
+      raise "MultibyteStringScanner doesn't support #getbyte."
+    end
 
-  def getbyte
-    raise "MultibyteStringScanner doesn't support #getbyte."
-  end
+    def pos=(n)
+      @mb_last_pos = nil
 
-  def pos=(n)
-    @mb_last_pos = nil
-
-    # We set position kind of a lot during parsing, so we want it to be as
-    # efficient as possible. This is complicated by the fact that UTF-8 is a
-    # variable-length encoding, so it's difficult to find the byte length that
-    # corresponds to a given character length.
-    #
-    # Our heuristic here is to try to count the fewest possible characters. So
-    # if the new position is close to the current one, just count the
-    # characters between the two; if the new position is closer to the
-    # beginning of the string, just count the characters from there.
-    if @mb_pos - n < @mb_pos / 2
-      # New position is close to old position
-      byte_delta = @mb_pos > n ? -string[n...@mb_pos].bytesize : string[@mb_pos...n].bytesize
-      super(byte_pos + byte_delta)
-    else
-      # New position is close to BOS
-      super(string[0...n].bytesize)
-    end
-    @mb_pos = n
-  end
+      # We set position kind of a lot during parsing, so we want it to be as
+      # efficient as possible. This is complicated by the fact that UTF-8 is a
+      # variable-length encoding, so it's difficult to find the byte length that
+      # corresponds to a given character length.
+      #
+      # Our heuristic here is to try to count the fewest possible characters. So
+      # if the new position is close to the current one, just count the
+      # characters between the two; if the new position is closer to the
+      # beginning of the string, just count the characters from there.
+      if @mb_pos - n < @mb_pos / 2
+        # New position is close to old position
+        byte_delta = @mb_pos > n ? -string[n...@mb_pos].bytesize : string[@mb_pos...n].bytesize
+        super(byte_pos + byte_delta)
+      else
+        # New position is close to BOS
+        super(string[0...n].bytesize)
+      end
+      @mb_pos = n
+    end
 
-  def reset
-    @mb_pos = 0
-    @mb_matched_size = nil
-    @mb_last_pos = nil
-    super
-  end
+    def reset
+      @mb_pos = 0
+      @mb_matched_size = nil
+      @mb_last_pos = nil
+      super
+    end
 
-  def scan_full(pattern, advance_pointer_p, return_string_p)
-    res = _match super(pattern, advance_pointer_p, true)
-    _forward res if advance_pointer_p
-    return res if return_string_p
-  end
+    def scan_full(pattern, advance_pointer_p, return_string_p)
+      res = _match super(pattern, advance_pointer_p, true)
+      _forward res if advance_pointer_p
+      return res if return_string_p
+    end
 
-  def search_full(pattern, advance_pointer_p, return_string_p)
-    res = super(pattern, advance_pointer_p, true)
-    _forward res if advance_pointer_p
-    _matched((res if return_string_p))
-  end
+    def search_full(pattern, advance_pointer_p, return_string_p)
+      res = super(pattern, advance_pointer_p, true)
+      _forward res if advance_pointer_p
+      _matched((res if return_string_p))
+    end
 
-  def string=(str)
-    @mb_pos = 0
-    @mb_matched_size = nil
-    @mb_last_pos = nil
-    super
-  end
+    def string=(str)
+      @mb_pos = 0
+      @mb_matched_size = nil
+      @mb_last_pos = nil
+      super
+    end
 
-  def terminate
-    @mb_pos = string.size
-    @mb_matched_size = nil
-    @mb_last_pos = nil
-    super
-  end
-  alias_method :clear, :terminate
+    def terminate
+      @mb_pos = string.size
+      @mb_matched_size = nil
+      @mb_last_pos = nil
+      super
+    end
+    alias_method :clear, :terminate
 
-  def unscan
-    super
-    @mb_pos = @mb_last_pos
-    @mb_last_pos = @mb_matched_size = nil
-  end
+    def unscan
+      super
+      @mb_pos = @mb_last_pos
+      @mb_last_pos = @mb_matched_size = nil
+    end
 
-  private
+    private
 
-  def _size(str)
-    str && str.size
-  end
+    def _size(str)
+      str && str.size
+    end
 
-  def _match(str)
-    @mb_matched_size = str && str.size
-    str
-  end
+    def _match(str)
+      @mb_matched_size = str && str.size
+      str
+    end
 
-  def _matched(res)
-    _match matched
-    res
-  end
+    def _matched(res)
+      _match matched
+      res
+    end
 
-  def _forward(str)
-    @mb_last_pos = @mb_pos
-    @mb_pos += str.size if str
-    str
+    def _forward(str)
+      @mb_last_pos = @mb_pos
+      @mb_pos += str.size if str
+      str
+    end
   end
 end

data/lib/sass/util/normalized_map.rb

@@ -5,11 +5,12 @@ module Sass
     # A hash that normalizes its string keys while still allowing you to get back
     # to the original keys that were stored. If several different values normalize
     # to the same value, whichever is stored last wins.
+    require 'sass/util/ordered_hash' if ruby1_8?
     class NormalizedMap
       # Create a normalized map
       def initialize(map = nil)
         @key_strings = {}
-        @map = {}
+        @map = Util.ruby1_8? ? OrderedHash.new : {}
 
         map.each {|key, value| self[key] = value} if map
       end
@@ -114,6 +115,12 @@ module Sass
         @map.send(method, *args, &block)
       end
 
+      if Sass::Util.ruby1_8?
+        def respond_to?(method, include_private = false)
+          super || @map.respond_to?(method, include_private)
+        end
+      end
+
       def respond_to_missing?(method, include_private = false)
         @map.respond_to?(method, include_private)
       end

data/lib/sass/util/ordered_hash.rb

@@ -0,0 +1,192 @@
+# 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
+# without limitation the rights to use, copy, modify, merge, publish,
+# 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
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# This class was copied from an old version of ActiveSupport.
+class OrderedHash < ::Hash
+  # In MRI the Hash class is core and written in C. In particular, methods are
+  # programmed with explicit C function calls and polymorphism is not honored.
+  #
+  # For example, []= is crucial in this implementation to maintain the @keys
+  # array but hash.c invokes rb_hash_aset() originally. This prevents method
+  # reuse through inheritance and forces us to reimplement stuff.
+  #
+  # For instance, we cannot use the inherited #merge! because albeit the algorithm
+  # itself would work, our []= is not being called at all by the C code.
+
+  def initialize(*args)
+    super
+    @keys = []
+  end
+
+  def self.[](*args)
+    ordered_hash = new
+
+    if args.length == 1 && args.first.is_a?(Array)
+      args.first.each do |key_value_pair|
+        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.even?
+      raise ArgumentError.new("odd number of arguments for Hash")
+    end
+
+    args.each_with_index do |val, ind|
+      next if ind.odd?
+      ordered_hash[val] = args[ind + 1]
+    end
+
+    ordered_hash
+  end
+
+  def initialize_copy(other)
+    super
+    # make a deep copy of keys
+    @keys = other.keys
+  end
+
+  def []=(key, value)
+    @keys << key unless has_key?(key)
+    super
+  end
+
+  def delete(key)
+    if has_key? key
+      index = @keys.index(key)
+      @keys.delete_at index
+    end
+    super
+  end
+
+  def delete_if
+    super
+    sync_keys!
+    self
+  end
+
+  def reject!
+    super
+    sync_keys!
+    self
+  end
+
+  def reject
+    dup.reject! {|h, k| yield h, k}
+  end
+
+  def keys
+    @keys.dup
+  end
+
+  def values
+    @keys.map {|key| self[key]}
+  end
+
+  def to_hash
+    self
+  end
+
+  def to_a
+    @keys.map {|key| [key, self[key]]}
+  end
+
+  def each_key
+    return to_enum(:each_key) unless block_given?
+    @keys.each {|key| yield key}
+    self
+  end
+
+  def each_value
+    return to_enum(:each_value) unless block_given?
+    @keys.each {|key| yield self[key]}
+    self
+  end
+
+  def each
+    return to_enum(:each) unless block_given?
+    @keys.each {|key| yield [key, self[key]]}
+    self
+  end
+
+  def each_pair
+    return to_enum(:each_pair) unless block_given?
+    @keys.each {|key| yield key, self[key]}
+    self
+  end
+
+  alias_method :select, :find_all
+
+  def clear
+    super
+    @keys.clear
+    self
+  end
+
+  def shift
+    k = @keys.first
+    v = delete(k)
+    [k, v]
+  end
+
+  def merge!(other_hash)
+    if block_given?
+      other_hash.each {|k, v| self[k] = key?(k) ? yield(k, self[k], v) : v}
+    else
+      other_hash.each {|k, v| self[k] = v}
+    end
+    self
+  end
+
+  alias_method :update, :merge!
+
+  def merge(other_hash)
+    if block_given?
+      dup.merge!(other_hash) {|k, v1, v2| yield k, v1, v2}
+    else
+      dup.merge!(other_hash)
+    end
+  end
+
+  # 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
+    self
+  end
+
+  def invert
+    OrderedHash[to_a.map! {|key_value_pair| key_value_pair.reverse}]
+  end
+
+  def inspect
+    "#<OrderedHash #{super}>"
+  end
+
+  private
+
+  def sync_keys!
+    @keys.delete_if {|k| !has_key?(k)}
+  end
+end