Module: Haml::Util
- Extended by:
- Util
- Included in:
- Buffer, Util, Version, Sass::Engine, Sass::Plugin, Sass::Script::Color
- 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}
Instance Method Summary collapse
-
#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.
-
#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_with_index(enum) ⇒ Enumerator
A version of
Enumerable#enum_with_index
that works in Ruby 1.8 and 1.9. -
#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.
-
#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.
-
#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
-
#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.
-
#scope(file) ⇒ String
Returns the path of a file relative to the Haml root directory.
-
#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.
-
#to_hash(arr) ⇒ Hash
Converts an array of
[key, value]
pairs to a hash.
Instance Method Details
#assert_html_safe!(text)
Assert that a given object (usually a String) is HTML safe according to Rails' XSS handling, if it's loaded.
221 222 223 224 |
# File 'lib/haml/util.rb', line 221
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
.
190 191 192 193 |
# File 'lib/haml/util.rb', line 190
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.
142 143 144 145 146 |
# File 'lib/haml/util.rb', line 142
def caller_info(entry = caller[1])
info = entry.scan(/^(.*?):(-?.*?)(?::.*`(.+)')?$/).first
info[1] = info[1].to_i
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.
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 |
# File 'lib/haml/util.rb', line 250
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
|
#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.
353 354 355 356 357 358 359 360 361 362 363 364 |
# File 'lib/haml/util.rb', line 353
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_with_index(enum) ⇒ Enumerator
A version of Enumerable#enum_with_index
that works in Ruby 1.8 and 1.9.
298 299 300 |
# File 'lib/haml/util.rb', line 298
def enum_with_index(enum)
ruby1_8? ? enum.enum_with_index : enum.each_with_index
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.
290 291 292 |
# File 'lib/haml/util.rb', line 290
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
.
212 213 214 215 |
# File 'lib/haml/util.rb', line 212
def html_safe(text)
return text.html_safe if defined?(ActiveSupport::SafeBuffer)
text.html_safe!
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}
82 83 84 |
# File 'lib/haml/util.rb', line 82
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"}
47 48 49 |
# File 'lib/haml/util.rb', line 47
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}
64 65 66 |
# File 'lib/haml/util.rb', line 64
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"]
126 127 128 129 130 131 132 133 134 135 |
# File 'lib/haml/util.rb', line 126
def merge_adjacent_strings(enum)
e = enum.inject([]) do |a, e|
if e.is_a?(String) && a.last.is_a?(String)
a.last << e
else
a << e
end
a
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]]
95 96 97 98 99 100 101 102 103 104 |
# File 'lib/haml/util.rb', line 95
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.
176 177 178 179 180 |
# File 'lib/haml/util.rb', line 176
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.
165 166 167 168 169 |
# File 'lib/haml/util.rb', line 165
def rails_root
return Rails.root.to_s if defined?(Rails.root)
return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
return nil
end
|
#rails_safe_buffer_class
226 227 228 229 |
# File 'lib/haml/util.rb', line 226
def rails_safe_buffer_class
return ActionView::SafeBuffer if defined?(ActionView::SafeBuffer)
ActiveSupport::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.
202 203 204 |
# File 'lib/haml/util.rb', line 202
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.
113 114 115 |
# File 'lib/haml/util.rb', line 113
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.
236 237 238 |
# File 'lib/haml/util.rb', line 236
def ruby1_8?
Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
end
|
#scope(file) ⇒ String
Returns the path of a file relative to the Haml root directory.
18 19 20 |
# File 'lib/haml/util.rb', line 18
def scope(file)
File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), file)
end
|
#silence_warnings { ... }
Silence all output to STDERR within a block.
151 152 153 154 155 156 |
# File 'lib/haml/util.rb', line 151
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.
371 372 373 |
# File 'lib/haml/util.rb', line 371
def static_method_name(name, *vars)
"#{name}_#{vars.map {|v| !!v}.join('_')}"
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"}
30 31 32 |
# File 'lib/haml/util.rb', line 30
def to_hash(arr)
arr.compact.inject({}) {|h, (k, v)| h[k] = v; h}
end
|