Module: Haml::Util

Extends:: Util
Defined in:: /var/www/haml-pages/.haml/lib/haml/util.rb,
/var/www/haml-pages/.haml/lib/haml/util/subset_map.rb

Overview

A module containing various useful functions.

Defined Under Namespace

Classes: StaticConditionalContext, SubsetMap

Constant Summary

RUBY_VERSION = An array of ints representing the Ruby version number.

::RUBY_VERSION.split(".").map {

Instance Method Summary

- (Boolean) ap_geq?(version) Returns whether this environment is using ActionPack of a version greater than or equal to that specified.
- (Boolean) ap_geq_3? 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.
- ([String, Fixnum, (String, nil)]) caller_info(entry = caller[1]) Returns information about the caller of the previous method.
- (String) check_encoding(str) {|msg| ... } Checks that the encoding of a string is valid in Ruby 1.9 and cleans up potential encoding gotchas like the UTF-8 BOM.
- (String) check_haml_encoding(str, &block) {|msg| ... } 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.
- ((String, Encoding)) check_sass_encoding(str, &block) {|msg| ... } 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 Haml::Buffer that need to be very fast, and take a lot of boolean parameters that are known at compile-time.
- (Enumerator) enum_cons(enum, n) A version of Enumerable#enum_cons that works in Ruby 1.8 and 1.9.
- (Enumerator) enum_slice(enum, n) A version of Enumerable#enum_slice that works in Ruby 1.8 and 1.9.
- (Enumerator) enum_with_index(enum) A version of Enumerable#enum_with_index that works in Ruby 1.8 and 1.9.
- (Array) flatten(arr, n) 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.
- (Boolean) has?(attr, klass, method) Checks to see if a class has a given method.
- (String^?) html_safe(text) Returns the given text, marked as being HTML-safe.
- (Array) intersperse(enum, val) Intersperses a value in an enumerable, as would be done with Array#join but without concatenating the array together afterwards.
- (Array) lcs(x, y, &block) {|a, b| ... } Computes a single longest common subsequence for x and y.
- (Hash) map_hash(hash, &block) {|key, value| ... } Maps the key-value pairs of a hash according to a block.
- (Hash) map_keys(hash) {|key| ... } Maps the keys in a hash according to a block.
- (Hash) map_vals(hash) {|value| ... } Maps the values in a hash according to a block.
- (Array) merge_adjacent_strings(enum) Concatenates all strings that are adjacent in an array, while leaving other elements as they are.
- (Fixnum) ord(c) Returns the ASCII code of the given character.
- (Array<Arrays>) paths(arrs) Return an array of all possible paths through the given arrays.
- (Set<Set>) powerset(arr) Computes the powerset of the given array.
- (String^?) rails_env Returns the environment of the Rails application, if this is running in a Rails context.
- (String^?) rails_root Returns the root of the Rails application, if this is running in a Rails context.
- (Class) rails_safe_buffer_class The class for the Rails SafeBuffer XSS protection class.
- (Boolean) rails_xss_safe? 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+.
- (Numeric) restrict(value, range) Restricts a number to falling within a given range.
- (Boolean) ruby1_8? Whether or not this is running under Ruby 1.8 or lower.
- (Boolean) ruby1_8_6? Whether or not this is running under Ruby 1.8.6 or lower.
- (String) scope(file) Returns the path of a file relative to the Haml root directory.
- (Boolean) set_eql?(set1, set2) Tests the hash-equality of two sets in a cross-version manner.
- (Fixnum) set_hash(set) 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.
- (String) static_method_name(name, *vars) Computes the name for a method defined via #def_static_method.
- (Array) strip_string_array(arr) 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.
- (Hash) to_hash(arr) Converts an array of [key, value] pairs to a hash.
- (Boolean) version_geq(v1, v2) Returns whether one version string represents the same or a more recent version than another.
- (Boolean) version_gt(v1, v2) Returns whether one version string represents a more recent version than another.
- (Boolean) windows? Whether or not this is running on Windows.

Instance Method Details

- (Boolean) ap_geq?(version)

Returns whether this environment is using ActionPack of a version greater than or equal to that specified.

Parameters:

(String) version — 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)

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 344

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

