Module: Haml::Util
- Extended by:
- Util
- Included in:
- Buffer, Util, Version, Sass::Engine, Sass::Plugin, Sass::Script::Color
- Defined in:
- lib/haml/util.rb,
lib/haml/util/subset_map.rb
Overview
A module containing various useful functions.
Defined Under Namespace
Classes: StaticConditionalContext, SubsetMap
Constant Summary collapse
- RUBY_VERSION =
An array of ints representing the Ruby version number.
::RUBY_VERSION.split(".").map {|s| s.to_i}
- 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 # /\A@charset "(.*?)"/ Regexp.new(/\A#{_enc('@charset "', e)}(.*?)#{_enc('"', e)}/) end end
- @@silence_warnings =
false
Instance Method Summary collapse
-
#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.
-
#assert_html_safe!(text)
Assert that a given object (usually a String) is HTML safe according to Rails' XSS handling, if it's loaded.
-
#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_haml_encoding(str) {|msg| ... } ⇒ String
Like #check_encoding, but also checks for a Ruby-style
-# coding:
comment at the beginning of the template and uses that encoding if it exists. -
#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. -
#def_static_method(klass, name, args, *vars, erb)
This is used for methods in Buffer that need to be very fast, and take a lot of boolean parameters that are known at compile-time.
-
#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. -
#flatten(arr, n) ⇒ Array
Flattens the first
n
nested arrays in a cross-version manner. -
#haml_warn(msg)
The same as
Kernel#warn
, but is silenced by #silence_haml_warnings. -
#has?(attr, klass, method) ⇒ Boolean
Checks to see if a class has a given method.
-
#html_safe(text) ⇒ String?
Returns the given text, marked as being HTML-safe.
-
#intersperse(enum, val) ⇒ Array
Intersperses a value in an enumerable, as would be done with
Array#join
but without concatenating the array together afterwards. -
#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(enum) ⇒ 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.
-
#rails_safe_buffer_class ⇒ Class
The class for the Rails SafeBuffer XSS protection class.
-
#rails_xss_safe? ⇒ Boolean
Whether or not ActionView's XSS protection is available and enabled, as is the default for Rails 3.0+, and optional for version 2.3.5+.
-
#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.
-
#scope(file) ⇒ String
Returns the path of a file relative to the Haml 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_haml_warnings { ... }
Silences all Haml warnings within a block.
-
#silence_warnings { ... }
Silence all output to STDERR within a block.
-
#static_method_name(name, *vars) ⇒ String
Computes the name for a method defined via #def_static_method.
-
#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. -
#windows? ⇒ Boolean
Whether or not this is running on Windows.
Instance Method Details
#ap_geq?(version) ⇒ Boolean
Returns whether this environment is using ActionPack of a version greater than or equal to that specified.
306 307 308 309 310 311 312 |
# File 'lib/haml/util.rb', line 306
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)
ActionPack::VERSION::STRING >= version
end
|
#ap_geq_3? ⇒ Boolean
Returns whether this environment is using ActionPack version 3.0.0 or greater.
295 296 297 |
# File 'lib/haml/util.rb', line 295
def ap_geq_3?
ap_geq?("3.0.0.beta1")
end
|
#assert_html_safe!(text)
Assert that a given object (usually a String) is HTML safe according to Rails' XSS handling, if it's loaded.
354 355 356 357 |
# File 'lib/haml/util.rb', line 354
def assert_html_safe!(text)
return unless rails_xss_safe? && text && !text.to_s.html_safe?
raise Haml::Error.new("Expected #{text.inspect} to be HTML-safe.")
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
.
322 323 324 325 |
# File 'lib/haml/util.rb', line 322
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.
226 227 228 229 230 231 232 |
# File 'lib/haml/util.rb', line 226
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.
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 |
# File 'lib/haml/util.rb', line 407
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_haml_encoding(str) {|msg| ... } ⇒ String
Like #check_encoding, but also checks for a Ruby-style -# coding:
comment
at the beginning of the template and uses that encoding if it exists.
The Sass encoding rules are simple.
If a -# coding:
comment exists,
we assume that that's the original encoding of the document.
Otherwise, we use whatever encoding Ruby has.
Haml uses the same rules for parsing coding comments as Ruby.
This means that it can understand Emacs-style comments
(e.g. -*- encoding: "utf-8" -*-
),
and also that it cannot understand non-ASCII-compatible encodings
such as UTF-16
and UTF-32
.
453 454 455 456 457 458 459 460 461 462 463 |
# File 'lib/haml/util.rb', line 453
def check_haml_encoding(str, &block)
return check_encoding(str, &block) if ruby1_8?
str = str.dup if str.frozen?
bom, encoding = parse_haml_magic_comment(str)
if encoding; str.force_encoding(encoding)
elsif bom; str.force_encoding("UTF-8")
end
return check_encoding(str, &block)
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.
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 |
# File 'lib/haml/util.rb', line 484
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 = Haml::Util::ENCODINGS_TO_CHECK.find do |enc|
bin =~ Haml::Util::CHARSET_REGEXPS[enc]
end
charset, bom = $1, $2
if charset
charset = charset.force_encoding(encoding).encode("UTF-8")
if endianness = encoding[/[BL]E$/]
begin
Encoding.find(charset + endianness)
charset << endianness
rescue ArgumentError # Encoding charset + endianness doesn't exist
end
end
str.force_encoding(charset)
elsif bom
str.force_encoding(encoding)
end
str = check_encoding(str, &block)
return str.encode("UTF-8"), str.encoding
end
|
#def_static_method(klass, name, args, *vars, erb)
This is used for methods in Buffer that need to be very fast, and take a lot of boolean parameters that are known at compile-time. Instead of passing the parameters in normally, a separate method is defined for every possible combination of those parameters; these are then called using #static_method_name.
To define a static method, an ERB template for the method is provided. All conditionals based on the static parameters are done as embedded Ruby within this template. For example:
def_static_method(Foo, :my_static_method, [:foo, :bar], :baz, :bang, <<RUBY)
<% if baz && bang %>
return foo + bar
<% elsif baz || bang %>
return foo - bar
<% else %>
return 17
<% end %>
RUBY
#static_method_name can be used to call static methods.
672 673 674 675 676 677 678 679 680 681 682 683 |
# File 'lib/haml/util.rb', line 672
def def_static_method(klass, name, args, *vars)
erb = vars.pop
info = caller_info
powerset(vars).each do |set|
context = StaticConditionalContext.new(set).instance_eval {binding}
klass.class_eval(<<METHOD, info[0], info[1])
def #{static_method_name(name, *vars.map {|v| set.include?(v)})}(#{args.join(', ')})
#{ERB.new(erb).result(context)}
end
METHOD
end
end
|
#enum_cons(enum, n) ⇒ Enumerator
A version of Enumerable#enum_cons
that works in Ruby 1.8 and 1.9.
568 569 570 |
# File 'lib/haml/util.rb', line 568
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.
577 578 579 |
# File 'lib/haml/util.rb', line 577
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.
559 560 561 |
# File 'lib/haml/util.rb', line 559
def enum_with_index(enum)
ruby1_8? ? enum.enum_with_index : enum.each_with_index
end
|
#flatten(arr, n) ⇒ Array
Flattens the first n
nested arrays in a cross-version manner.
594 595 596 597 598 |
# File 'lib/haml/util.rb', line 594
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
|
#haml_warn(msg)
The same as Kernel#warn
, but is silenced by #silence_haml_warnings.
259 260 261 262 |
# File 'lib/haml/util.rb', line 259
def haml_warn(msg)
return if @@silence_warnings
warn(msg)
end
|
#has?(attr, klass, method) ⇒ Boolean
Checks to see if a class has a given method. For example:
Haml::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.
551 552 553 |
# File 'lib/haml/util.rb', line 551
def has?(attr, klass, method)
klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
end
|
#html_safe(text) ⇒ String?
Returns the given text, marked as being HTML-safe.
With older versions of the Rails XSS-safety mechanism,
this destructively modifies the HTML-safety of text
.
344 345 346 347 348 |
# File 'lib/haml/util.rb', line 344
def html_safe(text)
return unless text
return text.html_safe if defined?(ActiveSupport::SafeBuffer)
text.html_safe!
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.
153 154 155 |
# File 'lib/haml/util.rb', line 153
def intersperse(enum, val)
enum.inject([]) {|a, e| a << e << val}[0...-1]
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
.
214 215 216 217 218 219 |
# File 'lib/haml/util.rb', line 214
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. For example:
map_hash({:foo => "bar", :baz => "bang"}) {|k, v| [k.to_s, v.to_sym]}
#=> {"foo" => :bar, "baz" => :bang}
88 89 90 |
# File 'lib/haml/util.rb', line 88
def map_hash(hash, &block)
to_hash(hash.map(&block))
end
|
#map_keys(hash) {|key| ... } ⇒ Hash
Maps the keys in a hash according to a block. For example:
map_keys({:foo => "bar", :baz => "bang"}) {|k| k.to_s}
#=> {"foo" => "bar", "baz" => "bang"}
53 54 55 |
# File 'lib/haml/util.rb', line 53
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. For example:
map_values({:foo => "bar", :baz => "bang"}) {|v| v.to_sym}
#=> {:foo => :bar, :baz => :bang}
70 71 72 |
# File 'lib/haml/util.rb', line 70
def map_vals(hash)
to_hash(hash.map {|k, v| [k, yield(v)]})
end
|
#merge_adjacent_strings(enum) ⇒ Array
Concatenates all strings that are adjacent in an array, while leaving other elements as they are. For example:
merge_adjacent_strings([1, "foo", "bar", 2, "baz"])
#=> [1, "foobar", 2, "baz"]
132 133 134 135 136 137 138 139 140 141 142 143 144 145 |
# File 'lib/haml/util.rb', line 132
def merge_adjacent_strings(enum)
enum.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.
585 586 587 |
# File 'lib/haml/util.rb', line 585
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.
paths([[1, 2], [3, 4], [5]]) #=> # [[1, 3, 5], # [2, 3, 5], # [1, 4, 5], # [2, 4, 5]]
197 198 199 200 201 |
# File 'lib/haml/util.rb', line 197
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. For example:
powerset([1, 2, 3]) #=>
Set[Set[], Set[1], Set[2], Set[3], Set[1, 2], Set[2, 3], Set[1, 3], Set[1, 2, 3]]
101 102 103 104 105 106 107 108 109 110 |
# File 'lib/haml/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.
285 286 287 288 289 |
# File 'lib/haml/util.rb', line 285
def rails_env
return Rails.env.to_s if defined?(Rails.root)
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.
271 272 273 274 275 276 277 278 |
# File 'lib/haml/util.rb', line 271
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
|
#rails_safe_buffer_class ⇒ Class
The class for the Rails SafeBuffer XSS protection class. This varies depending on Rails version.
363 364 365 366 367 368 369 |
# File 'lib/haml/util.rb', line 363
def rails_safe_buffer_class
# It's important that we check ActiveSupport first,
# because in Rails 2.3.6 ActionView::SafeBuffer exists
# but is a deprecated proxy object.
return ActiveSupport::SafeBuffer if defined?(ActiveSupport::SafeBuffer)
return ActionView::SafeBuffer
end
|
#rails_xss_safe? ⇒ Boolean
Whether or not ActionView's XSS protection is available and enabled, as is the default for Rails 3.0+, and optional for version 2.3.5+. Overridden in haml/template.rb if this is the case.
334 335 336 |
# File 'lib/haml/util.rb', line 334
def rails_xss_safe?
false
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/haml/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.
385 386 387 |
# File 'lib/haml/util.rb', line 385
def ruby1_8?
Haml::Util::RUBY_VERSION[0] == 1 && Haml::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.
393 394 395 |
# File 'lib/haml/util.rb', line 393
def ruby1_8_6?
ruby1_8? && Haml::Util::RUBY_VERSION[2] < 7
end
|
#scope(file) ⇒ String
Returns the path of a file relative to the Haml root directory.
24 25 26 |
# File 'lib/haml/util.rb', line 24
def scope(file)
File.join(Haml::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.
616 617 618 619 |
# File 'lib/haml/util.rb', line 616
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.
605 606 607 608 |
# File 'lib/haml/util.rb', line 605
def set_hash(set)
return set.hash unless ruby1_8_6?
set.map {|e| e.hash}.uniq.sort.hash
end
|
#silence_haml_warnings { ... }
Silences all Haml warnings within a block.
248 249 250 251 252 253 254 |
# File 'lib/haml/util.rb', line 248
def silence_haml_warnings
old_silence_warnings = @@silence_warnings
@@silence_warnings = true
yield
ensure
@@silence_warnings = old_silence_warnings
end
|
#silence_warnings { ... }
Silence all output to STDERR within a block.
237 238 239 240 241 242 |
# File 'lib/haml/util.rb', line 237
def silence_warnings
the_real_stderr, $stderr = $stderr, StringIO.new
yield
ensure
$stderr = the_real_stderr
end
|
#static_method_name(name, *vars) ⇒ String
Computes the name for a method defined via #def_static_method.
690 691 692 |
# File 'lib/haml/util.rb', line 690
def static_method_name(name, *vars)
"#{name}_#{vars.map {|v| !!v}.join('_')}"
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).
180 181 182 183 184 |
# File 'lib/haml/util.rb', line 180
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.
162 163 164 165 166 167 168 169 170 171 172 |
# File 'lib/haml/util.rb', line 162
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.
For example:
to_hash([[:foo, "bar"], [:baz, "bang"]])
#=> {:foo => "bar", :baz => "bang"}
36 37 38 |
# File 'lib/haml/util.rb', line 36
def to_hash(arr)
arr.compact.inject({}) {|h, (k, v)| h[k] = v; h}
end
|
#windows? ⇒ Boolean
Whether or not this is running on Windows.
376 377 378 |
# File 'lib/haml/util.rb', line 376
def windows?
RbConfig::CONFIG['host_os'] =~ /mswin|windows/i
end
|