Module: Sass::Util

Extended by:
Util
Included in:
Util
Defined in:
/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb,
/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util/cross_platform_random.rb,
/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util/normalized_map.rb,
/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util/subset_map.rb,
/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util/test.rb

Overview

A module containing various useful functions.

Defined Under Namespace

Modules: Test Classes: CrossPlatformRandom, MultibyteStringScanner, NormalizedMap, StaticConditionalContext, SubsetMap

Constant Summary

RUBY_VERSION_COMPONENTS =

An array of ints representing the Ruby version number.

RUBY_VERSION.split(".").map {|s| s.to_i}
RUBY_ENGINE =

The Ruby engine we’re running under. Defaults to "ruby" if the top-level constant is undefined.

defined?(::RUBY_ENGINE) ? ::RUBY_ENGINE : "ruby"

Instance Method Summary (collapse)

Instance Method Details

- (String) absolute_path(path, dir_string = nil)

A cross-platform implementation of File.absolute_path.

Parameters:

  • path (String)
  • dir_string (String) (defaults to: nil) —

    The directory to consider [path] relative to.

Returns:

  • (String) —

    The absolute version of path.



1183
1184
1185
1186
1187
1188
1189
1190
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1183

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)

Throws a NotImplementedError for an abstract method.

Parameters:

  • obj (Object) —

    self

Raises:

  • (NotImplementedError) 


476
477
478
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 476

def abstract(obj)
  raise NotImplementedError.new("#{obj.class} must implement ##{caller_info[2]}")
end

- (Boolean) ap_geq?(version)

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

Parameters:

  • 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

Returns:

  • (Boolean) 


561
562
563
564
565
566
567
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 561

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

- (Boolean) ap_geq_3?

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

Returns:

  • (Boolean) 


550
551
552
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 550

def ap_geq_3?
  ap_geq?("3.0.0.beta1")
end

- (Array) array_minus(minuend, subtrahend)

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#-.

Parameters:

  • minuend (Array)
  • subtrahend (Array)

Returns:

  • (Array) 


349
350
351
352
353
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 349

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| ... }

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.

Parameters:

  • filename (String) —

    The file to write to.

  • perms (Integer) (defaults to: 0666) —

    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.

Yield Parameters:

  • tmpfile (Tempfile) —

    The temp file that can be written to.

Returns:

  • The value returned by the block.



1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1226

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)

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.

