Class: ERB

Inherits:
Object
  • Object
show all
Defined in:
lib/erb.rb,
lib/erb.rb,
lib/erb.rb,
lib/erb.rb,
lib/erb.rb

Overview

– ERB::DefMethod

Defined Under Namespace

Modules: DefMethod, Util Classes: Compiler

Constant Summary collapse

Revision =

:nodoc: #‘

'$Date::                           $'

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(str, safe_level = NOT_GIVEN, legacy_trim_mode = NOT_GIVEN, legacy_eoutvar = NOT_GIVEN, trim_mode: nil, eoutvar: '_erbout') ⇒ ERB

Constructs a new ERB object with the template specified in str.

An ERB object works by building a chunk of Ruby code that will output the completed template when run.

If trim_mode is passed a String containing one or more of the following modifiers, ERB will adjust its code generation as listed:

%  enables Ruby code processing for lines beginning with %
<> omit newline for lines starting with <% and ending in %>
>  omit newline for lines ending in %>
-  omit blank lines ending in -%>

eoutvar can be used to set the name of the variable ERB will build up its output in. This is useful when you need to run multiple ERB templates through the same binding and/or when you want to control where output ends up. Pass the name of the variable to be used inside a String.

Example

require "erb"

# build data class
class Listings
  PRODUCT = { :name => "Chicken Fried Steak",
              :desc => "A well messages pattie, breaded and fried.",
              :cost => 9.95 }

  attr_reader :product, :price

  def initialize( product = "", price = "" )
    @product = product
    @price = price
  end

  def build
    b = binding
    # create and run templates, filling member data variables
    ERB.new(<<-'END_PRODUCT'.gsub(/^\s+/, ""), trim_mode: "", eoutvar: "@product").result b
      <%= PRODUCT[:name] %>
      <%= PRODUCT[:desc] %>
    END_PRODUCT
    ERB.new(<<-'END_PRICE'.gsub(/^\s+/, ""), trim_mode: "", eoutvar: "@price").result b
      <%= PRODUCT[:name] %> -- <%= PRODUCT[:cost] %>
      <%= PRODUCT[:desc] %>
    END_PRICE
  end
end

# setup template data
listings = Listings.new
listings.build

puts listings.product + "\n" + listings.price

Generates

Chicken Fried Steak
A well messages pattie, breaded and fried.

Chicken Fried Steak -- 9.95
A well messages pattie, breaded and fried.



809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
 
# File 'lib/erb.rb', line 809

def initialize(str, safe_level=NOT_GIVEN, legacy_trim_mode=NOT_GIVEN, legacy_eoutvar=NOT_GIVEN, trim_mode: nil, eoutvar: '_erbout')
  # Complex initializer for $SAFE deprecation at [Feature #14256]. Use keyword arguments to pass trim_mode or eoutvar.
  if safe_level != NOT_GIVEN
    warn 'Passing safe_level with the 2nd argument of ERB.new is deprecated. Do not use it, and specify other arguments as keyword arguments.', uplevel: 1 if $VERBOSE || !ZERO_SAFE_LEVELS.include?(safe_level)
  end
  if legacy_trim_mode != NOT_GIVEN
    warn 'Passing trim_mode with the 3rd argument of ERB.new is deprecated. Use keyword argument like ERB.new(str, trim_mode: ...) instead.', uplevel: 1 if $VERBOSE
    trim_mode = legacy_trim_mode
  end
  if legacy_eoutvar != NOT_GIVEN
    warn 'Passing eoutvar with the 4th argument of ERB.new is deprecated. Use keyword argument like ERB.new(str, eoutvar: ...) instead.', uplevel: 1 if $VERBOSE
    eoutvar = legacy_eoutvar
  end

  compiler = make_compiler(trim_mode)
  set_eoutvar(compiler, eoutvar)
  @src, @encoding, @frozen_string = *compiler.compile(str)
  @filename = nil
  @lineno = 0
  @_init = self.class.singleton_class
end

Instance Attribute Details

#encoding ⇒ Object (readonly)

The encoding to eval



846
847
848
 
# File 'lib/erb.rb', line 846

def encoding
  @encoding
end

#filename ⇒ Object

The optional filename argument passed to Kernel#eval when the ERB code is run



850
851
852
 
# File 'lib/erb.rb', line 850

def filename
  @filename
end

#lineno ⇒ Object

The optional lineno argument passed to Kernel#eval when the ERB code is run



854
855
856
 
# File 'lib/erb.rb', line 854

def lineno
  @lineno
end

#src ⇒ Object (readonly)

The Ruby code generated by ERB



843
844
845
 
# File 'lib/erb.rb', line 843

def src
  @src
end

Class Method Details

.version ⇒ Object

Returns revision information for the erb.rb module.



262
263
264
 
