Module: Haml::Util

Extended by:
Util
Included in:
Buffer, Compiler, Parser, Util, Version
Defined in:
lib/haml/util.rb

Overview

A module containing various useful functions.

Defined Under Namespace

Classes: StaticConditionalContext

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
      # /\A@charset "(.*?)"/
      Regexp.new(/\A#{_enc('@charset "', e)}(.*?)#{_enc('"', e)}/)
    end
end
@@silence_warnings = 
false

Instance Method Summary collapse

Instance Method Details

#abstract(obj)

Throws a NotImplementedError for an abstract method.

Parameters:

  • obj (Object) —

    self

Raises:

  • (NotImplementedError) 


305
306
307
 
# File 'lib/haml/util.rb', line 305

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.

Parameters:

  • version (String) —

    The string version number to check against. Should be greater than or equal to Rails 3, because otherwise ActionPack::VERSION isn't autoloaded

Returns:

  • (Boolean) 


410
411
412
413
414
415
416
 
# File 'lib/haml/util.rb', line 410

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.

Returns:

  • (Boolean) 


399
400
401
 
# File 'lib/haml/util.rb', line 399

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.

Parameters:

  • text (Object)

Raises:



458
459
460
461
 
# File 'lib/haml/util.rb', line 458

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.

Parameters:

  • name (#to_s) —

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



426
427
428
429
 
# File 'lib/haml/util.rb', line 426

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.

Parameters:

  • entry (String) (defaults to: ) —

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

Returns:

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

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



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.

Parameters:

  • str (String) —

    The string of which to check the encoding

Yields:

  • (msg) —

    A block in which an encoding error can be raised. Only yields if there is an encoding error

Yield Parameters:

  • msg (String) —

    The error message to be raised

Returns:

  • (String) —

    str, potentially with encoding gotchas like BOMs removed



523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
 
# File 'lib/haml/util.rb', line 523

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

Parameters:

  • str (String) —

    The Haml template of which to check the encoding

Yields:

  • (msg) —

    A block in which an encoding error can be raised. Only yields if there is an encoding error

Yield Parameters:

  • msg (String) —

    The error message to be raised

Returns:

  • (String) —

    The original string encoded properly

Raises:

  • (ArgumentError) —

    if the document declares an unknown encoding



569
570
571
572
573
574
575
576
577
578
579
 
# File 'lib/haml/util.rb', line 569

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

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

Parameters:

  • klass (Module) —

    The class on which to define the static method

  • name (#to_s) —

    The (base) name of the static method

  • args (Array<Symbol>) —

    The names of the arguments to the defined methods (not to the ERB template)

  • vars (Array<Symbol>) —

    The names of the static boolean variables to be made available to the ERB template

  • erb (String) —

    The template for the method code



756
757
758
759
760
761
762
763
764
765
766
767
 
# File 'lib/haml/util.rb', line 756

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

#dump(obj) ⇒ String

A wrapper for Marshal.dump that calls #_before_dump on the object before dumping it, #_after_dump afterwards. It also calls #_around_dump and passes it a block in which the object is dumped.

If any of these methods are undefined, they are not called.

Parameters:

  • obj (Object) —

    The object to dump.

Returns:

  • (String) —

    The dumped data.



280
281
282
283
284
285
286
287
288
 
# File 'lib/haml/util.rb', line 280

def dump(obj)
  obj._before_dump if obj.respond_to?(:_before_dump)
  return Marshal.dump(obj) unless obj.respond_to?(:_around_dump)
  res = nil
  obj._around_dump {res = Marshal.dump(obj)}
  res
ensure
  obj._after_dump if obj.respond_to?(:_after_dump)
end

#enum_cons(enum, n) ⇒ Enumerator

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

Parameters:

  • enum (Enumerable) —

    The enumerable to get the enumerator for

  • n (Fixnum) —

    The size of each cons

Returns:

  • (Enumerator) —

    The consed enumerator



639
640
641
 
# File 'lib/haml/util.rb', line 639

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.

Parameters:

  • enum (Enumerable) —

    The enumerable to get the enumerator for

  • n (Fixnum) —

    The size of each slice

Returns:

  • (Enumerator) —

    The consed enumerator



648
649
650
 
# File 'lib/haml/util.rb', line 648

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.

Parameters:

  • enum (Enumerable) —

    The enumerable to get the enumerator for

Returns:

  • (Enumerator) —

    The with-index enumerator



630
631
632
 
# File 'lib/haml/util.rb', line 630

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.

Parameters:

  • arr (Array) —

    The array to flatten

  • n (Fixnum) —

    The number of levels to flatten

Returns:

  • (Array) —

    The flattened array



665
666
667
668
669
 
# File 'lib/haml/util.rb', line 665

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.

Parameters:

  • msg (String) 


334
335
336
337
 
# File 'lib/haml/util.rb', line 334

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.

Parameters:

  • attr (#to_s) —

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

  • klass (Module) —

    The class to check the methods of which to check

  • method (String, Symbol) —

    The name of the method do check for

Returns:

  • (Boolean) —

    Whether or not the given collection has the given method



622
623
624
 
# File 'lib/haml/util.rb', line 622

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.

Parameters:

  • text (String, nil)

Returns:

  • (String, nil) —

    text, marked as HTML-safe



448
449
450
451
452
 
# File 'lib/haml/util.rb', line 448

def html_safe(text)
  return unless text
  return text.html_safe if defined?(ActiveSupport::SafeBuffer)
  text.html_safe!
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 #encoded into @options[:encoding] before being evaluated.

Parameters:

  • obj (Object)

Returns:

  • (String) 


698
699
700
701
702
703
 
# File 'lib/haml/util.rb', line 698

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.

Parameters:

  • enum (Enumerable)
  • val

Returns:

  • (Array) 


153
154
155
 
# File 'lib/haml/util.rb', line 153

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

#ironruby? ⇒ Boolean

Whether or not this is running on IronRuby.

Returns:

  • (Boolean) 


487
488
489
 
# File 'lib/haml/util.rb', line 487

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.

Parameters:

  • x (Array)
  • y (Array)

Yields:

  • (a, b) —

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

Yield Returns:

  • (Object, nil) —

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

Returns:

  • (Array) —

    The LCS



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

#load(data) ⇒ Object

A wrapper for Marshal.load that calls #_after_load on the object after loading it, if it's defined.

Parameters:

  • data (String) —

    The data to load.

Returns:

  • (Object) —

    The loaded object.



295
296
297
298
299
 
# File 'lib/haml/util.rb', line 295

def load(data)
  obj = Marshal.load(data)
  obj._after_load if obj.respond_to?(:_after_load)
  obj
end

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

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

Examples:

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

Parameters:

  • hash (Hash) —

    The hash to map

Yields:

  • (key, value) —

    A block in which the key-value pairs are transformed

Yield Parameters:

  • The (key) —

    hash key

  • The (value) —

    hash value

Yield Returns:

  • ((Object, Object)) —

    The new value for the [key, value] pair

Returns:

  • (Hash) —

    The mapped hash

See Also:



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.

Examples:

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

Parameters:

  • hash (Hash) —

    The hash to map

Yields:

  • (key) —

    A block in which the keys are transformed

Yield Parameters:

  • key (Object) —

    The key that should be mapped

Yield Returns:

  • (Object) —

    The new value for the key

Returns:

  • (Hash) —

    The mapped hash

See Also:



55
56
57
 
# File 'lib/haml/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.

Examples:

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

Parameters:

  • hash (Hash) —

    The hash to map

Yields:

  • (value) —

    A block in which the values are transformed

Yield Parameters:

  • value (Object) —

    The value that should be mapped

Yield Returns:

  • (Object) —

    The new value for the value

Returns:

  • (Hash) —

    The mapped hash

See Also:



71
72
73
 
# File 'lib/haml/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.

Examples:

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

Parameters:

  • arr (Array)

Returns:

  • (Array) —

    The enumerable with strings merged



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/haml/util.rb', line 130

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.

Parameters:

  • c (String) —

    All characters but the first are ignored.

Returns:

  • (Fixnum) —

    The ASCII code of c.



656
657
658
 
# File 'lib/haml/util.rb', line 656

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.

Examples:

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

Parameters:

  • arrs (Array<Array>)

Returns:

  • (Array<Arrays>) 


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.

Examples:

powerset([1, 2, 3]) #=>
  Set[Set[], Set[1], Set[2], Set[3], Set[1, 2], Set[2, 3], Set[1, 3], Set[1, 2, 3]]

Parameters:

  • arr (Enumerable)

Returns:

  • (Set<Set>) —

    The subsets of arr



100
101
102
103
104
105
106
107
108
109
 
# File 'lib/haml/util.rb', line 100

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.

Returns:

  • (String, nil) 


389
390
391
392
393
 
# File 'lib/haml/util.rb', line 389

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.

Returns:

  • (String, nil) 


375
376
377
378
379
380
381
382
 
# File 'lib/haml/util.rb', line 375

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.

Returns:

  • (Class) 


467
468
469
470
471
472
473
 
# File 'lib/haml/util.rb', line 467

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.

Returns:

  • (Boolean) 


438
439
440
 
# File 'lib/haml/util.rb', line 438

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.

Parameters:

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

Returns:

  • (Numeric) 


118
119
120
 
# File 'lib/haml/util.rb', line 118

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.

Returns:

  • (Boolean) 


499
500
501
502
503
 
# File 'lib/haml/util.rb', line 499

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

Returns:

  • (Boolean) 


509
510
511
 
# File 'lib/haml/util.rb', line 509

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.

Parameters:

  • file (String) —

    The filename relative to the Haml root

Returns:

  • (String) —

    The filename relative to the the working directory



28
29
30
 
# File 'lib/haml/util.rb', line 28

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.

Parameters:

  • set1 (Set)
  • set2 (Set)

Returns:

  • (Boolean) —

    Whether or not the sets are hashcode equal



687
688
689
690
 
# File 'lib/haml/util.rb', line 687

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.

Parameters:

  • set (Set)

Returns:

  • (Fixnum) —

    The order-independent hashcode of set



676
677
678
679
 
# File 'lib/haml/util.rb', line 676

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.

Yields:

  • A block in which no Haml warnings will be printed



323
324
325
326
327
328
329
 
# File 'lib/haml/util.rb', line 323

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.

Yields:

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



312
313
314
315
316
317
 
# File 'lib/haml/util.rb', line 312

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.

Parameters:

  • name (String) —

    The base name of the static method

  • vars (Array<Boolean>) —

    The static variable assignment

Returns:

  • (String) —

    The real name of the static method



774
775
776
 
# File 'lib/haml/util.rb', line 774

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

Parameters:

  • arr (Array)

Returns:

  • (Array) —

    arr



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.

Parameters:

  • ary (Array) —

    The array in which to make the substitution

  • from (Array) —

    The sequence of elements to replace with to

  • to (Array) —

    The sequence of elements to replace from with



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.

Examples:

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

Parameters:

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

    An array of pairs

Returns:

  • (Hash) —

    A hash



39
40
41
 
# File 'lib/haml/util.rb', line 39

def to_hash(arr)
  Hash[arr.compact]
end

#try_sass ⇒ Boolean

Try loading Sass. If the sass gem isn't installed, print a warning and load from the vendored gem.

Returns:

  • (Boolean) —

    True if Sass was successfully loaded from the sass gem, false otherwise.



344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
 
# File 'lib/haml/util.rb', line 344

def try_sass
  return true if defined?(::SASS_BEGUN_TO_LOAD)
  begin
    require 'sass/version'
    loaded = Sass.respond_to?(:version) && Sass.version[:major] &&
      Sass.version[:minor] && ((Sass.version[:major] > 3 && Sass.version[:minor] > 1) ||
      ((Sass.version[:major] == 3 && Sass.version[:minor] == 1) &&
        (Sass.version[:prerelease] || Sass.version[:name] != "Bleeding Edge")))
  rescue LoadError => e
    loaded = false
  end

  unless loaded
    haml_warn(<<WARNING)
Sass is in the process of being separated from Haml,
and will no longer be bundled at all in Haml 3.2.0.
Please install the 'sass' gem if you want to use Sass.
WARNING
    $".delete('sass/version')
    $LOAD_PATH.unshift(scope("vendor/sass/lib"))
  end
  loaded
end

#version_geq(v1, v2) ⇒ Boolean

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

Parameters:

  • v1 (String) —

    A version string.

  • v2 (String) —

    Another version string.

Returns:

  • (Boolean) 


268
269
270
 
# File 'lib/haml/util.rb', line 268

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.

Parameters:

  • v1 (String) —

    A version string.

  • v2 (String) —

    Another version string.

Returns:

  • (Boolean) 


239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/haml/util.rb', line 239

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.

Returns:

  • (Boolean) 


480
481
482
 
# File 'lib/haml/util.rb', line 480

def windows?
  RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i
end