Parameters:

  • name (#to_s) —

    The name of the class to get. For example, :Error will return ActionView::TemplateError or ActionView::Template::Error.



595
596
597
598
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 595

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

- ([String, Fixnum, (String, nil)]) caller_info(entry = nil)

Returns information about the caller of the previous method.

Parameters:

  • entry (String) (defaults to: nil) —

    An entry in the #caller list, or a similarly formatted string

Returns:

  • ([String, Fixnum, (String, nil)]) —

    An array containing the filename, line, and method name of the caller. The method name may be nil



424
425
426
427
428
429
430
431
432
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 424

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

- (Numeric) check_range(name, range, value, unit = '')

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

Parameters:

  • name (String) —

    The name of the value. Used in the error message.

  • range (Range) —

    The allowed range of values.

  • value (Numeric, Sass::Script::Value::Number) —

    The value to check.

  • unit (String) (defaults to: '') —

    The unit of the value. Used in error reporting.

Returns:

  • (Numeric) —

    value adjusted to fall within range, if it was outside by a floating-point margin.

Raises:

  • (ArgumentError) 


390
391
392
393
394
395
396
397
398
399
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 390

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

- ((String, Encoding)) check_sass_encoding(str)

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.

Parameters:

  • str (String) —

    The string of which to check the encoding

Returns:

  • ((String, Encoding)) —

    The original string encoded as UTF-8, and the source encoding of the string (or nil under Ruby 1.8)

Raises:

  • (Encoding::UndefinedConversionError) —

    if the source encoding cannot be converted to UTF-8

  • (ArgumentError) —

    if the document uses an unknown encoding with @charset

  • (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.



863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 863

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

- (Pathname) cleanpath(path)

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.

Parameters:

  • path (String, Pathname)

Returns:

  • (Pathname) 


676
677
678
679
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 676

def cleanpath(path)
  path = Pathname.new(path) unless path.is_a?(Pathname)
  pathname(path.cleanpath.to_s)
end

- deprecated(obj, message = nil)

Prints a deprecation warning for the caller method.

Parameters:

  • obj (Object) —

    self

  • message (String) (defaults to: nil) —

    A message describing what to do instead.



484
485
486
487
488
489
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 484

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

- (Object) destructure(val)

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.

Parameters:

  • val (Object)

Returns:

  • (Object) 


761
762
763
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 761

def destructure(val)
  val || []
end

- (String) encode_vlq(value)

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

Parameters:

  • value (Fixnum)

Returns:

  • (String) —

    The encoded value



1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1144

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

- (Enumerator) enum_cons(enum, n)

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

Parameters:

  • enum (Enumerable) —

    The enumerable to get the enumerator for

  • n (Fixnum) —

    The size of each cons

Returns:

  • (Enumerator) —

    The consed enumerator



946
947
948
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 946

def enum_cons(enum, n)
  ruby1_8? ? enum.enum_cons(n) : enum.each_cons(n)
end

- (Enumerator) enum_slice(enum, n)

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

Parameters:

  • enum (Enumerable) —

    The enumerable to get the enumerator for

  • n (Fixnum) —

    The size of each slice

Returns:

  • (Enumerator) —

    The consed enumerator



955
956
957
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 955

def enum_slice(enum, n)
  ruby1_8? ? enum.enum_slice(n) : enum.each_slice(n)
end

- (Enumerator) enum_with_index(enum)

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

Parameters:

  • enum (Enumerable) —

    The enumerable to get the enumerator for

Returns:

  • (Enumerator) —

    The with-index enumerator



937
938
939
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 937

def enum_with_index(enum)
  ruby1_8? ? enum.enum_with_index : enum.each_with_index
end

- (String) escape_uri(string)

URI-escape string.

Parameters:

  • string (String)

Returns:

  • (String) 


1174
1175
1176
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1174

def escape_uri(string)
  URI_ESCAPE.escape string
end

- (Array) extract!(array) {|el| ... }

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

Parameters:

  • array (Array) —

    The array from which to remove elements.

Yields:

  • (el) —

    Called for each element.

Yield Parameters:

  • el (*) —

    The element to test.

Yield Returns:

  • (Boolean) —

    Whether or not to extract the element.

Returns:

  • (Array) —

    The extracted elements.



967
968
969
970
971
972
973
974
975
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 967

def extract!(array)
  out = []
  array.reject! do |e|
    next false unless yield e
    out << e
    true
  end
  out
end

- ((String, Array)) extract_values(arr)

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.

Parameters:

  • arr (Array) —

    The array from which values are extracted.

Returns:

  • ((String, Array)) —

    The resulting string, and an array of extracted values.



1029
1030
1031
1032
1033
1034
1035
1036
1037
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1029

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

- (String) file_uri_from_path(path)

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

Parameters:

  • path (String, Pathname)

Returns:

  • (String) 


727
728
729
730
731
732
733
734
735
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 727

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 =~ %r{^[a-zA-Z]:[/\\]}
  return "file:" + path.tr("\\", "/") if path =~ %r{\\\\[^\\]+\\[^\\/]+}
  path.tr("\\", "/")
end

- (Array) flatten_vertically(arrs)

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.

Parameters:

  • arrs (Array) —

    The array to flatten.

Returns:

  • (Array) —

    The flattened array.



991
992
993
994
995
996
997
998
999
1000
1001
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 991

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)

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

Parameters:

  • path (String) 


647
648
649
650
651
652
653
654
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 647

def glob(path)
  path = path.tr('\\', '/') if windows?
  if block_given?
    Dir.glob(path) {|f| yield(f)}
  else
    Dir.glob(path)
  end
end

- (Array<[Object, Array]>) group_by_to_a(enum)

Performs the equivalent of enum.group_by.to_a, but with a guaranteed order. Unlike #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).

Parameters:

  • enum (Enumerable)

Returns:

  • (Array<[Object, Array]>) —

    An array of pairs.



325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 325

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

- (Boolean) has?(attr, klass, method)

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.

Parameters:

  • attr (#to_s) —

    The (singular) name of the method-collection method (e.g. :instance_methods, :private_methods)

  • klass (Module) —

    The class to check the methods of which to check

  • method (String, Symbol) —

    The name of the method do check for

Returns:

  • (Boolean) —

    Whether or not the given collection has the given method



929
930
931
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 929

def has?(attr, klass, method)
  klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
end

- (Array) hash_to_a(hash)

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).

Parameters:

  • hash (Hash)

Returns:

  • (Array) 


313
314
315
316
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 313

def hash_to_a(hash)
  return hash.to_a unless ruby1_8? || defined?(Test::Unit)
  hash.sort_by {|k, _v| k}
end

- (Array) inject_values(str, values)

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

Parameters:

  • str (String) —

    The string with escape sequences.

  • values (Array) —

    The array of values to inject.

Returns:

  • (Array) —

    The array of strings and values.



1045
1046
1047
1048
1049
1050
1051
1052
1053
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1045

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

- (String) inspect_obj(obj)

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 #encoded into @options[:encoding] before being evaluated.

Parameters:

  • obj (Object)

Returns:

  • (String) 


1010
1011
1012
1013
1014
1015
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1010

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

- (Array) intersperse(enum, val)

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

Parameters:

  • enum (Enumerable)
  • val

Returns:

  • (Array) 


223
224
225
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 223

def intersperse(enum, val)
  enum.inject([]) {|a, e| a << e << val}[0...-1]
end

- (Boolean) ironruby?

Whether or not this is running on IronRuby.

Returns:

  • (Boolean) 


616
617
618
619
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 616

def ironruby?
  return @ironruby if defined?(@ironruby)
  @ironruby = RUBY_ENGINE == "ironruby"
end

- (Boolean) jruby1_6?

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

Returns:

  • (Boolean) 


798
799
800
801
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 798

def jruby1_6?
  return @jruby1_6 if defined?(@jruby1_6)
  @jruby1_6 = jruby? && jruby_version[0] == 1 && jruby_version[1] < 7
end

- (Boolean) jruby?

Whether or not this is running on JRuby.

Returns:

  • (Boolean) 


632
633
634
635
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 632

def jruby?
  return @jruby if defined?(@jruby)
  @jruby = RUBY_PLATFORM =~ /java/
end

- (Array<Fixnum>) jruby_version

Returns an array of ints representing the JRuby version number.

Returns:

  • (Array<Fixnum>) 


640
641
642
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 640

def jruby_version
  @jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
end

- (String) json_escape_string(s)

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

Parameters:

  • s (String) —

    The string to be escaped

Returns:

  • (String) —

    The escaped string



1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1083

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

- (String) json_value_of(v)

Converts the argument into a valid JSON value.

Parameters:

  • v (Fixnum, String, Array, Boolean, nil)

Returns:

  • (String) 


1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1107

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

- (Array) lcs(x, y) {|a, b| ... }

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.

Parameters:

  • x (Array)
  • y (Array)

Yields:

  • (a, b) —

    An optional block to use in place of a check for equality between elements of x and y.

Yield Returns:

  • (Object, nil) —

    If the two values register as equal, this will return the value to use in the LCS array.

Returns:

  • (Array) —

    The LCS



297
298
299
300
301
302
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 297

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

- (Boolean) listen_geq_2?

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

Returns:

  • (Boolean) 


573
574
575
576
577
578
579
580
581
582
583
584
585
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 573

def listen_geq_2?
  return @listen_geq_2 if defined?(@listen_geq_2)
  @listen_geq_2 =
    begin
      # Make sure we're loading listen/version from the same place that
      # we're loading listen itself.
      load_listen!
      require 'listen/version'
      version_geq(::Listen::VERSION, '2.0.0')
    rescue LoadError
      false
    end
end

- load_listen! 



1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1249

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 = "~> 3.0"
        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

- (Boolean) macruby?

Whether or not this is running under MacRuby.

Returns:

  • (Boolean) 


806
807
808
809
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 806

def macruby?
  return @macruby if defined?(@macruby)
  @macruby = RUBY_ENGINE == 'macruby'
end

- (Hash) map_hash(hash) {|key, value| ... }

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

Examples:

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

Parameters:

  • hash (Hash) —

    The hash to map

Yields:

  • (key, value) —

    A block in which the key-value pairs are transformed

Yield Parameters:

  • The (key) —

    hash key

  • The (value) —

    hash value

Yield Returns:

  • ((Object, Object)) —

    The new value for the [key, value] pair

Returns:

  • (Hash) —

    The mapped hash

See Also:



101
102
103
104
105
106
107
108
109
110
111
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 101

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

- (Hash) map_keys(hash) {|key| ... }

Maps the keys in a hash according to a block.

Examples:

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

Parameters:

  • hash (Hash) —

    The hash to map

Yields:

  • (key) —

    A block in which the keys are transformed

Yield Parameters:

  • key (Object) —

    The key that should be mapped

Yield Returns:

  • (Object) —

    The new value for the key

Returns:

  • (Hash) —

    The mapped hash

See Also:



61
62
63
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 61

def map_keys(hash)
  map_hash(hash) {|k, v| [yield(k), v]}
end

- (Hash) map_vals(hash) {|value| ... }

Maps the values in a hash according to a block.

Examples:

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

Parameters:

  • hash (Hash) —

    The hash to map

Yields:

  • (value) —

    A block in which the values are transformed

Yield Parameters:

  • value (Object) —

    The value that should be mapped

Yield Returns:

  • (Object) —

    The new value for the value

Returns:

  • (Hash) —

    The mapped hash

See Also:



77
78
79
80
81
82
83
84
85
86
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 77

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)

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



