module Sass::Util - sass-3.4.14 Documentation

# module Sass::Util

A module containing various useful functions.

### Constants

ATOMIC_WRITE_MUTEX

  @private

BASE64_DIGITS
BASE64_DIGIT_MAP
CHARSET_REGEXP
MultibyteStringScanner

  rubocop:disable ConstantName

RUBY_ENGINE

  The Ruby engine we're running under. Defaults to `“ruby”` if the top-level constant is undefined. @api public

RUBY_VERSION_COMPONENTS

  An array of ints representing the Ruby version number. @api public

URI_ESCAPE

  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

UTF_16BE_BOM
UTF_16LE_BOM
UTF_8_BOM
VLQ_BASE
VLQ_BASE_MASK
VLQ_BASE_SHIFT
VLQ_CONTINUATION_BIT

### Public Instance Methods

absolute_path(path, dir_string = nil) click to toggle source

A cross-platform implementation of `File.absolute_path`.

@param path [String] @param dir_string [String] The directory to consider [path] relative to. @return [String] The absolute version of `path`.

    # File lib/sass/util.rb, line 1205
    def absolute_path(path, dir_string = nil)
      # Ruby 1.8 doesn't support File.absolute_path.
      return File.absolute_path(path, dir_string) unless ruby1_8?

      # File.expand_path expands "~", which we don't want.
      return File.expand_path(path, dir_string) unless path[0] == ?~
      File.expand_path(File.join(".", path), dir_string)
    end

abstract(obj) click to toggle source

Throws a NotImplementedError for an abstract method.

@param obj [Object] `self` @raise [NotImplementedError]

    # File lib/sass/util.rb, line 461
    def abstract(obj)
      raise NotImplementedError.new("#{obj.class} must implement ##{caller_info[2]}")
    end

ap_geq?(version) click to toggle source

Returns whether this environment is using ActionPack of a version greater than or equal to that specified.

@param version [String] The string version number to check against.

    Should be greater than or equal to Rails 3,
    because otherwise ActionPack::VERSION isn't autoloaded

@return [Boolean]

    # File lib/sass/util.rb, line 546
    def ap_geq?(version)
      # The ActionPack module is always loaded automatically in Rails >= 3
      return false unless defined?(ActionPack) && defined?(ActionPack::VERSION) &&
        defined?(ActionPack::VERSION::STRING)

      version_geq(ActionPack::VERSION::STRING, version)
    end

ap_geq_3?() click to toggle source

Returns whether this environment is using ActionPack version 3.0.0 or greater.

@return [Boolean]

    # File lib/sass/util.rb, line 535
    def ap_geq_3?
      ap_geq?("3.0.0.beta1")
    end

array_minus(minuend, subtrahend) click to toggle source

Returns a sub-array of `minuend` containing only elements that are also in `subtrahend`. Ensures that the return value has the same order as `minuend`, even on Rubinius where that's not guaranteed by `Array#-`.

@param minuend [Array] @param subtrahend [Array] @return [Array]

    # File lib/sass/util.rb, line 334
    def array_minus(minuend, subtrahend)
      return minuend - subtrahend unless rbx?
      set = Set.new(minuend) - subtrahend
      minuend.select {|e| set.include?(e)}
    end

atomic_create_and_write_file(filename, perms = 0666) { |tmpfile| ... } click to toggle source

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. @param perms [Integer] The permissions used for creating this file.

    Will be masked by the process umask. Defaults to readable/writeable
    by all users however the umask usually changes this to only be writable
    by the process's user.

@yieldparam tmpfile [Tempfile] The temp file that can be written to. @return The value returned by the block.

    # File lib/sass/util.rb, line 1248
    def atomic_create_and_write_file(filename, perms = 0666)
      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
        begin
          File.chmod(perms & ~File.umask, tmpfile.path)
        rescue Errno::EPERM
          # If we don't have permissions to chmod the file, don't let that crash
          # the compilation. See issue 1215.
        end
        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

av_template_class(name) click to toggle source

Returns an ActionView::Template* class. In pre-3.0 versions of Rails, most of these classes were of the form `ActionView::TemplateFoo`, while afterwards they were of the form `ActionView;:Template::Foo`.

