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::ConverterNotFound => _ 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 = ) ⇒ [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. -
#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)
Like
Dir.glob
, but works with backslash-separated paths on Windows. -
#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
. -
#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).
-
#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.
311 312 313 |
# File 'lib/sass/util.rb', line 311
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.
385 386 387 388 389 390 391 |
# File 'lib/sass/util.rb', line 385
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.
374 375 376 |
# File 'lib/sass/util.rb', line 374
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
.
401 402 403 404 |
# File 'lib/sass/util.rb', line 401
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 = ) ⇒ [String, Fixnum, (String, nil)]
Returns information about the caller of the previous method.
261 262 263 264 265 266 267 |
# File 'lib/sass/util.rb', line 261
def caller_info(entry = caller[1])
info = entry.scan(/^(.*?):(-?.*?)(?::.*`(.+)')?$/).first
info[1] = info[1].to_i
# This is added by Rubinius to designate a block, but we don't care about it.
info[2].sub!(/ \{\}\Z/, '') if info[2]
info
end
|
#check_encoding(str) {|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.
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 |
# File 'lib/sass/util.rb', line 462
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.
245 246 247 248 249 250 251 252 253 254 |
# File 'lib/sass/util.rb', line 245
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.
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 |
# File 'lib/sass/util.rb', line 507
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
|
#enum_cons(enum, n) ⇒ Enumerator
A version of Enumerable#enum_cons
that works in Ruby 1.8 and 1.9.
594 595 596 |
# File 'lib/sass/util.rb', line 594
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.
603 604 605 |
# File 'lib/sass/util.rb', line 603
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.
585 586 587 |
# File 'lib/sass/util.rb', line 585
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.
615 616 617 618 619 620 621 622 623 |
# File 'lib/sass/util.rb', line 615
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.
690 691 692 693 694 695 696 697 |
# File 'lib/sass/util.rb', line 690
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.
638 639 640 641 642 |
# File 'lib/sass/util.rb', line 638
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)
Like Dir.glob
, but works with backslash-separated paths on Windows.
425 426 427 428 |
# File 'lib/sass/util.rb', line 425
def glob(path)
path = path.gsub('\\', '/') if windows?
Dir.glob(path)
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.
577 578 579 |
# File 'lib/sass/util.rb', line 577
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.
705 706 707 708 709 710 711 712 713 |
# File 'lib/sass/util.rb', line 705
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.
671 672 673 674 675 676 |
# File 'lib/sass/util.rb', line 671
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.
418 419 420 |
# File 'lib/sass/util.rb', line 418
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
|
#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.
629 630 631 |
# File 'lib/sass/util.rb', line 629
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.
364 365 366 367 368 |
# File 'lib/sass/util.rb', line 364
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.
350 351 352 353 354 355 356 357 |
# File 'lib/sass/util.rb', line 350
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.
438 439 440 441 442 |
# File 'lib/sass/util.rb', line 438
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.
448 449 450 |
# File 'lib/sass/util.rb', line 448
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.
339 340 341 |
# File 'lib/sass/util.rb', line 339
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.
660 661 662 663 |
# File 'lib/sass/util.rb', line 660
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.
649 650 651 652 |
# File 'lib/sass/util.rb', line 649
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.
329 330 331 332 333 334 |
# File 'lib/sass/util.rb', line 329
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.
318 319 320 321 322 323 |
# File 'lib/sass/util.rb', line 318
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
|
#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.
303 304 305 |
# File 'lib/sass/util.rb', line 303
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.
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 |
# File 'lib/sass/util.rb', line 274
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.
411 412 413 |
# File 'lib/sass/util.rb', line 411
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.
723 724 725 726 727 |
# File 'lib/sass/util.rb', line 723
def with_extracted_values(arr)
str, vals = extract_values(arr)
str = yield str
inject_values(str, vals)
end
|