357
358
359
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 357

def max(val1, val2)
  val1 > val2 ? val1 : val2
end

- (Array) merge_adjacent_strings(arr)

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

Examples:

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

Parameters:

  • arr (Array)

Returns:

  • (Array) —

    The enumerable with strings merged



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 163

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)

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



363
364
365
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 363

def min(val1, val2)
  val1 <= val2 ? val1 : val2
end

- (Fixnum) ord(c)

Returns the ASCII code of the given character.

Parameters:

  • c (String) —

    All characters but the first are ignored.

Returns:

  • (Fixnum) —

    The ASCII code of c.



981
982
983
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 981

def ord(c)
  ruby1_8? ? c[0] : c.ord
end

- (Hash) ordered_hash(hash) - (Hash) ordered_hash(*pairs)

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.

Overloads:

  • - (Hash) ordered_hash(hash)

    Parameters:

    • hash (Hash) —

      a normal hash to convert to an ordered hash

    Returns:

    • (Hash)
  • - (Hash) ordered_hash(*pairs)

    Examples:

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

    Parameters:

    • pairs (Array<(Object, Object)>) —

      the list of key/value pairs for the hash.

    Returns:

    • (Hash) 


830
831
832
833
834
835
836
837
838
839
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 830

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)[*pairs_or_hash.flatten(1)]
end