- (Boolean) ap_geq_3?

Returns whether this environment is using ActionPack version 3.0.0 or greater.

Returns:

(Boolean)



333
334
335

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 333

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:

(Object) text

Raises:

(Haml::Error)

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 392

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:

(#to_s) name — The name of the class to get. For example, :Error will return ActionView::TemplateError or ActionView::Template::Error.

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 360

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

- ([String, Fixnum, (String, nil)]) caller_info(entry = caller[1])

Returns information about the caller of the previous method.

Parameters:

(String) entry (defaults to: caller[1]) — 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

# File '/var/www/haml-pages/.haml/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

- (String) check_encoding(str) {|msg| ... }

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:

(String) str — 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:

(String) msg — The error message to be raised

Returns:

(String) — str, potentially with encoding gotchas like BOMs removed

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 445

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 <

- (String) check_haml_encoding(str, &block) {|msg| ... }

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.

Parameters:

(String) str — 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:

(String) msg — The error message to be raised

Returns:

(String) — The original string encoded properly

Raises:

(ArgumentError) — if the document declares an unknown encoding

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 491

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

- ((String, Encoding)) check_sass_encoding(str, &block) {|msg| ... }

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.

Parameters:

(String) str — 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:

(String) msg — The error message to be raised

Returns:

((String, Encoding)) — The original string encoded as UTF-8, and the source encoding of the string (or nil under Ruby 1.8)

Raises:

(Encoding::UndefinedConversionError) — if the source encoding cannot be converted to UTF-8
(ArgumentError) — if the document uses an unknown encoding with @charset

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 522

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

(Module) klass — The class on which to define the static method
(#to_s) name — The (base) name of the static method
(Array<Symbol>) args — The names of the arguments to the defined methods (not to the ERB template)
(Array<Symbol>) vars — The names of the static boolean variables to be made available to the ERB template
(String) erb — The template for the method code

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 710

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("def \#{static_method_name(name, *vars.map {|v| set.include?(v)})}(\#{args.join(', ')})\n  \#{ERB.new(erb).result(context)}\nend\n", info[0], info[1])
  end
end

- (Enumerator) enum_cons(enum, n)

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

Parameters:

(Enumerable) enum — The enumerable to get the enumerator for
(Fixnum) n — The size of each cons

Returns:

(Enumerator) — The consed enumerator



606
607
608

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 606

def enum_cons(enum, n)
  ruby1_8? ? enum.enum_cons(n) : enum.each_cons(n)
end

- (Enumerator) enum_slice(enum, n)

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

Parameters:

(Enumerable) enum — The enumerable to get the enumerator for
(Fixnum) n — The size of each slice

Returns:

(Enumerator) — The consed enumerator



615
616
617

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 615

def enum_slice(enum, n)
  ruby1_8? ? enum.enum_slice(n) : enum.each_slice(n)
end

- (Enumerator) enum_with_index(enum)

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

Parameters:

(Enumerable) enum — The enumerable to get the enumerator for

Returns:

(Enumerator) — The with-index enumerator



597
598
599

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 597

def enum_with_index(enum)
  ruby1_8? ? enum.enum_with_index : enum.each_with_index
end

- (Array) flatten(arr, n)

Flattens the first n nested arrays in a cross-version manner.

Parameters:

(Array) arr — The array to flatten
(Fixnum) n — The number of levels to flatten

Returns:

(Array) — The flattened array

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 632

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:

(String) msg

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 297

def haml_warn(msg)
  return if @@silence_warnings
  warn(msg)
end

- (Boolean) has?(attr, klass, method)

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:

(#to_s) attr — The (singular) name of the method-collection method (e.g. :instance_methods, :private_methods)
(Module) klass — The class to check the methods of which to check
(String, Symbol) method — The name of the method do check for

Returns:

(Boolean) — Whether or not the given collection has the given method



589
590
591

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 589

def has?(attr, klass, method)
  klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
end

- (String^?) html_safe(text)

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:

(String, nil) text

Returns:

(String, nil) — text, marked as HTML-safe

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 382

def html_safe(text)
  return unless text
  return text.html_safe if defined?(ActiveSupport::SafeBuffer)
  text.html_safe!
end

- (Array) intersperse(enum, val)

Intersperses a value in an enumerable, as would be done with Array#join but without concatenating the array together afterwards.

Parameters:

(Enumerable) enum
val

Returns:

(Array)



153
154
155

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 153

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

- (Array) lcs(x, y, &block) {|a, b| ... }

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:

(Array) x
(Array) y

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

# File '/var/www/haml-pages/.haml/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

- (Hash) map_hash(hash, &block) {|key, value| ... }

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}

Parameters:

(Hash) hash — The hash to map

Yields:

(key, value) — A block in which the key-value pairs are transformed

Yield Parameters:

(key) The — hash key
(value) The — hash value

Yield Returns:

((Object, Object)) — The new value for the [key, value] pair

Returns:

(Hash) — The mapped hash

Parameters:

(Hash) hash — The hash to map

Yields:

(key) — A block in which the keys are transformed

Yield Parameters:

(Object) key — The key that should be mapped

Yield Returns:

(Object) — The new value for the key

Returns:

(Hash) — The mapped hash

Parameters:

(Hash) hash — The hash to map

Yields:

(value) — A block in which the values are transformed

Yield Parameters:

(Object) value — The value that should be mapped

Yield Returns:

(Object) — The new value for the value

Returns:

(Hash) — The mapped hash

Parameters:

(Enumerable) enum

Returns:

(Array) — The enumerable with strings merged

# File '/var/www/haml-pages/.haml/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

- (Fixnum) ord(c)

Returns the ASCII code of the given character.

Parameters:

(String) c — All characters but the first are ignored.

Returns:

(Fixnum) — The ASCII code of c.



623
624
625

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 623

def ord(c)
  ruby1_8? ? c[0] : c.ord
end

- (Array<Arrays>) paths(arrs)

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:

(Array<Array>) arrs

Returns:

(Array<Arrays>)

# File '/var/www/haml-pages/.haml/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

- (Set<Set>) powerset(arr)

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]]

