Class: Arrow::Template::RenderDirective

154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

# File 'lib/arrow/template/render.rb', line 154

def loadSubtemplate( filename, parser, state )
  nodes = nil
  load_path = state.template._load_path
  path = Arrow::Template.find_file( filename, load_path )
  subtemplate = nil

  # If the template has already been loaded, just reuse the nodelist
  state.data[:loadCache] ||= {}
  if state.data[:loadCache].include?( path )
    self.log.debug "Re-using cache template instance for %p" % path
    subtemplate = state.data[:loadCache][ path ]

  else
    # Load the content of the file and untaint it
    self.log.debug "Loading %p for the first time" % path
    content = File.read( path )
    content.untaint

    # Load a blank template object, cache it, then parse the content
    # into nodes and install the resulting syntax tree in the
    # template. The template object is created before parsing so that
    # recursive renders work.
    initialData = state.data.dup
    subtemplate = initialData[:loadCache][ path ] = Arrow::Template.new()
    nodes = parser.parse( content, state.template, initialData )
    subtemplate.install_syntax_tree( nodes )
  end

  return subtemplate
rescue Arrow::TemplateError, ::IOError => err
  msg = "#{err.class.name}: Render with #{filename}: #{err.message}"
  @nodes = [ Arrow::Template::CommentNode.new(msg) ]
end

84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

# File 'lib/arrow/template/render.rb', line 84

def parse_directive_contents( parser, state )
  scanner = state.scanner

  @name = parser.scan_for_identifier( state, true ) or
    raise Arrow::ParseError, "missing or malformed identifier"

  # If there's an infix operator, the rest of the tag up to the 'as' is
  # the methodchain. Can't use the parser's
  # #scan_for_methodchain because it just scans the rest of the tag.
  if scanner.scan( INFIX )
    # If the 'infix' was actually the left side of an index operator,
    # include it in the methodchain.
    start = scanner.matched == "[" ? scanner.pos - 1 : scanner.pos

    # Find the end of the methodchain
    # :FIXME: This will screw up if the methodchain itself has an ' as ' in it.
    scanner.scan_until( AS ) or
      raise Arrow::ParseError, "invalid render tag: no 'as' found"

    # StringScanner#pre_match is broken, so we have to do the equivalent
    # ourselves.
    offset = scanner.pos - scanner.matched.length - 1
    @methodchain = scanner.string[ start..offset ]

  # No methodchain
  else
    scanner.scan_until( AS ) or
      raise Arrow::ParseError, "invalid render tag: no 'as' found"
    @methodchain = ''
    self.log.debug "No methodchain parsed"
  end

  # Parse the target identifier
  @target = parser.scan_for_identifier( state ) or
    raise Arrow::ParseError, "missing or malformed target identifier"
  self.log.debug "Parsed target identifier: %p" % [@target]

  # Skip over the ' in ' bit
  scanner.skip( WHITESPACE )
  scanner.skip( IN ) or
    raise Arrow::ParseError, "invalid render tag: no 'in'"
  scanner.skip( WHITESPACE )

  # Parse the filename of the subtemplate to load
  filename = parser.scan_for_pathname( state ) or
    raise Arrow::ParseError, "No filename found for 'render'"
  filename.untaint
  self.log.debug "Parsed subtemplate filename: %p" % [filename]

  # Load and parse the subtemplate
  @subtemplate = self.loadSubtemplate( filename, parser, state )
  self.log.debug "Subtemplate set to: %p" % [@subtemplate]

  return true
end

143
144
145
146
147
148
149

# File 'lib/arrow/template/render.rb', line 143

def render_contents( template, scope )
  data = super

  @subtemplate.send( "#{@target}=", data )
  self.log.debug "Rendering %p" % [@subtemplate]
  return @subtemplate.render( nil, scope, template )
end