# File 'lib/erb.rb', line 262

def self.version
  "erb.rb [2.2.0 #{ERB::Revision.split[1]}]"
end

Instance Method Details

#def_class(superklass = Object, methodname = 'result') ⇒ Object

Define unnamed class which has methodname as instance method, and return it.

example:

class MyClass_
  def initialize(arg1, arg2)
    @arg1 = arg1;  @arg2 = arg2
  end
end
filename = 'example.rhtml'  # @arg1 and @arg2 are used in example.rhtml
erb = ERB.new(File.read(filename))
erb.filename = filename
MyClass = erb.def_class(MyClass_, 'render()')
print MyClass.new('foo', 123).render()



977
978
979
980
981
 
# File 'lib/erb.rb', line 977

def def_class(superklass=Object, methodname='result')
  cls = Class.new(superklass)
  def_method(cls, methodname, @filename || '(ERB)')
  cls
end

#def_method(mod, methodname, fname = '(ERB)') ⇒ Object

Define methodname as instance method of mod from compiled Ruby source.

example:

filename = 'example.rhtml'   # 'arg1' and 'arg2' are used in example.rhtml
erb = ERB.new(File.read(filename))
erb.def_method(MyClass, 'render(arg1, arg2)', filename)
print MyClass.new.render('foo', 123)



941
942
943
944
945
946
 
# File 'lib/erb.rb', line 941

def def_method(mod, methodname, fname='(ERB)')
  src = self.src.sub(/^(?!#|$)/) {"def #{methodname}\n"} << "\nend\n"
  mod.module_eval do
    eval(src, binding, fname, -1)
  end
end

#def_module(methodname = 'erb') ⇒ Object

Create unnamed module, define methodname as instance method of it, and return it.

example:

filename = 'example.rhtml'   # 'arg1' and 'arg2' are used in example.rhtml
erb = ERB.new(File.read(filename))
erb.filename = filename
MyModule = erb.def_module('render(arg1, arg2)')
class MyClass
  include MyModule
end



958
959
960
961
962
 
# File 'lib/erb.rb', line 958

def def_module(methodname='erb')
  mod = Module.new
  def_method(mod, methodname, @filename || '(ERB)')
  mod
end

#location=(filename, lineno) ⇒ Object

Sets optional filename and line number that will be used in ERB code evaluation and error reporting. See also #filename= and #lineno=

erb = ERB.new('<%= some_x %>')
erb.render
# undefined local variable or method `some_x'
#   from (erb):1

erb.location = ['file.erb', 3]
# All subsequent error reporting would use new location
erb.render
# undefined local variable or method `some_x'
#   from file.erb:4



871
872
873
874
 
# File 'lib/erb.rb', line 871

def location=((filename, lineno))
  @filename = filename
  @lineno = lineno if lineno
end

#make_compiler(trim_mode) ⇒ Object

Creates a new compiler for ERB. See ERB::Compiler.new for details



838
839
840
 
# File 'lib/erb.rb', line 838

def make_compiler(trim_mode)
  ERB::Compiler.new(trim_mode)
end

#result(b = new_toplevel) ⇒ Object

Executes the generated ERB code to produce a completed template, returning the results of that code. (See ERB::new for details on how this process can be affected by safe_level.)

b accepts a Binding object which is used to set the context of code evaluation.



901
902
903
904
905
906
 
# File 'lib/erb.rb', line 901

def result(b=new_toplevel)
  unless @_init.equal?(self.class.singleton_class)
    raise ArgumentError, "not initialized"
  end
  eval(@src, b, (@filename || '(erb)'), @lineno)
end

#result_with_hash(hash) ⇒ Object

Render a template on a new toplevel binding with local variables specified by a Hash object.



910
911
912
913
914
915
916
 
# File 'lib/erb.rb', line 910

def result_with_hash(hash)
  b = new_toplevel(hash.keys)
  hash.each_pair do |key, value|
    b.local_variable_set(key, value)
  end
  result(b)
end

#run(b = new_toplevel) ⇒ Object

Generate results and print them. (see ERB#result)



889
890
891
 
# File 'lib/erb.rb', line 889

def run(b=new_toplevel)
  print self.result(b)
end

#set_eoutvar(compiler, eoutvar = '_erbout') ⇒ Object

Can be used to set eoutvar as described in ERB::new. It’s probably easier to just use the constructor though, since calling this method requires the setup of an ERB compiler object.



881
882
883
884
885
886
 
# File 'lib/erb.rb', line 881

def set_eoutvar(compiler, eoutvar = '_erbout')
  compiler.put_cmd = "#{eoutvar}.<<"
  compiler.insert_cmd = "#{eoutvar}.<<"
  compiler.pre_cmd = ["#{eoutvar} = +''"]
  compiler.post_cmd = [eoutvar]
end