Parameters:

(Enumerable) arr

Returns:

(Set<Set>) — The subsets of arr

# File '/var/www/haml-pages/.haml/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

- (String^?) rails_env

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)

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 323

def rails_env
  return ::Rails.env.to_s if defined?(::Rails.env)
  return RAILS_ENV.to_s if defined?(RAILS_ENV)
  return nil
end

- (String^?) rails_root

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)

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 309

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

- (Class) rails_safe_buffer_class

The class for the Rails SafeBuffer XSS protection class. This varies depending on Rails version.

Returns:

(Class)

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 401

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

- (Boolean) rails_xss_safe?

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)



372
373
374

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 372

def rails_xss_safe?
  false
end

- (Numeric) restrict(value, range)

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:

(Numeric) value
(Range<Numeric>) range

Returns:

(Numeric)



119
120
121

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 119

def restrict(value, range)
  [[value, range.first].max, range.last].min
end

- (Boolean) ruby1_8?

Whether or not this is running under Ruby 1.8 or lower.

Returns:

(Boolean)



423
424
425

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 423

def ruby1_8?
  Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
end

- (Boolean) ruby1_8_6?

Whether or not this is running under Ruby 1.8.6 or lower. Note that lower versions are not officially supported.

Returns:

(Boolean)



431
432
433

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 431

def ruby1_8_6?
  ruby1_8? && Haml::Util::RUBY_VERSION[2] < 7
