Module: Erubis::Basic::Converter

Includes:
Converter
Included in:
Basic::Engine
Defined in:
lib/erubis/converter.rb

Overview

basic converter which supports ‘<% … %>’ notation.

Instance Attribute Summary collapse

Attributes included from Converter

#escape, #postamble, #preamble

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Converter

#convert

Instance Attribute Details

#pattern ⇒ Object

Returns the value of attribute pattern.



101
102
103
 
# File 'lib/erubis/converter.rb', line 101

def pattern
  @pattern
end

#trim ⇒ Object

Returns the value of attribute trim.



101
102
103
 
# File 'lib/erubis/converter.rb', line 101

def trim
  @trim
end

Class Method Details

.pattern_regexp(pattern) ⇒ Object

return regexp of pattern to parse eRuby script



112
113
114
115
116
117
 
# File 'lib/erubis/converter.rb', line 112

def pattern_regexp(pattern)
  @prefix, @postfix = pattern.split()   # '<% %>' => '<%', '%>'
  #return /(.*?)(^[ \t]*)?#{@prefix}(=+|\#)?(.*?)-?#{@postfix}([ \t]*\r?\n)?/m
  #return /(^[ \t]*)?#{@prefix}(=+|\#)?(.*?)-?#{@postfix}([ \t]*\r?\n)?/m
  return /#{@prefix}(=+|-|\#|%)?(.*?)([-=])?#{@postfix}([ \t]*\r?\n)?/m
end

.supported_properties ⇒ Object

:nodoc:



94
95
96
97
98
99
 
# File 'lib/erubis/converter.rb', line 94

def self.supported_properties    # :nodoc:
  return [
          [:pattern,  '<% %>', "embed pattern"],
          [:trim,      true,   "trim spaces around <% ... %>"],
         ]
end

Instance Method Details

#add_expr(src, code, indicator) ⇒ Object

add expression code to src



176
177
178
179
180
181
182
183
184
185
 
# File 'lib/erubis/converter.rb', line 176

def add_expr(src, code, indicator)
  case indicator
  when '='
    @escape ? add_expr_escaped(src, code) : add_expr_literal(src, code)
  when '=='
    @escape ? add_expr_literal(src, code) : add_expr_escaped(src, code)
  when '==='
    add_expr_debug(src, code)
  end
end

#convert_input(src, input) ⇒ Object 



127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/erubis/converter.rb', line 127

def convert_input(src, input)
  pat = @pattern
  regexp = pat.nil? || pat == '<% %>' ? DEFAULT_REGEXP : pattern_regexp(pat)
  pos = 0
  is_bol = true     # is beginning of line
  input.scan(regexp) do |indicator, code, tailch, rspace|
    match = Regexp.last_match()
    len  = match.begin(0) - pos
    text = input[pos, len]
    pos  = match.end(0)
    ch   = indicator ? indicator[0] : nil
    lspace = ch == ?= ? nil : detect_spaces_at_bol(text, is_bol)
    is_bol = rspace ? true : false
    add_text(src, text) if text && !text.empty?
    ## * when '<%= %>', do nothing
    ## * when '<% %>' or '<%# %>', delete spaces iff only spaces are around '<% %>'
    if ch == ?=              # <%= %>
      rspace = nil if tailch && !tailch.empty?
      add_text(src, lspace) if lspace
      add_expr(src, code, indicator)
      add_text(src, rspace) if rspace
    elsif ch == ?\#          # <%# %>
      n = code.count("\n") + (rspace ? 1 : 0)
      if @trim && lspace && rspace
        add_stmt(src, "\n" * n)
      else
        add_text(src, lspace) if lspace
        add_stmt(src, "\n" * n)
        add_text(src, rspace) if rspace
      end
    elsif ch == ?%           # <%% %>
      s = "#{lspace}#{@prefix||='<%'}#{code}#{tailch}#{@postfix||='%>'}#{rspace}"
      add_text(src, s)
    else                     # <% %>
      if @trim && lspace && rspace
        add_stmt(src, "#{lspace}#{code}#{rspace}")
      else
        add_text(src, lspace) if lspace
        add_stmt(src, code)
        add_text(src, rspace) if rspace
      end
    end
  end
  #rest = $' || input                        # ruby1.8
  rest = pos == 0 ? input : input[pos..-1]   # ruby1.9
  add_text(src, rest)
end

#init_converter(properties = {}) ⇒ Object 



103
104
105
106
107
 
# File 'lib/erubis/converter.rb', line 103

def init_converter(properties={})
  super(properties)
  @pattern = properties[:pattern]
  @trim    = properties[:trim] != false
end