- (Pathname) pathname(path)

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.

Parameters:

  • path (String)

Returns:

  • (Pathname) 


664
665
666
667
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 664

def pathname(path)
  path = path.tr("/", "\\") if windows?
  Pathname.new(path)
end

- (Array<Arrays>) paths(arrs)

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

Examples:

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

Parameters:

  • arrs (Array<Array>)

Returns:

  • (Array<Arrays>) 


280
281
282
283
284
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 280

def paths(arrs)
  arrs.inject([[]]) do |paths, arr|
    arr.map {|e| paths.map {|path| path + [e]}}.flatten(1)
  end
end

- (Set<Set>) powerset(arr)

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

Examples:

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]]

Parameters:

  • arr (Enumerable)

Returns:

  • (Set<Set>) —

    The subsets of arr



121
122
123
124
125
126
127
128
129
130
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 121

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

- (String?) rails_env

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

Returns:

  • (String, nil) 


540
541
542
543
544
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 540

def rails_env
  return ::Rails.env.to_s if defined?(::Rails.env)
  return RAILS_ENV.to_s if defined?(RAILS_ENV)
  nil
end

- (String?) rails_root

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

Returns:

  • (String, nil) 


526
527
528
529
530
531
532
533
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 526

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

- (Boolean) rbx?