end

- (String) scope(file)

Returns the path of a file relative to the Haml root directory.

Parameters:

(String) file — The filename relative to the Haml root

Returns:

(String) — The filename relative to the the working directory



24
25
26

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 24

def scope(file)
  File.join(Haml::ROOT_DIR, file)
end

- (Boolean) set_eql?(set1, set2)

Tests the hash-equality of two sets in a cross-version manner. Aggravatingly, this is order-dependent in Ruby 1.8.6.

Parameters:

(Set) set1
(Set) set2

Returns:

(Boolean) — Whether or not the sets are hashcode equal

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 654

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

- (Fixnum) set_hash(set)

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

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 643

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

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 286

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

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 275

def silence_warnings
  the_real_stderr, $stderr = $stderr, StringIO.new
  yield
ensure
  $stderr = the_real_stderr
end

- (String) static_method_name(name, *vars)

Computes the name for a method defined via #def_static_method.

Parameters:

(String) name — The base name of the static method
(Array<Boolean>) vars — The static variable assignment

Returns:

(String) — The real name of the static method



729
730
731

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 729

def static_method_name(name, *vars)
  "#{name}_#{vars.map {|v| !!v}.join('_')}"
end

- (Array) strip_string_array(arr)

Destructively strips whitespace from the beginning and end of the first and last elements, respectively, in the array (if those elements are strings).

Parameters:

(Array) arr

Returns:

(Array) — arr

# File '/var/www/haml-pages/.haml/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:

(Array) ary — The array in which to make the substitution
(Array) from — The sequence of elements to replace with to
(Array) to — The sequence of elements to replace from with

# File '/var/www/haml-pages/.haml/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

- (Hash) to_hash(arr)

Converts an array of [key, value] pairs to a hash. For example:

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

Parameters:

(Array<(Object, Object)>) arr — An array of pairs

Returns:

(Hash) — A hash



36
37
38

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 36

def to_hash(arr)
  arr.compact.inject({}) {|h, (k, v)| h[k] = v; h}
end

- (Boolean) version_geq(v1, v2)

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

Parameters:

(String) v1 — A version string.
(String) v2 — Another version string.

Returns:

(Boolean)



268
269
270

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 268

def version_geq(v1, v2)
  version_gt(v1, v2) || !version_gt(v2, v1)
end

- (Boolean) version_gt(v1, v2)

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

Parameters:

(String) v1 — A version string.
(String) v2 — Another version string.

Returns:

(Boolean)

# File '/var/www/haml-pages/.haml/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

- (Boolean) windows?

Whether or not this is running on Windows.

Returns:

(Boolean)



414
415
416

# File '/var/www/haml-pages/.haml/lib/haml/util.rb', line 414

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

Module: Haml::Util

Overview

Defined Under Namespace

Constant Summary

Instance Method Summary

Instance Method Details

Parameters:

Returns:

Returns:

Parameters:

Raises:

Parameters:

Parameters:

Returns:

Parameters:

Yields:

Yield Parameters:

Returns:

Parameters:

Yields:

Yield Parameters:

Returns:

Raises:

Parameters:

Yields:

Yield Parameters:

Returns:

Raises:

Parameters:

Parameters:

Returns:

Parameters:

Returns:

Parameters:

Returns:

Parameters:

Returns:

Parameters:

Parameters:

Returns:

Parameters:

Returns:

Parameters:

Returns:

Parameters:

Yields:

Yield Returns:

Returns:

Parameters:

Yields:

Yield Parameters:

Yield Returns:

Returns:

See Also:

Parameters:

Yields:

Yield Parameters:

Yield Returns:

Returns:

See Also:

Parameters:

Yields:

Yield Parameters:

Yield Returns:

Returns:

See Also:

Parameters:

Returns:

Parameters:

Returns:

Examples:

Parameters:

Returns:

Parameters:

Returns:

Returns:

Returns:

Returns:

Returns:

Parameters: