Module: Sass::Util
- Extended by:
- Util
- Included in:
- Engine, Plugin, Plugin::Compiler, Script::Color, Util, Version
- Defined in:
- lib/sass/util.rb,
lib/sass/util/test.rb,
lib/sass/util/subset_map.rb
Overview
A module containing various useful functions.
Defined Under Namespace
Modules: Test Classes: MultibyteStringScanner, StaticConditionalContext, SubsetMap
Constant Summary collapse
- RUBY_VERSION =
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"
- 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.
%w[UTF-8 UTF-16BE UTF-16LE UTF-32BE UTF-32LE]
- CHARSET_REGEXPS =
Hash.new do |h, e| h[e] = begin # /\A(?:\uFEFF)?@charset "(.*?)"|\A(\uFEFF)/ Regexp.new(/\A(?:#{_enc("\uFEFF", e)})?#{ _enc('@charset "', e)}(.*?)#{_enc('"', e)}|\A(#{ _enc("\uFEFF", e)})/) rescue Encoding::ConverterNotFoundError => _ nil # JRuby on Java 5 doesn't support UTF-32 rescue # /\A@charset "(.*?)"/ Regexp.new(/\A#{_enc('@charset "', e)}(.*?)#{_enc('"', e)}/) end end
- @@silence_warnings =
false
Instance Method Summary collapse
-
#abstract(obj)
Throws a NotImplementedError for an abstract method.
-
#ap_geq?(version) ⇒ Boolean
Returns whether this environment is using ActionPack of a version greater than or equal to that specified.
-
#ap_geq_3? ⇒ Boolean
Returns whether this environment is using ActionPack version 3.0.0 or greater.
-
#array_minus(minuend, subtrahend) ⇒ Array
Returns a sub-array of
minuend
containing only elements that are also insubtrahend
. -
#atomic_create_and_write_file(filename) {|tmpfile| ... }
This creates a temp file and yields it for writing.
-
#av_template_class(name)
Returns an ActionView::Template* class.
-
#caller_info(entry = nil) ⇒ [String, Fixnum, (String, nil)]
Returns information about the caller of the previous method.
-
#check_encoding(str) {|msg| ... } ⇒ String
Checks that the encoding of a string is valid in Ruby 1.9 and cleans up potential encoding gotchas like the UTF-8 BOM.
-
#check_range(name, range, value, unit = '') ⇒ Numeric
Asserts that
value
falls withinrange
(inclusive), leaving room for slight floating-point errors. -
#check_sass_encoding(str) {|msg| ... } ⇒ (String, Encoding)
Like #check_encoding, but also checks for a
@charset
declaration at the beginning of the file and uses that encoding if it exists. -
#destructure(val) ⇒ Object
Prepare a value for a destructuring assignment (e.g.
a, b = val
). -
#enum_cons(enum, n) ⇒ Enumerator
A version of
Enumerable#enum_cons
that works in Ruby 1.8 and 1.9. -
#enum_slice(enum, n) ⇒ Enumerator
A version of
Enumerable#enum_slice
that works in Ruby 1.8 and 1.9. -
#enum_with_index(enum) ⇒ Enumerator
A version of
Enumerable#enum_with_index
that works in Ruby 1.8 and 1.9. -
#extract!(array) {|el| ... } ⇒ Array
Destructively removes all elements from an array that match a block, and returns the removed elements.
-
#extract_values(arr) ⇒ (String, Array)
Extracts the non-string vlaues from an array containing both strings and non-strings.
-
#flatten(arr, n) ⇒ Array
Flattens the first
n
nested arrays in a cross-version manner. -
#glob(path, &block)
Like
Dir.glob
, but works with backslash-separated paths on Windows. -
#group_by_to_a(enum, &block) ⇒ Array<[Object, Array]>
Performs the equivalent of
enum.group_by.to_a
, but with a guaranteed order. -
#has?(attr, klass, method) ⇒ Boolean
Checks to see if a class has a given method.
-
#hash_to_a(hash) ⇒ Array
Converts a Hash to an Array.
-
#inject_values(str, values) ⇒ Array
Undoes #extract_values by transforming a string with escape sequences into an array of strings and non-string values.
-
#inspect_obj(obj) ⇒ String
Like
Object#inspect
, but preserves non-ASCII characters rather than escaping them under Ruby 1.9.2. -
#intersperse(enum, val) ⇒ Array
Intersperses a value in an enumerable, as would be done with
Array#join
but without concatenating the array together afterwards. -
#ironruby? ⇒ Boolean
Whether or not this is running on IronRuby.
-
#jruby1_6? ⇒ Boolean
Wehter or not this is running under JRuby 1.6 or lower.
-
#jruby? ⇒ Boolean
Whether or not this is running on JRuby.
-
#jruby_version ⇒ Array<Fixnum>
Returns an array of ints representing the JRuby version number.
-
#lcs(x, y) {|a, b| ... } ⇒ Array
Computes a single longest common subsequence for
x
andy
. -
#macruby? ⇒ Boolean
Whether or not this is running under MacRuby.
-
#map_hash(hash) {|key, value| ... } ⇒ Hash
Maps the key-value pairs of a hash according to a block.
-
#map_keys(hash) {|key| ... } ⇒ Hash
Maps the keys in a hash according to a block.
-
#map_vals(hash) {|value| ... } ⇒ Hash
Maps the values in a hash according to a block.
-
#merge_adjacent_strings(arr) ⇒ Array
Concatenates all strings that are adjacent in an array, while leaving other elements as they are.
-
#ord(c) ⇒ Fixnum
Returns the ASCII code of the given character.
-
#paths(arrs) ⇒ Array<Arrays>
Return an array of all possible paths through the given arrays.
-
#powerset(arr) ⇒ Set<Set>
Computes the powerset of the given array.
-
#rails_env ⇒ String?
Returns the environment of the Rails application, if this is running in a Rails context.
-
#rails_root ⇒ String?
Returns the root of the Rails application, if this is running in a Rails context.
-
#rbx? ⇒ Boolean
Whether or not this is running on Rubinius.
-
#restrict(value, range) ⇒ Numeric
Restricts a number to falling within a given range.
-
#ruby1? ⇒ Boolean
Whether or not this is running under a Ruby version under 2.0.
-
#ruby1_8? ⇒ Boolean
Whether or not this is running under Ruby 1.8 or lower.
-
#ruby1_8_6? ⇒ Boolean
Whether or not this is running under Ruby 1.8.6 or lower.
-
#sass_warn(msg)
The same as
Kernel#warn
, but is silenced by #silence_sass_warnings. -
#scope(file) ⇒ String
Returns the path of a file relative to the Sass root directory.
-
#set_eql?(set1, set2) ⇒ Boolean
Tests the hash-equality of two sets in a cross-version manner.
-
#set_hash(set) ⇒ Fixnum
Returns the hash code for a set in a cross-version manner.
-
#silence_sass_warnings { ... }
Silences all Sass warnings within a block.
-
#silence_warnings { ... }
Silence all output to STDERR within a block.
-
#strip_string_array(arr) ⇒ Array
Destructively strips whitespace from the beginning and end of the first and last elements, respectively, in the array (if those elements are strings).
-
#subsequence?(seq1, seq2) ⇒ Boolean
Returns whether or not
seq1
is a subsequence ofseq2
. -
#substitute(ary, from, to)
Substitutes a sub-array of one array with another sub-array.
-
#to_hash(arr) ⇒ Hash
Converts an array of
[key, value]
pairs to a hash. -
#undefined_conversion_error_char(e) ⇒ String
Returns a string description of the character that caused an
Encoding::UndefinedConversionError
. -
#version_geq(v1, v2) ⇒ Boolean
Returns whether one version string represents the same or a more recent version than another.
-
#version_gt(v1, v2) ⇒ Boolean
Returns whether one version string represents a more recent version than another.
-
#windows? ⇒ Boolean
Whether or not this is running on Windows.
-
#with_extracted_values(arr) {|str| ... } ⇒ Array
Allows modifications to be performed on the string form of an array containing both strings and non-strings.
Instance Method Details
#abstract(obj)
Throws a NotImplementedError for an abstract method.
381 382 383 |
# File 'lib/sass/util.rb', line 381
def abstract(obj)
raise NotImplementedError.new("#{obj.class} must implement ##{caller_info[2]}")
end
|
#ap_geq?(version) ⇒ Boolean
Returns whether this environment is using ActionPack of a version greater than or equal to that specified.
456 457 458 459 460 461 462 |
# File 'lib/sass/util.rb', line 456
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? ⇒ Boolean
Returns whether this environment is using ActionPack version 3.0.0 or greater.
445 446 447 |
# File 'lib/sass/util.rb', line 445
def ap_geq_3?
ap_geq?("3.0.0.beta1")
end
|
#array_minus(minuend, subtrahend) ⇒ Array
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#-.
267 268 269 270 271 |
# File 'lib/sass/util.rb', line 267
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) {|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.
880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 |
# File 'lib/sass/util.rb', line 880
def atomic_create_and_write_file(filename)
require 'tempfile'
tmpfile = Tempfile.new(File.basename(filename), File.dirname(filename))
tmpfile.binmode if tmpfile.respond_to?(:binmode)
result = yield tmpfile
tmpfile.flush # ensure all writes are flushed to the OS
begin
tmpfile.fsync # ensure all buffered data in the OS is sync'd to disk.
rescue NotImplementedError
# Not all OSes support fsync
end
File.rename tmpfile.path, filename
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
.
472 473 474 475 |
# File 'lib/sass/util.rb', line 472
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 = nil) ⇒ [String, Fixnum, (String, nil)]
Returns information about the caller of the previous method.
329 330 331 332 333 334 335 336 337 |
# File 'lib/sass/util.rb', line 329
def caller_info(entry = nil)
# JRuby evaluates `caller` incorrectly when it's in an actual default argument.
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) {|msg| ... } ⇒ String
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.
586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 |
# File 'lib/sass/util.rb', line 586
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 #{undefined_conversion_error_char(e)}
MSG
end
end
return str
end
|
#check_range(name, range, value, unit = '') ⇒ Numeric
Asserts that value
falls within range
(inclusive), leaving
room for slight floating-point errors.
296 297 298 299 300 301 302 303 304 305 |
# File 'lib/sass/util.rb', line 296
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::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) {|msg| ... } ⇒ (String, Encoding)
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.
631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 |
# File 'lib/sass/util.rb', line 631
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|
re = Sass::Util::CHARSET_REGEXPS[enc]
re && bin =~ re
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
|
#destructure(val) ⇒ Object
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.
531 532 533 |
# File 'lib/sass/util.rb', line 531
def destructure(val)
val || []
end
|
#enum_cons(enum, n) ⇒ Enumerator
A version of Enumerable#enum_cons
that works in Ruby 1.8 and 1.9.
718 719 720 |
# File 'lib/sass/util.rb', line 718
def enum_cons(enum, n)
ruby1_8? ? enum.enum_cons(n) : enum.each_cons(n)
end
|
#enum_slice(enum, n) ⇒ Enumerator
A version of Enumerable#enum_slice
that works in Ruby 1.8 and 1.9.
727 728 729 |
# File 'lib/sass/util.rb', line 727
def enum_slice(enum, n)
ruby1_8? ? enum.enum_slice(n) : enum.each_slice(n)
end
|
#enum_with_index(enum) ⇒ Enumerator
A version of Enumerable#enum_with_index
that works in Ruby 1.8 and 1.9.
709 710 711 |
# File 'lib/sass/util.rb', line 709
def enum_with_index(enum)
ruby1_8? ? enum.enum_with_index : enum.each_with_index
end
|
#extract!(array) {|el| ... } ⇒ Array
Destructively removes all elements from an array that match a block, and returns the removed elements.
739 740 741 742 743 744 745 746 747 |
# File 'lib/sass/util.rb', line 739
def extract!(array)
out = []
array.reject! do |e|
next false unless yield e
out << e
true
end
out
end
|
#extract_values(arr) ⇒ (String, Array)
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.
814 815 816 817 818 819 820 821 |
# File 'lib/sass/util.rb', line 814
def extract_values(arr)
values = []
return arr.map do |e|
next e.gsub('{', '{{') if e.is_a?(String)
values << e
next "{#{values.count - 1}}"
end.join, values
end
|
#flatten(arr, n) ⇒ Array
Flattens the first n
nested arrays in a cross-version manner.
762 763 764 765 766 |
# File 'lib/sass/util.rb', line 762
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
|
#glob(path, &block)
Like Dir.glob
, but works with backslash-separated paths on Windows.
517 518 519 520 |
# File 'lib/sass/util.rb', line 517
def glob(path, &block)
path = path.gsub('\\', '/') if windows?
Dir.glob(path, &block)
end
|
#group_by_to_a(enum, &block) ⇒ Array<[Object, Array]>
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).
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 |
# File 'lib/sass/util.rb', line 244
def group_by_to_a(enum, &block)
return enum.group_by(&block).to_a unless ruby1_8?
order = {}
arr = []
enum.group_by do |e|
res = block[e]
unless order.include?(res)
order[res] = order.size
end
res
end.each do |key, vals|
arr[order[key]] = [key, vals]
end
arr
end
|
#has?(attr, klass, method) ⇒ Boolean
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.
701 702 703 |
# File 'lib/sass/util.rb', line 701
def has?(attr, klass, method)
klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
end
|
#hash_to_a(hash) ⇒ Array
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).
232 233 234 235 |
# File 'lib/sass/util.rb', line 232
def hash_to_a(hash)
return hash.to_a unless ruby1_8? || defined?(Test::Unit)
return hash.sort_by {|k, v| k}
end
|
#inject_values(str, values) ⇒ Array
Undoes #extract_values by transforming a string with escape sequences into an array of strings and non-string values.
829 830 831 832 833 834 835 836 837 |
# File 'lib/sass/util.rb', line 829
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) ⇒ String
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[:encoding]
before being evaluated.
795 796 797 798 799 800 |
# File 'lib/sass/util.rb', line 795
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) ⇒ Array
Intersperses a value in an enumerable, as would be done with Array#join
but without concatenating the array together afterwards.
155 156 157 |
# File 'lib/sass/util.rb', line 155
def intersperse(enum, val)
enum.inject([]) {|a, e| a << e << val}[0...-1]
end
|
#ironruby? ⇒ Boolean
Whether or not this is running on IronRuby.
489 490 491 |
# File 'lib/sass/util.rb', line 489
def ironruby?
RUBY_ENGINE == "ironruby"
end
|
#jruby1_6? ⇒ Boolean
Wehter or not this is running under JRuby 1.6 or lower.
565 566 567 |
# File 'lib/sass/util.rb', line 565
def jruby1_6?
jruby? && jruby_version[0] == 1 && jruby_version[1] < 7
end
|
#jruby? ⇒ Boolean
Whether or not this is running on JRuby.
503 504 505 |
# File 'lib/sass/util.rb', line 503
def jruby?
RUBY_PLATFORM =~ /java/
end
|
#jruby_version ⇒ Array<Fixnum>
Returns an array of ints representing the JRuby version number.
510 511 512 |
# File 'lib/sass/util.rb', line 510
def jruby_version
$jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
end
|
#lcs(x, y) {|a, b| ... } ⇒ Array
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
.
216 217 218 219 220 221 |
# File 'lib/sass/util.rb', line 216
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
|
#macruby? ⇒ Boolean
Whether or not this is running under MacRuby.
572 573 574 |
# File 'lib/sass/util.rb', line 572
def macruby?
RUBY_ENGINE == 'macruby'
end
|
#map_hash(hash) {|key, value| ... } ⇒ Hash
Maps the key-value pairs of a hash according to a block.
89 90 91 92 |
# File 'lib/sass/util.rb', line 89
def map_hash(hash)
# Using &block here completely hoses performance on 1.8.
to_hash(hash.map {|k, v| yield k, v})
end
|
#map_keys(hash) {|key| ... } ⇒ Hash
Maps the keys in a hash according to a block.
56 57 58 |
# File 'lib/sass/util.rb', line 56
def map_keys(hash)
to_hash(hash.map {|k, v| [yield(k), v]})
end
|
#map_vals(hash) {|value| ... } ⇒ Hash
Maps the values in a hash according to a block.
72 73 74 |
# 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) ⇒ Array
Concatenates all strings that are adjacent in an array, while leaving other elements as they are.
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 |
# File 'lib/sass/util.rb', line 132
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) ⇒ Fixnum
Returns the ASCII code of the given character.
753 754 755 |
# File 'lib/sass/util.rb', line 753
def ord(c)
ruby1_8? ? c[0] : c.ord
end
|
#paths(arrs) ⇒ Array<Arrays>
Return an array of all possible paths through the given arrays.
199 200 201 202 203 |
# File 'lib/sass/util.rb', line 199
def paths(arrs)
arrs.inject([[]]) do |paths, arr|
flatten(arr.map {|e| paths.map {|path| path + [e]}}, 1)
end
end
|
#powerset(arr) ⇒ Set<Set>
Computes the powerset of the given array. This is the set of all subsets of the array.
102 103 104 105 106 107 108 109 110 111 |
# File 'lib/sass/util.rb', line 102
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 ⇒ String?
Returns the environment of the Rails application,
if this is running in a Rails context.
Returns nil
if no such environment is defined.
435 436 437 438 439 |
# File 'lib/sass/util.rb', line 435
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 ⇒ String?
Returns the root of the Rails application,
if this is running in a Rails context.
Returns nil
if no such root is defined.
421 422 423 424 425 426 427 428 |
# File 'lib/sass/util.rb', line 421
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
|
#rbx? ⇒ Boolean
Whether or not this is running on Rubinius.
496 497 498 |
# File 'lib/sass/util.rb', line 496
def rbx?
RUBY_ENGINE == "rbx"
end
|
#restrict(value, range) ⇒ Numeric
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.
120 121 122 |
# File 'lib/sass/util.rb', line 120
def restrict(value, range)
[[value, range.first].max, range.last].min
end
|
#ruby1? ⇒ Boolean
Whether or not this is running under a Ruby version under 2.0.
540 541 542 |
# File 'lib/sass/util.rb', line 540
def ruby1?
Sass::Util::RUBY_VERSION[0] <= 1
end
|
#ruby1_8? ⇒ Boolean
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.
550 551 552 553 554 |
# File 'lib/sass/util.rb', line 550
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? ⇒ Boolean
Whether or not this is running under Ruby 1.8.6 or lower. Note that lower versions are not officially supported.
560 561 562 |
# File 'lib/sass/util.rb', line 560
def ruby1_8_6?
ruby1_8? && Sass::Util::RUBY_VERSION[2] < 7
end
|
#sass_warn(msg)
The same as Kernel#warn
, but is silenced by #silence_sass_warnings.
409 410 411 412 |
# File 'lib/sass/util.rb', line 409
def sass_warn(msg)
msg = msg + "\n" unless ruby1?
Sass.logger.warn(msg)
end
|
#scope(file) ⇒ String
Returns the path of a file relative to the Sass root directory.
29 30 31 |
# File 'lib/sass/util.rb', line 29
def scope(file)
File.join(Sass::ROOT_DIR, file)
end
|
#set_eql?(set1, set2) ⇒ Boolean
Tests the hash-equality of two sets in a cross-version manner. Aggravatingly, this is order-dependent in Ruby 1.8.6.
784 785 786 787 |
# File 'lib/sass/util.rb', line 784
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) ⇒ Fixnum
Returns the hash code for a set in a cross-version manner. Aggravatingly, this is order-dependent in Ruby 1.8.6.
773 774 775 776 |
# File 'lib/sass/util.rb', line 773
def set_hash(set)
return set.hash unless ruby1_8_6?
set.map {|e| e.hash}.uniq.sort.hash
end
|
#silence_sass_warnings { ... }
Silences all Sass warnings within a block.
399 400 401 402 403 404 |
# File 'lib/sass/util.rb', line 399
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.
388 389 390 391 392 393 |
# File 'lib/sass/util.rb', line 388
def silence_warnings
the_real_stderr, $stderr = $stderr, StringIO.new
yield
ensure
$stderr = the_real_stderr
end
|
#strip_string_array(arr) ⇒ Array
Destructively strips whitespace from the beginning and end of the first and last elements, respectively, in the array (if those elements are strings).
182 183 184 185 186 |
# File 'lib/sass/util.rb', line 182
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) ⇒ Boolean
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).
314 315 316 317 318 319 320 321 322 |
# File 'lib/sass/util.rb', line 314
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.
164 165 166 167 168 169 170 171 172 173 174 |
# File 'lib/sass/util.rb', line 164
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) ⇒ Hash
Converts an array of [key, value]
pairs to a hash.
40 41 42 |
# File 'lib/sass/util.rb', line 40
def to_hash(arr)
Hash[arr.compact]
end
|
#undefined_conversion_error_char(e) ⇒ String
Returns a string description of the character that caused an
Encoding::UndefinedConversionError
.
278 279 280 281 282 283 284 285 |
# File 'lib/sass/util.rb', line 278
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) ⇒ Boolean
Returns whether one version string represents the same or a more recent version than another.
373 374 375 |
# File 'lib/sass/util.rb', line 373
def version_geq(v1, v2)
version_gt(v1, v2) || !version_gt(v2, v1)
end
|
#version_gt(v1, v2) ⇒ Boolean
Returns whether one version string represents a more recent version than another.
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 |
# File 'lib/sass/util.rb', line 344
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? ⇒ Boolean
Whether or not this is running on Windows.
482 483 484 |
# File 'lib/sass/util.rb', line 482
def windows?
RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i
end
|
#with_extracted_values(arr) {|str| ... } ⇒ Array
Allows modifications to be performed on the string form of an array containing both strings and non-strings.
847 848 849 850 851 |
# File 'lib/sass/util.rb', line 847
def with_extracted_values(arr)
str, vals = extract_values(arr)
str = yield str
inject_values(str, vals)
end
|