Module | Erubis::Basic::Converter
In: | erubis/converter.rb

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

### Methods

add_expr convert_input init_converter pattern_regexp

### Included Modules

Erubis::Converter

### Constants

DEFAULT_REGEXP | = | pattern_regexp('<% %>') |  | DEFAULT_REGEXP = /(.*?)(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m DEFAULT_REGEXP = /(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m DEFAULT_REGEXP = /<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m

### Attributes

pattern | [RW] |
trim | [RW] |

### Public Instance methods

add_expr(src, code, indicator)

add expression code to src

[Source]

    # File erubis/converter.rb, line 177
        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)

[Source]

    # File erubis/converter.rb, line 128
        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={})

[Source]

    # File erubis/converter.rb, line 104
        def init_converter(properties={})
          super(properties)
          @pattern = properties[:pattern]
          @trim    = properties[:trim] != false
        end

### Protected Instance methods

pattern_regexp(pattern)

return regexp of pattern to parse eRuby script

[Source]

    # File erubis/converter.rb, line 113
        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

[Validate]