@param name [#to_s] The name of the class to get.

    For example, `:Error` will return `ActionView::TemplateError`
    or `ActionView::Template::Error`.

    # File lib/sass/util.rb, line 577
    def av_template_class(name)
      return ActionView.const_get("Template#{name}") if ActionView.const_defined?("Template#{name}")
      ActionView::Template.const_get(name.to_s)
    end

caller_info(entry = nil) click to toggle source

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.
    The method name may be nil

    # File lib/sass/util.rb, line 409
    def caller_info(entry = nil)
      # JRuby evaluates `caller` incorrectly when it's in an actual default argument.
      entry ||= caller[1]
      info = entry.scan(/^((?:[A-Za-z]:)?.*?):(-?.*?)(?::.*`(.+)')?$/).first
      info[1] = info[1].to_i
      # This is added by Rubinius to designate a block, but we don't care about it.
      info[2].sub!(/ \{\}\Z/, '') if info[2]
      info
    end

check_range(name, range, value, unit = '') click to toggle source

Asserts that `value` falls within `range` (inclusive), leaving room for slight floating-point errors.

@param name [String] The name of the value. Used in the error message. @param range [Range] The allowed range of values. @param value [Numeric, Sass::Script::Value::Number] The value to check. @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.

    # File lib/sass/util.rb, line 375
    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)
      return value if range.include?(value)
      return range.first if grace.include?(value - range.first)
      return range.last if grace.include?(value - range.last)
      raise ArgumentError.new(
        "#{name} #{str} must be between #{range.first}#{unit} and #{range.last}#{unit}")
    end

check_sass_encoding(str) click to toggle source

Like {#check_encoding}, but also checks for a `@charset` declaration at the beginning of the file and uses that encoding if it exists.

Sass follows CSS's decoding rules.

@param str [String] The string of which to check the encoding @return [(String, Encoding)] The original string encoded as UTF-8,

    and the source encoding of the string (or `nil` under Ruby 1.8)

@raise [Encoding::UndefinedConversionError] if the source encoding

    cannot be converted to UTF-8

@raise [ArgumentError] if the document uses an unknown encoding with `@charset` @raise [Sass::SyntaxError] If the document declares an encoding that

    doesn't match its contents, or it doesn't declare an encoding and its
    contents are invalid in the native encoding.

    # File lib/sass/util.rb, line 853
    def check_sass_encoding(str)
      # On Ruby 1.8 we can't do anything complicated with encodings.
      # Instead, we just strip out a UTF-8 BOM if it exists and
      # sanitize according to Section 3.3 of CSS Syntax Level 3. We
      # don't sanitize null characters since they might be components
      # of other characters.
      if ruby1_8?
        return str.gsub(/\A\xEF\xBB\xBF/, '').gsub(/\r\n?|\f/, "\n"), nil
      end

      # Determine the fallback encoding following section 3.2 of CSS Syntax Level 3 and Encodings:
      # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#determine-the-fallback-encoding
      # http://encoding.spec.whatwg.org/#decode
      binary = str.dup.force_encoding("BINARY")
      if binary.start_with?(UTF_8_BOM)
        binary.slice! 0, UTF_8_BOM.length
        str = binary.force_encoding('UTF-8')
      elsif binary.start_with?(UTF_16BE_BOM)
        binary.slice! 0, UTF_16BE_BOM.length
        str = binary.force_encoding('UTF-16BE')
      elsif binary.start_with?(UTF_16LE_BOM)
        binary.slice! 0, UTF_16LE_BOM.length
        str = binary.force_encoding('UTF-16LE')
      elsif binary =~ CHARSET_REGEXP
        charset = $1.force_encoding('US-ASCII')
        # Ruby 1.9.2 doesn't recognize a UTF-16 encoding without an endian marker.
        if ruby1_9_2? && charset.downcase == 'utf-16'
          encoding = Encoding.find('UTF-8')
        else
          encoding = Encoding.find(charset)
          if encoding.name == 'UTF-16' || encoding.name == 'UTF-16BE'
            encoding = Encoding.find('UTF-8')
          end
        end
        str = binary.force_encoding(encoding)
      elsif str.encoding.name == "ASCII-8BIT"
        # Normally we want to fall back on believing the Ruby string
        # encoding, but if that's just binary we want to make sure
        # it's valid UTF-8.
        str = str.force_encoding('utf-8')
      end

      find_encoding_error(str) unless str.valid_encoding?

      begin
        # If the string is valid, preprocess it according to section 3.3 of CSS Syntax Level 3.
        return str.encode("UTF-8").gsub(/\r\n?|\f/, "\n").tr("\u0000", "�"), str.encoding
      rescue EncodingError
        find_encoding_error(str)
      end
    end

cleanpath(path) click to toggle source

Like `Pathname#cleanpath`, but normalizes Windows paths to always use backslash separators. Normally, `Pathname#cleanpath` actually does the reverse – it will convert backslashes to forward slashes, which can break `Pathname#relative_path_from`.

@param path [String, Pathname] @return [Pathname]

    # File lib/sass/util.rb, line 658
    def cleanpath(path)
      path = Pathname.new(path) unless path.is_a?(Pathname)
      pathname(path.cleanpath.to_s)
    end

deprecated(obj, message = nil) click to toggle source

Prints a deprecation warning for the caller method.

@param obj [Object] `self` @param message [String] A message describing what to do instead.

    # File lib/sass/util.rb, line 469
    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

destructure(val) click to toggle source

Prepare a value for a destructuring assignment (e.g. `a, b = val`). This works around a performance bug when using ActiveSupport, and only needs to be called when `val` is likely to be `nil` reasonably often.

See [this bug report](redmine.ruby-lang.org/issues/4917).

@param val [Object] @return [Object]

    # File lib/sass/util.rb, line 743
    def destructure(val)
      val || []
    end

encode_vlq(value) click to toggle source

Encodes `value` as VLQ (en.wikipedia.org/wiki/VLQ).

@param value [Fixnum] @return [String] The encoded value

    # File lib/sass/util.rb, line 1166
    def encode_vlq(value)
      if value < 0
        value = ((-value) << 1) | 1
      else
        value <<= 1
      end

      result = ''
      begin
        digit = value & VLQ_BASE_MASK
        value >>= VLQ_BASE_SHIFT
        if value > 0
          digit |= VLQ_CONTINUATION_BIT
        end
        result << BASE64_DIGITS[digit]
      end while value > 0
      result
    end

enum_cons(enum, n) click to toggle source

A version of `Enumerable#enum_cons` that works in Ruby 1.8 and 1.9.

@param enum [Enumerable] The enumerable to get the enumerator for @param n [Fixnum] The size of each cons @return [Enumerator] The consed enumerator

    # File lib/sass/util.rb, line 936
    def enum_cons(enum, n)
      ruby1_8? ? enum.enum_cons(n) : enum.each_cons(n)
    end

enum_slice(enum, n) click to toggle source

A version of `Enumerable#enum_slice` that works in Ruby 1.8 and 1.9.

@param enum [Enumerable] The enumerable to get the enumerator for @param n [Fixnum] The size of each slice @return [Enumerator] The consed enumerator

    # File lib/sass/util.rb, line 945
    def enum_slice(enum, n)
      ruby1_8? ? enum.enum_slice(n) : enum.each_slice(n)
    end

enum_with_index(enum) click to toggle source

A version of `Enumerable#enum_with_index` that works in Ruby 1.8 and 1.9.

@param enum [Enumerable] The enumerable to get the enumerator for @return [Enumerator] The with-index enumerator

    # File lib/sass/util.rb, line 927
    def enum_with_index(enum)
      ruby1_8? ? enum.enum_with_index : enum.each_with_index
    end

escape_uri(string) click to toggle source

URI-escape `string`.

@param string [String] @return [String]

    # File lib/sass/util.rb, line 1196
    def escape_uri(string)
      URI_ESCAPE.escape string
    end

extract!(array) { |e| ... } click to toggle source

Destructively removes all elements from an array that match a block, and returns the removed elements.

@param array [Array] The array from which to remove elements. @yield [el] Called for each element. @yieldparam el [*] The element to test. @yieldreturn [Boolean] Whether or not to extract the element. @return [Array] The extracted elements.

    # File lib/sass/util.rb, line 957
    def extract!(array)
      out = []
      array.reject! do |e|
        next false unless yield e
        out << e
        true
      end
      out
    end

extract_values(arr) click to toggle source

Extracts the non-string vlaues from an array containing both strings and non-strings. These values are replaced with escape sequences. This can be undone using {#inject_values}.

This is useful e.g. when we want to do string manipulation on an interpolated string.

The precise format of the resulting string is not guaranteed. However, it is guaranteed that newlines and whitespace won't be affected.

@param arr [Array] The array from which values are extracted. @return [(String, Array)] The resulting string, and an array of extracted values.

    # File lib/sass/util.rb, line 1051
    def extract_values(arr)
      values = []
      mapped = arr.map do |e|
        next e.gsub('{', '{{') if e.is_a?(String)
        values << e
        next "{#{values.count - 1}}"
      end
      return mapped.join, values
    end

file_uri_from_path(path) click to toggle source

Converts `path` to a “file:” URI. This handles Windows paths correctly.

@param path [String, Pathname] @return [String]

    # File lib/sass/util.rb, line 709
    def file_uri_from_path(path)
      path = path.to_s if path.is_a?(Pathname)
      path = path.tr('\', '/') if windows?
      path = Sass::Util.escape_uri(path)
      return path.start_with?('/') ? "file://" + path : path unless windows?
      return "file:///" + path.tr("\\", "/") if path =~ /^[a-zA-Z]:[\/\]/
      return "file:" + path.tr("\\", "/") if path =~ /\\[^\]+\[^\\/]+/
      path.tr("\\", "/")
    end

flatten(arr, n) click to toggle source

Flattens the first `n` nested arrays in a cross-version manner.

@param arr [Array] The array to flatten @param n [Fixnum] The number of levels to flatten @return [Array] The flattened array

    # File lib/sass/util.rb, line 980
    def flatten(arr, n)
      return arr.flatten(n) unless ruby1_8_6?
      return arr if n == 0
      arr.inject([]) {|res, e| e.is_a?(Array) ? res.concat(flatten(e, n - 1)) : res << e}
    end

flatten_vertically(arrs) click to toggle source

Flattens the first level of nested arrays in `arrs`. Unlike `Array#flatten`, this orders the result by taking the first values from each array in order, then the second, and so on.

@param arrs [Array] The array to flatten. @return [Array] The flattened array.

    # File lib/sass/util.rb, line 992
    def flatten_vertically(arrs)
      result = []
      arrs = arrs.map {|sub| sub.is_a?(Array) ? sub.dup : Array(sub)}
      until arrs.empty?
        arrs.reject! do |arr|
          result << arr.shift
          arr.empty?
        end
      end
      result
    end

glob(path) { |f| ... } click to toggle source

Like `Dir.glob`, but works with backslash-separated paths on Windows.

@param path [String]

    # File lib/sass/util.rb, line 629
    def glob(path)
      path = path.gsub('\', '/') if windows?
      if block_given?
        Dir.glob(path) {|f| yield(f)}
      else
        Dir.glob(path)
      end
    end

group_by_to_a(enum) { |e| ... } click to toggle source

Performs the equivalent of `enum.group_by.to_a`, but with a guaranteed order. Unlike {Util#hash_to_a}, the resulting order isn't sorted key order; instead, it's the same order as `#group_by` has under Ruby 1.9 (key appearance order).

@param enum [Enumerable] @return [Array<[Object, Array]>] An array of pairs.

    # File lib/sass/util.rb, line 310
    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 = yield(e)
        unless order.include?(res)
          order[res] = order.size
        end
        res
      end
      groups.each do |key, vals|
        arr[order[key]] = [key, vals]
      end
      arr
    end

has?(attr, klass, method) click to toggle source

Checks to see if a class has a given method. For example:

    Sass::Util.has?(:public_instance_method, String, :gsub) #=> true

Method collections like `Class#instance_methods` return strings in Ruby 1.8 and symbols in Ruby 1.9 and on, so this handles checking for them in a compatible way.

@param attr [#to_s] The (singular) name of the method-collection method

    (e.g. `:instance_methods`, `:private_methods`)

@param klass [Module] The class to check the methods of which to check @param method [String, Symbol] The name of the method do check for @return [Boolean] Whether or not the given collection has the given method

    # File lib/sass/util.rb, line 919
    def has?(attr, klass, method)
      klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
    end

hash_to_a(hash) click to toggle source

Converts a Hash to an Array. This is usually identical to `Hash#to_a`, with the following exceptions:

- In Ruby 1.8, `Hash#to_a` is not deterministically ordered, but this is.

- In Ruby 1.9 when running tests, this is ordered in the same way it would be under Ruby 1.8 (sorted key order rather than insertion order).

@param hash [Hash] @return [Array]

    # File lib/sass/util.rb, line 298
    def hash_to_a(hash)
      return hash.to_a unless ruby1_8? || defined?(Test::Unit)
      hash.sort_by {|k, v| k}
    end

inject_values(str, values) click to toggle source

Undoes {#extract_values} by transforming a string with escape sequences into an array of strings and non-string values.

@param str [String] The string with escape sequences. @param values [Array] The array of values to inject. @return [Array] The array of strings and values.

    # File lib/sass/util.rb, line 1067
    def inject_values(str, values)
      return [str.gsub('{{', '{')] if values.empty?
      # Add an extra { so that we process the tail end of the string
      result = (str + '{{').scan(/(.*?)(?:(\{\{)|\{(\d+)\})/m).map do |(pre, esc, n)|
        [pre, esc ? '{' : '', n ? values[n.to_i] : '']
      end.flatten(1)
      result[-2] = '' # Get rid of the extra {
      merge_adjacent_strings(result).reject {|s| s == ''}
    end

inspect_obj(obj) click to toggle source

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` before being evaluated.

@param obj {Object} @return {String}

    # File lib/sass/util.rb, line 1032
    def inspect_obj(obj)
      return obj.inspect unless version_geq(RUBY_VERSION, "1.9.2")
      return ':' + inspect_obj(obj.to_s) if obj.is_a?(Symbol)
      return obj.inspect unless obj.is_a?(String)
      '"' + obj.gsub(/[\x00-\x7F]+/) {|s| s.inspect[1...-1]} + '"'
    end

intersperse(enum, val) click to toggle source

Intersperses a value in an enumerable, as would be done with `Array#join` but without concatenating the array together afterwards.

@param enum [Enumerable] @param val @return [Array]

    # File lib/sass/util.rb, line 208
    def intersperse(enum, val)
      enum.inject([]) {|a, e| a << e << val}[0...-1]
    end

ironruby?() click to toggle source

Whether or not this is running on IronRuby.

@return [Boolean]

    # File lib/sass/util.rb, line 598
    def ironruby?
      return @ironruby if defined?(@ironruby)
      @ironruby = RUBY_ENGINE == "ironruby"
    end

jruby1_6?() click to toggle source

Wehter or not this is running under JRuby 1.6 or lower.

    # File lib/sass/util.rb, line 789
    def jruby1_6?
      return @jruby1_6 if defined?(@jruby1_6)
      @jruby1_6 = jruby? && jruby_version[0] == 1 && jruby_version[1] < 7
    end

jruby?() click to toggle source

Whether or not this is running on JRuby.

@return [Boolean]

    # File lib/sass/util.rb, line 614
    def jruby?
      return @jruby if defined?(@jruby)
      @jruby = RUBY_PLATFORM =~ /java/
    end

jruby_version() click to toggle source

Returns an array of ints representing the JRuby version number.

@return [Array<Fixnum>]

    # File lib/sass/util.rb, line 622
    def jruby_version
      @jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
    end

json_escape_string(s) click to toggle source

Escapes certain characters so that the result can be used as the JSON string value. Returns the original string if no escaping is necessary.

@param s [String] The string to be escaped @return [String] The escaped string

    # File lib/sass/util.rb, line 1105
    def json_escape_string(s)
      return s if s !~ /["\\b\f\n\r\t]/

      result = ""
      s.split("").each do |c|
        case c
        when '"', "\\"
          result << "\\" << c
        when "\n" then result << "\\n"
        when "\t" then result << "\\t"
        when "\r" then result << "\\r"
        when "\f" then result << "\\f"
        when "\b" then result << "\\b"
        else
          result << c
        end
      end
      result
    end

json_value_of(v) click to toggle source

Converts the argument into a valid JSON value.

@param v [Fixnum, String, Array, Boolean, nil] @return [String]

    # File lib/sass/util.rb, line 1129
    def json_value_of(v)
      case v
      when Fixnum
        v.to_s
      when String
        "\"" + json_escape_string(v) + "\""
      when Array
        "[" + v.map {|x| json_value_of(x)}.join(",") + "]"
      when NilClass
        "null"
      when TrueClass
        "true"
      when FalseClass
        "false"
      else
        raise ArgumentError.new("Unknown type: #{v.class.name}")
      end
    end

lcs(x, y, &block) click to toggle source

Computes a single longest common subsequence for `x` and `y`. If there are more than one longest common subsequences, the one returned is that which starts first in `x`.

@param x [Array] @param y [Array] @yield [a, b] An optional block to use in place of a check for equality

    between elements of `x` and `y`.

@yieldreturn [Object, nil] If the two values register as equal,

    this will return the value to use in the LCS array.

@return [Array] The LCS

    # File lib/sass/util.rb, line 282
    def lcs(x, y, &block)
      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)
    end

listen_geq_2?() click to toggle source

Returns whether this environment is using Listen version 2.0.0 or greater.

@return [Boolean]

    # File lib/sass/util.rb, line 558
    def listen_geq_2?
      return @listen_geq_2 unless @listen_geq_2.nil?
      @listen_geq_2 =
        begin
          require 'listen/version'
          version_geq(::Listen::VERSION, '2.0.0')
        rescue LoadError
          false
        end
    end

load_listen!() click to toggle source

    # File lib/sass/util.rb, line 1271
    def load_listen!
      if defined?(gem)
        begin
          gem 'listen', '>= 1.1.0', '< 3.0.0'
          require 'listen'
        rescue Gem::LoadError
          dir = scope("vendor/listen/lib")
          $LOAD_PATH.unshift dir
          begin
            require 'listen'
          rescue LoadError => e
            if version_geq(RUBY_VERSION, "1.9.3")
              version_constraint = "~> 2.7"
            else
              version_constraint = "~> 1.1"
            end
            e.message << "\n" <<
              "Run \"gem install listen --version '#{version_constraint}'\" to get it."
            raise e
          end
        end
      else
        begin
          require 'listen'
        rescue LoadError => e
          dir = scope("vendor/listen/lib")
          if $LOAD_PATH.include?(dir)
            raise e unless File.exist?(scope(".git"))
            e.message << "\n" <<
              'Run "git submodule update --init" to get the bundled version.'
          else
            $LOAD_PATH.unshift dir
            retry
          end
        end
      end
    end

macruby?() click to toggle source

Whether or not this is running under MacRuby.

@return [Boolean]

    # File lib/sass/util.rb, line 797
    def macruby?
      return @macruby if defined?(@macruby)
      @macruby = RUBY_ENGINE == 'macruby'
    end

map_hash(hash) { |k, v| ... } click to toggle source

Maps the key-value pairs of a hash according to a block.

@example

    map_hash({:foo => "bar", :baz => "bang"}) {|k, v| [k.to_s, v.to_sym]}
      #=> {"foo" => :bar, "baz" => :bang}

@param hash [Hash] The hash to map @yield [key, value] A block in which the key-value pairs are transformed @yieldparam [key] The hash key @yieldparam [value] The hash value @yieldreturn [(Object, Object)] The new value for the `[key, value]` pair @return [Hash] The mapped hash @see map_keys @see map_vals

    # File lib/sass/util.rb, line 98
    def map_hash(hash)
      # 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)
        new_key = hash.denormalize(new_key) if hash.is_a?(NormalizedMap) && new_key == k
        rv[new_key] = new_value
      end
      rv
    end

map_keys(hash) { |k| ... } click to toggle source

Maps the keys in a hash according to a block.

@example

    map_keys({:foo => "bar", :baz => "bang"}) {|k| k.to_s}
      #=> {"foo" => "bar", "baz" => "bang"}

@param hash [Hash] The hash to map @yield [key] A block in which the keys are transformed @yieldparam key [Object] The key that should be mapped @yieldreturn [Object] The new value for the key @return [Hash] The mapped hash @see map_vals @see map_hash

    # File lib/sass/util.rb, line 58
    def map_keys(hash)
      map_hash(hash) {|k, v| [yield(k), v]}
    end

map_vals(hash) { |v| ... } click to toggle source

Maps the values in a hash according to a block.

@example

    map_values({:foo => "bar", :baz => "bang"}) {|v| v.to_sym}
      #=> {:foo => :bar, :baz => :bang}

@param hash [Hash] The hash to map @yield [value] A block in which the values are transformed @yieldparam value [Object] The value that should be mapped @yieldreturn [Object] The new value for the value @return [Hash] The mapped hash @see map_keys @see map_hash

    # File lib/sass/util.rb, line 74
    def map_vals(hash)
      # We don't delegate to map_hash for performance here
      # because map_hash does more than is necessary.
      rv = hash.class.new
      hash = hash.as_stored if hash.is_a?(NormalizedMap)
      hash.each do |k, v|
        rv[k] = yield(v)
      end
      rv
    end

max(val1, val2) click to toggle source

Returns the maximum of `val1` and `val2`. We use this over {Array.max} to avoid unnecessary garbage collection.

    # File lib/sass/util.rb, line 342
    def max(val1, val2)
      val1 > val2 ? val1 : val2
    end

merge_adjacent_strings(arr) click to toggle source

Concatenates all strings that are adjacent in an array, while leaving other elements as they are.

@example

    merge_adjacent_strings([1, "foo", "bar", 2, "baz"])
      #=> [1, "foobar", 2, "baz"]

@param arr [Array] @return [Array] The enumerable with strings merged

    # File lib/sass/util.rb, line 148
    def merge_adjacent_strings(arr)
      # Optimize for the common case of one element
      return arr if arr.size < 2
      arr.inject([]) do |a, e|
        if e.is_a?(String)
          if a.last.is_a?(String)
            a.last << e
          else
            a << e.dup
          end
        else
          a << e
        end
        a
      end
    end

min(val1, val2) click to toggle source

Returns the minimum of `val1` and `val2`. We use this over {Array.min} to avoid unnecessary garbage collection.

    # File lib/sass/util.rb, line 348
    def min(val1, val2)
      val1 <= val2 ? val1 : val2
    end

ord(c) click to toggle source

Returns the ASCII code of the given character.

@param c [String] All characters but the first are ignored. @return [Fixnum] The ASCII code of `c`.

    # File lib/sass/util.rb, line 971
    def ord(c)
      ruby1_8? ? c[0] : c.ord
    end

ordered_hash(*pairs_or_hash) click to toggle source

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]

    # File lib/sass/util.rb, line 821
    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

pathname(path) click to toggle source

Like `Pathname.new`, but normalizes Windows paths to always use backslash separators.

`Pathname#relative_path_from` can break if the two pathnames aren't consistent in their slash style.

@param path [String] @return [Pathname]

    # File lib/sass/util.rb, line 646
    def pathname(path)
      path = path.tr("/", "\\") if windows?
      Pathname.new(path)
    end

paths(arrs) click to toggle source

Return an array of all possible paths through the given arrays.

@param arrs [Array<Array>] @return [Array<Arrays>]

@example

    paths([[1, 2], [3, 4], [5]]) #=>
      # [[1, 3, 5],
      #  [2, 3, 5],
      #  [1, 4, 5],
      #  [2, 4, 5]]

    # File lib/sass/util.rb, line 265
    def paths(arrs)
      arrs.inject([[]]) do |paths, arr|
        flatten(arr.map {|e| paths.map {|path| path + [e]}}, 1)
      end
    end

powerset(arr) click to toggle source

Computes the powerset of the given array. This is the set of all subsets of the array.

@example

    powerset([1, 2, 3]) #=>
      Set[Set[], Set[1], Set[2], Set[3], Set[1, 2], Set[2, 3], Set[1, 3], Set[1, 2, 3]]

@param arr [Enumerable] @return [Set<Set>] The subsets of `arr`

    # File lib/sass/util.rb, line 118
    def powerset(arr)
      arr.inject([Set.new].to_set) do |powerset, el|
        new_powerset = Set.new
        powerset.each do |subset|
          new_powerset << subset
          new_powerset << subset + [el]
        end
        new_powerset
      end
    end

rails_env() click to toggle source

Returns the environment of the Rails application, if this is running in a Rails context. Returns `nil` if no such environment is defined.

@return [String, nil]

    # File lib/sass/util.rb, line 525
    def rails_env
      return ::Rails.env.to_s if defined?(::Rails.env)
      return RAILS_ENV.to_s if defined?(RAILS_ENV)
      nil
    end

rails_root() click to toggle source

Returns the root of the Rails application, if this is running in a Rails context. Returns `nil` if no such root is defined.

@return [String, nil]

    # File lib/sass/util.rb, line 511
    def rails_root
      if defined?(::Rails.root)
        return ::Rails.root.to_s if ::Rails.root
        raise "ERROR: Rails.root is nil!"
      end
      return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
      nil
    end

rbx?() click to toggle source

Whether or not this is running on Rubinius.

@return [Boolean]

    # File lib/sass/util.rb, line 606
    def rbx?
      return @rbx if defined?(@rbx)
      @rbx = RUBY_ENGINE == "rbx"
    end

realpath(path) click to toggle source

Returns `path` with all symlinks resolved.

@param path [String, Pathname] @return [Pathname]

    # File lib/sass/util.rb, line 667
    def realpath(path)
      path = Pathname.new(path) unless path.is_a?(Pathname)

      # Explicitly DON'T run #pathname here. We don't want to convert
      # to Windows directory separators because we're comparing these
      # against the paths returned by Listen, which use forward
      # slashes everywhere.
      begin
        path.realpath
      rescue SystemCallError
        # If [path] doesn't actually exist, don't bail, just
        # return the original.
        path
      end
    end

relative_path_from(path, from) click to toggle source

Returns `path` relative to `from`.

This is like `Pathname#relative_path_from` except it accepts both strings and pathnames, it handles Windows path separators correctly, and it throws an error rather than crashing if the paths use different encodings (github.com/ruby/ruby/pull/713).

@param path [String, Pathname] @param from [String, Pathname] @return [Pathname?]

    # File lib/sass/util.rb, line 693
    def relative_path_from(path, from)
      pathname(path.to_s).relative_path_from(pathname(from.to_s))
    rescue NoMethodError => e
      raise e unless e.name == :zero?

      # Work around https://github.com/ruby/ruby/pull/713.
      path = path.to_s
      from = from.to_s
      raise ArgumentError("Incompatible path encodings: #{path.inspect} is #{path.encoding}, " +
        "#{from.inspect} is #{from.encoding}")
    end

replace_subseq(arr, subseq, replacement) click to toggle source

Non-destructively replaces all occurrences of a subsequence in an array with another subsequence.

@example

    replace_subseq([1, 2, 3, 4, 5], [2, 3], [:a, :b])
      #=> [1, :a, :b, 4, 5]

@param arr [Array] The array whose subsequences will be replaced. @param subseq [Array] The subsequence to find and replace. @param replacement [Array] The sequence that `subseq` will be replaced with. @return [Array] `arr` with `subseq` replaced with `replacement`.

    # File lib/sass/util.rb, line 176
    def replace_subseq(arr, subseq, replacement)
      new = []
      matched = []
      i = 0
      arr.each do |elem|
        if elem != subseq[i]
          new.push(*matched)
          matched = []
          i = 0
          new << elem
          next
        end

        if i == subseq.length - 1
          matched = []
          i = 0
          new.push(*replacement)
        else
          matched << elem
          i += 1
        end
      end
      new.push(*matched)
      new
    end

restrict(value, range) click to toggle source

Restricts a number to falling within a given range. Returns the number if it falls within the range, or the closest value in the range if it doesn't.

@param value [Numeric] @param range [Range<Numeric>] @return [Numeric]

    # File lib/sass/util.rb, line 136
    def restrict(value, range)
      [[value, range.first].max, range.last].min
    end

retry_on_windows() { || ... } click to toggle source

Retries a filesystem operation if it fails on Windows. Windows has weird and flaky locking rules that can cause operations to fail.

@yield [] The filesystem operation.

    # File lib/sass/util.rb, line 723
    def retry_on_windows
      return yield unless windows?

      begin
        yield
      rescue SystemCallError
        sleep 0.1
        yield
      end
    end

ruby1?() click to toggle source

Whether or not this is running under a Ruby version under 2.0.

@return [Boolean]

    # File lib/sass/util.rb, line 752
    def ruby1?
      return @ruby1 if defined?(@ruby1)
      @ruby1 = RUBY_VERSION_COMPONENTS[0] <= 1
    end

ruby1_8?() click to toggle source

Whether or not this is running under Ruby 1.8 or lower.

Note that IronRuby counts as Ruby 1.8, because it doesn't support the Ruby 1.9 encoding API.

@return [Boolean]

    # File lib/sass/util.rb, line 763
    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.
      return @ruby1_8 if defined?(@ruby1_8)
      @ruby1_8 = ironruby? ||
                   (RUBY_VERSION_COMPONENTS[0] == 1 && RUBY_VERSION_COMPONENTS[1] < 9)
    end

ruby1_8_6?() click to toggle source

Whether or not this is running under Ruby 1.8.6 or lower. Note that lower versions are not officially supported.

@return [Boolean]

    # File lib/sass/util.rb, line 775
    def ruby1_8_6?
      return @ruby1_8_6 if defined?(@ruby1_8_6)
      @ruby1_8_6 = ruby1_8? && RUBY_VERSION_COMPONENTS[2] < 7
    end

ruby1_9_2?() click to toggle source

Whether or not this is running under Ruby 1.9.2 exactly.

@return [Boolean]

    # File lib/sass/util.rb, line 783
    def ruby1_9_2?
      return @ruby1_9_2 if defined?(@ruby1_9_2)
      @ruby1_9_2 = RUBY_VERSION_COMPONENTS == [1, 9, 2]
    end

sass_warn(msg) click to toggle source

The same as `Kernel#warn`, but is silenced by {#silence_sass_warnings}.

@param msg [String]

    # File lib/sass/util.rb, line 499
    def sass_warn(msg)
      msg = msg + "\n" unless ruby1?
      Sass.logger.warn(msg)
    end

scope(file) click to toggle source

Returns the path of a file relative to the Sass root directory.

@param file [String] The filename relative to the Sass root @return [String] The filename relative to the the working directory

    # File lib/sass/util.rb, line 31
    def scope(file)
      File.join(Sass::ROOT_DIR, file)
    end

set_eql?(set1, set2) click to toggle source

Tests the hash-equality of two sets in a cross-version manner. Aggravatingly, this is order-dependent in Ruby 1.8.6.

@param set1 [Set] @param set2 [Set] @return [Boolean] Whether or not the sets are hashcode equal

    # File lib/sass/util.rb, line 1020
    def set_eql?(set1, set2)
      return set1.eql?(set2) unless ruby1_8_6?
      set1.to_a.uniq.sort_by {|e| e.hash}.eql?(set2.to_a.uniq.sort_by {|e| e.hash})
    end

set_hash(set) click to toggle source

Returns the hash code for a set in a cross-version manner. Aggravatingly, this is order-dependent in Ruby 1.8.6.

@param set [Set] @return [Fixnum] The order-independent hashcode of `set`

    # File lib/sass/util.rb, line 1009
    def set_hash(set)
      return set.hash unless ruby1_8_6?
      set.map {|e| e.hash}.uniq.sort.hash
    end

silence_sass_warnings() { || ... } click to toggle source

Silences all Sass warnings within a block.

@yield A block in which no Sass warnings will be printed

    # File lib/sass/util.rb, line 489
    def silence_sass_warnings
      old_level, Sass.logger.log_level = Sass.logger.log_level, :error
      yield
    ensure
      Sass.logger.log_level = old_level
    end

silence_warnings() { || ... } click to toggle source

Silence all output to STDERR within a block.

@yield A block in which no output will be printed to STDERR

    # File lib/sass/util.rb, line 479
    def silence_warnings
      the_real_stderr, $stderr = $stderr, StringIO.new
      yield
    ensure
      $stderr = the_real_stderr
    end

slice_by(enum) { |value| ... } click to toggle source

    # File lib/sass/util.rb, line 212
    def slice_by(enum)
      results = []
      enum.each do |value|
        key = yield(value)
        if !results.empty? && results.last.first == key
          results.last.last << value
        else
          results << [key, [value]]
        end
      end
      results
    end

sourcemap_name(css) click to toggle source

Builds a sourcemap file name given the generated CSS file name.

@param css [String] The generated CSS file name. @return [String] The source map file name.

    # File lib/sass/util.rb, line 1095
    def sourcemap_name(css)
      css + ".map"
    end

strip_string_array(arr) click to toggle source

Destructively strips whitespace from the beginning and end of the first and last elements, respectively, in the array (if those elements are strings).

@param arr [Array] @return [Array] `arr`

    # File lib/sass/util.rb, line 248
    def strip_string_array(arr)
      arr.first.lstrip! if arr.first.is_a?(String)
      arr.last.rstrip! if arr.last.is_a?(String)
      arr
    end

subsequence?(seq1, seq2) click to toggle source

Returns whether or not `seq1` is a subsequence of `seq2`. That is, whether or not `seq2` contains every element in `seq1` in the same order (and possibly more elements besides).

@param seq1 [Array] @param seq2 [Array] @return [Boolean]

    # File lib/sass/util.rb, line 393
    def subsequence?(seq1, seq2)
      i = j = 0
      loop do
        return true if i == seq1.size
        return false if j == seq2.size
        i += 1 if seq1[i] == seq2[j]
        j += 1
      end
    end

substitute(ary, from, to) click to toggle source

Substitutes a sub-array of one array with another sub-array.

@param ary [Array] The array in which to make the substitution @param from [Array] The sequence of elements to replace with `to` @param to [Array] The sequence of elements to replace `from` with

    # File lib/sass/util.rb, line 230
    def substitute(ary, from, to)
      res = ary.dup
      i = 0
      while i < res.size
        if res[i...i + from.size] == from
          res[i...i + from.size] = to
        end
        i += 1
      end
      res
    end

to_hash(arr) click to toggle source

Converts an array of `[key, value]` pairs to a hash.

@example

    to_hash([[:foo, "bar"], [:baz, "bang"]])
      #=> {:foo => "bar", :baz => "bang"}

@param arr [Array<(Object, Object)>] An array of pairs @return [Hash] A hash

    # File lib/sass/util.rb, line 42
    def to_hash(arr)
      ordered_hash(*arr.compact)
    end

undefined_conversion_error_char(e) click to toggle source

Returns a string description of the character that caused an `Encoding::UndefinedConversionError`.

@param e [Encoding::UndefinedConversionError] @return [String]

    # File lib/sass/util.rb, line 357
    def undefined_conversion_error_char(e)
      # Rubinius (as of 2.0.0.rc1) pre-quotes the error character.
      return e.error_char if rbx?
      # 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[/^"[^"]+"/] # "
    end

version_geq(v1, v2) click to toggle source

Returns whether one version string represents the same or a more recent version than another.

@param v1 [String] A version string. @param v2 [String] Another version string. @return [Boolean]

    # File lib/sass/util.rb, line 453
    def version_geq(v1, v2)
      version_gt(v1, v2) || !version_gt(v2, v1)
    end

version_gt(v1, v2) click to toggle source

Returns whether one version string represents a more recent version than another.

@param v1 [String] A version string. @param v2 [String] Another version string. @return [Boolean]

    # File lib/sass/util.rb, line 424
    def version_gt(v1, v2)
      # Construct an array to make sure the shorter version is padded with nil
      Array.new([v1.length, v2.length].max).zip(v1.split("."), v2.split(".")) do |_, p1, p2|
        p1 ||= "0"
        p2 ||= "0"
        release1 = p1 =~ /^[0-9]+$/
        release2 = p2 =~ /^[0-9]+$/
        if release1 && release2
          # Integer comparison if both are full releases
          p1, p2 = p1.to_i, p2.to_i
          next if p1 == p2
          return p1 > p2
        elsif !release1 && !release2
          # String comparison if both are prereleases
          next if p1 == p2
          return p1 > p2
        else
          # If only one is a release, that one is newer
          return release1
        end
      end
    end

windows?() click to toggle source

Whether or not this is running on Windows.

@return [Boolean]

    # File lib/sass/util.rb, line 590
    def windows?
      return @windows if defined?(@windows)
      @windows = (RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i)
    end

with_extracted_values(arr) { |str| ... } click to toggle source

Allows modifications to be performed on the string form of an array containing both strings and non-strings.

@param arr [Array] The array from which values are extracted. @yield [str] A block in which string manipulation can be done to the array. @yieldparam str [String] The string form of `arr`. @yieldreturn [String] The modified string. @return [Array] The modified, interpolated array.

    # File lib/sass/util.rb, line 1085
    def with_extracted_values(arr)
      str, vals = extract_values(arr)
      str = yield str
      inject_values(str, vals)
    end

### Private Instance Methods

find_encoding_error(str) click to toggle source

    # File lib/sass/util.rb, line 1311
    def find_encoding_error(str)
      encoding = str.encoding
      cr = Regexp.quote("\r".encode(encoding).force_encoding('BINARY'))
      lf = Regexp.quote("\n".encode(encoding).force_encoding('BINARY'))
      ff = Regexp.quote("\f".encode(encoding).force_encoding('BINARY'))
      line_break = /#{cr}#{lf}?|#{ff}|#{lf}/

      str.force_encoding("binary").split(line_break).each_with_index do |line, i|
        begin
          line.encode(encoding)
        rescue Encoding::UndefinedConversionError => e
          raise Sass::SyntaxError.new(
            "Invalid #{encoding.name} character #{undefined_conversion_error_char(e)}",
            :line => i + 1)
        end
      end

      # We shouldn't get here, but it's possible some weird encoding stuff causes it.
      return str, str.encoding
    end

lcs_backtrace(c, x, y, i, j) { |x, y| ... } click to toggle source

Computes a single longest common subsequence for arrays x and y. Algorithm from [Wikipedia](en.wikipedia.org/wiki/Longest_common_subsequence_problem#Reading_out_an_LCS)

    # File lib/sass/util.rb, line 1358
    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
      end

      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

lcs_table(x, y) { |x, y| ... } click to toggle source

Calculates the memoization table for the Least Common Subsequence algorithm. Algorithm from [Wikipedia](en.wikipedia.org/wiki/Longest_common_subsequence_problem#Computing_the_length_of_the_LCS)

    # File lib/sass/util.rb, line 1336
    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}
      y.size.times {|j| c[0][j] = 0}
      (1...x.size).each do |i|
        (1...y.size).each do |j|
          c[i][j] =
            if yield x[i], y[j]
              c[i - 1][j - 1] + 1
            else
              [c[i][j - 1], c[i - 1][j]].max
            end
        end
      end
      c
    end