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/subset_map.rb
Overview
A module containing various useful functions.
Defined Under Namespace
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.
-
#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.
-
#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.
-
#restrict(value, range) ⇒ Numeric
Restricts a number to falling within a given range.
-
#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. -
#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.
353 354 355 |
# File 'lib/sass/util.rb', line 353
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.
427 428 429 430 431 432 433 |
# File 'lib/sass/util.rb', line 427
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.
416 417 418 |
# File 'lib/sass/util.rb', line 416
def ap_geq_3?
ap_geq?("3.0.0.beta1")
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
.
443 444 445 446 |
# File 'lib/sass/util.rb', line 443
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.
301 302 303 304 305 306 307 308 309 |
# File 'lib/sass/util.rb', line 301
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.
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 |
# File 'lib/sass/util.rb', line 524
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_range(name, range, value, unit = '') ⇒ Numeric
Asserts that value
falls within range
(inclusive), leaving
room for slight floating-point errors.
268 269 270 271 272 273 274 275 276 277 |
# File 'lib/sass/util.rb', line 268
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.
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 |
# File 'lib/sass/util.rb', line 569
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.
481 482 483 |
# File 'lib/sass/util.rb', line 481
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.
656 657 658 |
# File 'lib/sass/util.rb', line 656
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.
665 666 667 |
# File 'lib/sass/util.rb', line 665
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.
647 648 649 |
# File 'lib/sass/util.rb', line 647
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.
677 678 679 680 681 682 683 684 685 |
# File 'lib/sass/util.rb', line 677
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.
752 753 754 755 756 757 758 759 |
# File 'lib/sass/util.rb', line 752
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.
700 701 702 703 704 |
# File 'lib/sass/util.rb', line 700
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.
467 468 469 470 |
# File 'lib/sass/util.rb', line 467
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).
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 |
# File 'lib/sass/util.rb', line 243
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.
639 640 641 |
# File 'lib/sass/util.rb', line 639
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).
231 232 233 234 |
# File 'lib/sass/util.rb', line 231
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.
767 768 769 770 771 772 773 774 775 |
# File 'lib/sass/util.rb', line 767
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.
733 734 735 736 737 738 |
# File 'lib/sass/util.rb', line 733
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.
154 155 156 |
# File 'lib/sass/util.rb', line 154
def intersperse(enum, val)
enum.inject([]) {|a, e| a << e << val}[0...-1]
end
|
#ironruby? ⇒ Boolean
Whether or not this is running on IronRuby.
460 461 462 |
# File 'lib/sass/util.rb', line 460
def ironruby?
RUBY_ENGINE == "ironruby"
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
.
215 216 217 218 219 220 |
# 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
|
#macruby? ⇒ Boolean
Whether or not this is running under MacRuby.
510 511 512 |
# File 'lib/sass/util.rb', line 510
def macruby?
RUBY_ENGINE == 'macruby'
end
|
#map_hash(hash) {|key, value| ... } ⇒ Hash
Maps the key-value pairs of a hash according to a block.
88 89 90 91 |
# File 'lib/sass/util.rb', line 88
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.
55 56 57 |
# File 'lib/sass/util.rb', line 55
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.
71 72 73 |
# File 'lib/sass/util.rb', line 71
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.
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 |
# 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) ⇒ Fixnum
Returns the ASCII code of the given character.
691 692 693 |
# File 'lib/sass/util.rb', line 691
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.
198 199 200 201 202 |
# 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) ⇒ Set<Set>
Computes the powerset of the given array. This is the set of all subsets of the array.
101 102 103 104 105 106 107 108 109 110 |
# 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 ⇒ String?
Returns the environment of the Rails application,
if this is running in a Rails context.
Returns nil
if no such environment is defined.
406 407 408 409 410 |
# File 'lib/sass/util.rb', line 406
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.
392 393 394 395 396 397 398 399 |
# File 'lib/sass/util.rb', line 392
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) ⇒ 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.
119 120 121 |
# File 'lib/sass/util.rb', line 119
def restrict(value, range)
[[value, range.first].max, range.last].min
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.
493 494 495 496 497 |
# File 'lib/sass/util.rb', line 493
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.
503 504 505 |
# File 'lib/sass/util.rb', line 503
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.
381 382 383 |
# File 'lib/sass/util.rb', line 381
def sass_warn(msg)
Sass.logger.warn(msg)
end
|
#scope(file) ⇒ String
Returns the path of a file relative to the Sass root directory.
28 29 30 |
# File 'lib/sass/util.rb', line 28
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.
722 723 724 725 |
# File 'lib/sass/util.rb', line 722
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.
711 712 713 714 |
# File 'lib/sass/util.rb', line 711
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.
371 372 373 374 375 376 |
# File 'lib/sass/util.rb', line 371
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.
360 361 362 363 364 365 |
# File 'lib/sass/util.rb', line 360
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).
181 182 183 184 185 |
# 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
|
#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).
286 287 288 289 290 291 292 293 294 |
# File 'lib/sass/util.rb', line 286
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.
163 164 165 166 167 168 169 170 171 172 173 |
# 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) ⇒ Hash
Converts an array of [key, value]
pairs to a hash.
39 40 41 |
# File 'lib/sass/util.rb', line 39
def to_hash(arr)
Hash[arr.compact]
end
|
#version_geq(v1, v2) ⇒ Boolean
Returns whether one version string represents the same or a more recent version than another.
345 346 347 |
# File 'lib/sass/util.rb', line 345
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.
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 |
# File 'lib/sass/util.rb', line 316
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.
453 454 455 |
# File 'lib/sass/util.rb', line 453
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.
785 786 787 788 789 |
# File 'lib/sass/util.rb', line 785
def with_extracted_values(arr)
str, vals = extract_values(arr)
str = yield str
inject_values(str, vals)
end
|