Class/Module Index [+]

Quicksearch

Sass::Util

A module containing various useful functions.

Constants

CHARSET_REGEXPS
ENCODINGS_TO_CHECK

We could automatically add in any non-ASCII-compatible encodings here, but there's not really a good way to do that without manually checking that each encoding encodes all ASCII characters properly, which takes long enough to affect the startup time of the CLI.

RUBY_ENGINE

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

RUBY_VERSION

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

Public Instance Methods

_enc(string, encoding) click to toggle source

@private

# File lib/sass/util.rb, line 493
def _enc(string, encoding)
  string.encode(encoding).force_encoding("BINARY")
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 277
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 351
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 340
def ap_geq_3?
  ap_geq?("3.0.0.beta1")
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 367
def av_template_class(name)
  return ActionView.const_get("Template#{name}") if ActionView.const_defined?("Template#{name}")
  return ActionView::Template.const_get(name.to_s)
end
caller_info(entry = caller[1]) 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 227
def caller_info(entry = caller[1])
  info = entry.scan(/^(.*?):(-?.*?)(?::.*`(.+)')?$/).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_encoding(str) click to toggle source

Checks that the encoding of a string is valid in Ruby 1.9 and cleans up potential encoding gotchas like the UTF-8 BOM. If it's not, yields an error string describing the invalid character and the line on which it occurrs.

@param str [String] The string of which to check the encoding @yield [msg] A block in which an encoding error can be raised.

Only yields if there is an encoding error

@yieldparam msg [String] The error message to be raised @return [String] `str`, potentially with encoding gotchas like BOMs removed

# File lib/sass/util.rb, line 420
    def check_encoding(str)
      if ruby1_8?
        return str.gsub(/\A\xEF\xBB\xBF/, '') # Get rid of the UTF-8 BOM
      elsif str.valid_encoding?
        # Get rid of the Unicode BOM if possible
        if str.encoding.name =~ /^UTF-(8|16|32)(BE|LE)?$/
          return str.gsub(Regexp.new("\\A\uFEFF".encode(str.encoding.name)), '')
        else
          return str
        end
      end

      encoding = str.encoding
      newlines = Regexp.new("\r\n|\r|\n".encode(encoding).force_encoding("binary"))
      str.force_encoding("binary").split(newlines).each_with_index do |line, i|
        begin
          line.encode(encoding)
        rescue Encoding::UndefinedConversionError => e
          yield <<MSG.rstrip, i + 1
Invalid #{encoding.name} character #{e.error_char.dump}
MSG
        end
      end
      return str
    end
check_sass_encoding(str, &block) 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.

The Sass encoding rules are simple. If a `@charset` declaration exists, we assume that that's the original encoding of the document. Otherwise, we use whatever encoding Ruby has. Then we convert that to UTF-8 to process internally. The UTF-8 end result is what's returned by this method.

@param str [String] The string of which to check the encoding @yield [msg] A block in which an encoding error can be raised.

Only yields if there is an encoding error

@yieldparam msg [String] The error message to be raised @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`

# File lib/sass/util.rb, line 465
def check_sass_encoding(str, &block)
  return check_encoding(str, &block), nil if ruby1_8?
  # We allow any printable ASCII characters but double quotes in the charset decl
  bin = str.dup.force_encoding("BINARY")
  encoding = Sass::Util::ENCODINGS_TO_CHECK.find do |enc|
    bin =~ Sass::Util::CHARSET_REGEXPS[enc]
  end
  charset, bom = $1, $2
  if charset
    charset = charset.force_encoding(encoding).encode("UTF-8")
    if endianness = encoding[/[BL]E$/]
      begin
        Encoding.find(charset + endianness)
        charset << endianness
      rescue ArgumentError # Encoding charset + endianness doesn't exist
      end
    end
    str.force_encoding(charset)
  elsif bom
    str.force_encoding(encoding)
  end

  str = check_encoding(str, &block)
  return str.encode("UTF-8"), str.encoding
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 549
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 558
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 540
def enum_with_index(enum)
  ruby1_8? ? enum.enum_with_index : enum.each_with_index
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 575
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
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 532
def has?(attr, klass, method)
  klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
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 608
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 154
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 384
def ironruby?
  RUBY_ENGINE == "ironruby"
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 215
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
map_hash(hash, &block) 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 89
def map_hash(hash, &block)
  to_hash(hash.map(&block))
end
map_keys(hash) 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 56
def map_keys(hash)
  to_hash(hash.map {|k, v| [yield(k), v]})
end
map_vals(hash) 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 72
def map_vals(hash)
  to_hash(hash.map {|k, v| [k, yield(v)]})
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 131
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
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 566
def ord(c)
  ruby1_8? ? c[0] : c.ord
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 198
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 101
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 330
def rails_env
  return ::Rails.env.to_s if defined?(::Rails.env)
  return RAILS_ENV.to_s if defined?(RAILS_ENV)
  return 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 316
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)
  return nil
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 119
def restrict(value, range)
  [[value, range.first].max, range.last].min
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 396
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.
  ironruby? || (Sass::Util::RUBY_VERSION[0] == 1 && Sass::Util::RUBY_VERSION[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 406
def ruby1_8_6?
  ruby1_8? && Sass::Util::RUBY_VERSION[2] < 7
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 305
def sass_warn(msg)
  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 29
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 597
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 586
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 295
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 284
def silence_warnings
  the_real_stderr, $stderr = $stderr, StringIO.new
  yield
ensure
  $stderr = the_real_stderr
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 181
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
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 163
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 40
def to_hash(arr)
  Hash[arr.compact]
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 269
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 240
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 377
def windows?
  RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.