Whether or not this is running on Rubinius.

Returns:

  • (Boolean) 


624
625
626
627
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 624

def rbx?
  return @rbx if defined?(@rbx)
  @rbx = RUBY_ENGINE == "rbx"
end

- (Pathname) realpath(path)

Returns path with all symlinks resolved.

Parameters:

  • path (String, Pathname)

Returns:

  • (Pathname) 


685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 685

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

- (Pathname?) relative_path_from(path, from)

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 (https://github.com/ruby/ruby/pull/713).

Parameters:

  • path (String, Pathname)
  • from (String, Pathname)

Returns:

  • (Pathname?) 


711
712
713
714
715
716
717
718
719
720
721
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 711

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

- (Array) replace_subseq(arr, subseq, replacement)

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

Examples:

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

Parameters:

  • arr (Array) —

    The array whose subsequences will be replaced.

  • subseq (Array) —

    The subsequence to find and replace.

  • replacement (Array) —

    The sequence that subseq will be replaced with.

Returns:

  • (Array) —

    arr with subseq replaced with replacement.



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 191

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

- (Numeric) restrict(value, range)

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.

Parameters:

  • value (Numeric)
  • range (Range<Numeric>)

Returns:

  • (Numeric) 


139
140
141
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 139

def restrict(value, range)
  [[value, range.first].max, range.last].min
end

- retry_on_windows { ... }

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

Yields:

  • [] The filesystem operation.



741
742
743
744
745
746
747
748
749
750
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 741

def retry_on_windows
  return yield unless windows?

  begin
    yield
  rescue SystemCallError
    sleep 0.1
    yield
  end
end

- (Numeric) round(value)

Like [Fixnum.round], but leaves rooms for slight floating-point differences.

Parameters:

  • value (Numeric)

Returns:

  • (Numeric) 


148
149
150
151
152
153
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 148

def round(value)
  # If the number is within epsilon of X.5, round up (or down for negative
  # numbers).
  return value.round if (value % 1) - 0.5 <= -1 * Script::Value::Number.epsilon
  value > 0 ? value.ceil : value.floor
end

- (Boolean) ruby1?

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

Returns:

  • (Boolean) 


770
771
772
773
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 770

def ruby1?
  return @ruby1 if defined?(@ruby1)
  @ruby1 = RUBY_VERSION_COMPONENTS[0] <= 1
end

- (Boolean) ruby1_8?

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.

Returns:

  • (Boolean) 


781
782
783
784
785
786
787
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 781

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

- (Boolean) ruby1_9_2?

Whether or not this is running under Ruby 1.9.2 exactly.

Returns:

  • (Boolean) 


792
793
794
795
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 792

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)

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

Parameters:

  • msg (String) 


514
515
516
517
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 514

def sass_warn(msg)
  msg += "\n" unless ruby1?
  Sass.logger.warn(msg)
end

- (String) scope(file)

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

Parameters:

  • file (String) —

    The filename relative to the Sass root

Returns:

  • (String) —

    The filename relative to the the working directory



34
35
36
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 34

def scope(file)
  File.join(Sass::ROOT_DIR, file)
end

- silence_sass_warnings { ... }

Silences all Sass warnings within a block.

Yields:

  • A block in which no Sass warnings will be printed



504
505
506
507
508
509
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 504

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 { ... }

Silence all output to STDERR within a block.

Yields:

  • A block in which no output will be printed to STDERR



494
495
496
497
498
499
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 494

def silence_warnings
  the_real_stderr, $stderr = $stderr, StringIO.new
  yield
ensure
  $stderr = the_real_stderr
end

- slice_by(enum) 



227
228
229
230
231
232
233
234
235
236
237
238
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 227

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

- (String) sourcemap_name(css)

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

Parameters:

  • css (String) —

    The generated CSS file name.

Returns:

  • (String) —

    The source map file name.



1073
1074
1075
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1073

def sourcemap_name(css)
  css + ".map"
end

- (Array) strip_string_array(arr)

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

Parameters:

  • arr (Array)

Returns:

  • (Array) —

    arr



263
264
265
266
267
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 263

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

- (Boolean) subsequence?(seq1, seq2)

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).

Parameters:

  • seq1 (Array)
  • seq2 (Array)

Returns:

  • (Boolean) 


408
409
410
411
412
413
414
415
416
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 408

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)

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

Parameters:

  • ary (Array) —

    The array in which to make the substitution

  • from (Array) —

    The sequence of elements to replace with to

  • to (Array) —

    The sequence of elements to replace from with



245
246
247
248
249
250
251
252
253
254
255
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 245

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

- (Hash) to_hash(arr)

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

Examples:

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

Parameters:

  • arr (Array<(Object, Object)>) —

    An array of pairs

Returns:

  • (Hash) —

    A hash



45
46
47
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 45

def to_hash(arr)
  ordered_hash(*arr.compact)
end

- (String) undefined_conversion_error_char(e)

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

Parameters:

  • e (Encoding::UndefinedConversionError)

Returns:

  • (String) 


372
373
374
375
376
377
378
379
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 372

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

- (Boolean) version_geq(v1, v2)

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

Parameters:

  • v1 (String) —

    A version string.

  • v2 (String) —

    Another version string.

Returns:

  • (Boolean) 


468
469
470
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 468

def version_geq(v1, v2)
  version_gt(v1, v2) || !version_gt(v2, v1)
end

- (Boolean) version_gt(v1, v2)

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

Parameters:

  • v1 (String) —

    A version string.

  • v2 (String) —

    Another version string.

Returns:

  • (Boolean) 


439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 439

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

- (Boolean) windows?

Whether or not this is running on Windows.

Returns:

  • (Boolean) 


608
609
610
611
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 608

def windows?
  return @windows if defined?(@windows)
  @windows = (RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i)
end

- (Array) with_extracted_values(arr) {|str| ... }

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

Parameters:

  • arr (Array) —

    The array from which values are extracted.

Yields:

  • (str) —

    A block in which string manipulation can be done to the array.

Yield Parameters:

  • str (String) —

    The string form of arr.

Yield Returns:

  • (String) —

    The modified string.

Returns:

  • (Array) —

    The modified, interpolated array.



1063
1064
1065
1066
1067
 
# File '/Users/ceppstei/Projects/sass-lang/.sass/lib/sass/util.rb', line 1063

def with_extracted_values(arr)
  str, vals = extract_values(arr)
  str = yield str
  inject_values(str, vals)
end