simple-templater 0.0.1.3 → 0.0.1.4

data/gems/gems/erubis-2.6.5/lib/erubis/converter.rb

@@ -0,0 +1,357 @@
+##
+## $Release: 2.6.5 $
+## copyright(c) 2006-2009 kuwata-lab.com all rights reserved.
+##
+
+require 'abstract'
+
+module Erubis
+
+
+  ##
+  ## convert
+  ##
+  module Converter
+
+    attr_accessor :preamble, :postamble, :escape
+
+    def self.supported_properties    # :nodoc:
+      return [
+              [:preamble,  nil,    "preamble (no preamble when false)"],
+              [:postamble, nil,    "postamble (no postamble when false)"],
+              [:escape,    nil,    "escape expression or not in default"],
+             ]
+    end
+
+    def init_converter(properties={})
+      @preamble  = properties[:preamble]
+      @postamble = properties[:postamble]
+      @escape    = properties[:escape]
+    end
+
+    ## convert input string into target language
+    def convert(input)
+      codebuf = ""    # or []
+      @preamble.nil? ? add_preamble(codebuf) : (@preamble && (codebuf << @preamble))
+      convert_input(codebuf, input)
+      @postamble.nil? ? add_postamble(codebuf) : (@postamble && (codebuf << @postamble))
+      @_proc = nil    # clear cached proc object
+      return codebuf  # or codebuf.join()
+    end
+
+    protected
+
+    ##
+    ## detect spaces at beginning of line
+    ##
+    def detect_spaces_at_bol(text, is_bol)
+      lspace = nil
+      if text.empty?
+        lspace = "" if is_bol
+      elsif text[-1] == ?\n
+        lspace = ""
+      else
+        rindex = text.rindex(?\n)
+        if rindex
+          s = text[rindex+1..-1]
+          if s =~ /\A[ \t]*\z/
+            lspace = s
+            #text = text[0..rindex]
+            text[rindex+1..-1] = ''
+          end
+        else
+          if is_bol && text =~ /\A[ \t]*\z/
+            #lspace = text
+            #text = nil
+            lspace = text.dup
+            text[0..-1] = ''
+          end
+        end
+      end
+      return lspace
+    end
+
+    ##
+    ## (abstract) convert input to code
+    ##
+    def convert_input(codebuf, input)
+      not_implemented
+    end
+
+  end
+
+
+  module Basic
+  end
+
+
+  ##
+  ## basic converter which supports '<% ... %>' notation.
+  ##
+  module Basic::Converter
+    include Erubis::Converter
+
+    def self.supported_properties    # :nodoc:
+      return [
+              [:pattern,  '<% %>', "embed pattern"],
+              [:trim,      true,   "trim spaces around <% ... %>"],
+             ]
+    end
+
+    attr_accessor :pattern, :trim
+
+    def init_converter(properties={})
+      super(properties)
+      @pattern = properties[:pattern]
+      @trim    = properties[:trim] != false
+    end
+
+    protected
+
+    ## return regexp of pattern to parse eRuby script
+    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
+    module_function :pattern_regexp
+
+    #DEFAULT_REGEXP = /(.*?)(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
+    #DEFAULT_REGEXP = /(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
+    #DEFAULT_REGEXP = /<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
+    DEFAULT_REGEXP = pattern_regexp('<% %>')
+
+    public
+
+    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
+
+    ## add expression code to src
+    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
+
+  end
+
+
+  module PI
+  end
+
+  ##
+  ## Processing Instructions (PI) converter for XML.
+  ## this class converts '<?rb ... ?>' and '${...}' notation.
+  ##
+  module PI::Converter
+    include Erubis::Converter
+
+    def self.desc   # :nodoc:
+      "use processing instructions (PI) instead of '<% %>'"
+    end
+
+    def self.supported_properties    # :nodoc:
+      return [
+              [:trim,      true,   "trim spaces around <% ... %>"],
+              [:pi,        'rb',   "PI (Processing Instrunctions) name"],
+              [:embchar,   '@',    "char for embedded expression pattern('@{...}@')"],
+              [:pattern,  '<% %>', "embed pattern"],
+             ]
+    end
+
+    attr_accessor :pi, :prefix
+
+    def init_converter(properties={})
+      super(properties)
+      @trim    = properties.fetch(:trim, true)
+      @pi      = properties[:pi] if properties[:pi]
+      @embchar = properties[:embchar] || '@'
+      @pattern = properties[:pattern]
+      @pattern = '<% %>' if @pattern.nil?  #|| @pattern == true
+    end
+
+    def convert(input)
+      code = super(input)
+      return @header || @footer ? "#{@header}#{code}#{@footer}" : code
+    end
+
+    protected
+
+    def convert_input(codebuf, input)
+      unless @regexp
+        @pi ||= 'e'
+        ch = Regexp.escape(@embchar)
+        if @pattern
+          left, right = @pattern.split(' ')
+          @regexp = /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/m
+        else
+          @regexp = /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}/m
+        end
+      end
+      #
+      is_bol = true
+      pos = 0
+      input.scan(@regexp) do |pi_arg, stmt, rspace,
+                              indicator1, expr1, indicator2, expr2|
+        match = Regexp.last_match
+        len = match.begin(0) - pos
+        text = input[pos, len]
+        pos = match.end(0)
+        lspace = stmt ? detect_spaces_at_bol(text, is_bol) : nil
+        is_bol = stmt && rspace ? true : false
+        add_text(codebuf, text) # unless text.empty?
+        #
+        if stmt
+          if @trim && lspace && rspace
+            add_pi_stmt(codebuf, "#{lspace}#{stmt}#{rspace}", pi_arg)
+          else
+            add_text(codebuf, lspace) if lspace
+            add_pi_stmt(codebuf, stmt, pi_arg)
+            add_text(codebuf, rspace) if rspace
+          end
+        else
+          add_pi_expr(codebuf, expr1 || expr2, indicator1 || indicator2)
+        end
+      end
+      #rest = $' || input                        # ruby1.8
+      rest = pos == 0 ? input : input[pos..-1]   # ruby1.9
+      add_text(codebuf, rest)
+    end
+
+    #--
+    #def convert_input(codebuf, input)
+    #  parse_stmts(codebuf, input)
+    #  #parse_stmts2(codebuf, input)
+    #end
+    #
+    #def parse_stmts(codebuf, input)
+    #  #regexp = pattern_regexp(@pattern)
+    #  @pi ||= 'e'
+    #  @stmt_pattern ||= /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?/m
+    #  is_bol = true
+    #  pos = 0
+    #  input.scan(@stmt_pattern) do |pi_arg, code, rspace|
+    #    match = Regexp.last_match
+    #    len  = match.begin(0) - pos
+    #    text = input[pos, len]
+    #    pos  = match.end(0)
+    #    lspace = detect_spaces_at_bol(text, is_bol)
+    #    is_bol = rspace ? true : false
+    #    parse_exprs(codebuf, text) # unless text.empty?
+    #    if @trim && lspace && rspace
+    #      add_pi_stmt(codebuf, "#{lspace}#{code}#{rspace}", pi_arg)
+    #    else
+    #      add_text(codebuf, lspace)
+    #      add_pi_stmt(codebuf, code, pi_arg)
+    #      add_text(codebuf, rspace)
+    #    end
+    #  end
+    #  rest = $' || input
+    #  parse_exprs(codebuf, rest)
+    #end
+    #
+    #def parse_exprs(codebuf, input)
+    #  unless @expr_pattern
+    #    ch = Regexp.escape(@embchar)
+    #    if @pattern
+    #      left, right = @pattern.split(' ')
+    #      @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/
+    #    else
+    #      @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}/
+    #    end
+    #  end
+    #  pos = 0
+    #  input.scan(@expr_pattern) do |indicator1, code1, indicator2, code2|
+    #    indicator = indicator1 || indicator2
+    #    code = code1 || code2
+    #    match = Regexp.last_match
+    #    len  = match.begin(0) - pos
+    #    text = input[pos, len]
+    #    pos  = match.end(0)
+    #    add_text(codebuf, text) # unless text.empty?
+    #    add_pi_expr(codebuf, code, indicator)
+    #  end
+    #  rest = $' || input
+    #  add_text(codebuf, rest)
+    #end
+    #++
+
+    def add_pi_stmt(codebuf, code, pi_arg)  # :nodoc:
+      case pi_arg
+      when nil      ;  add_stmt(codebuf, code)
+      when 'header' ;  @header = code
+      when 'footer' ;  @footer = code
+      when 'comment';  add_stmt(codebuf, "\n" * code.count("\n"))
+      when 'value'  ;  add_expr_literal(codebuf, code)
+      else          ;  add_stmt(codebuf, code)
+      end
+    end
+
+    def add_pi_expr(codebuf, code, indicator)  # :nodoc:
+      case indicator
+      when nil, '', '=='    # @{...}@ or <%== ... %>
+        @escape == false ? add_expr_literal(codebuf, code) : add_expr_escaped(codebuf, code)
+      when '!', '='         # @!{...}@ or <%= ... %>
+        @escape == false ? add_expr_escaped(codebuf, code) : add_expr_literal(codebuf, code)
+      when '!!', '==='      # @!!{...}@ or <%=== ... %>
+        add_expr_debug(codebuf, code)
+      else
+        # ignore
+      end
+    end
+
+  end
+
+
+end

data/gems/gems/erubis-2.6.5/lib/erubis/engine/ec.rb

@@ -0,0 +1,117 @@
+##
+## $Release: 2.6.5 $
+## copyright(c) 2006-2009 kuwata-lab.com all rights reserved.
+##
+
+require 'erubis/engine'
+require 'erubis/enhancer'
+
+
+module Erubis
+
+
+  module CGenerator
+    include Generator
+
+    def self.supported_properties()  # :nodoc:
+      return [
+              [:indent, '',       "indent spaces (ex. '  ')"],
+              [:out,    'stdout', "output file pointer name"],
+            ]
+    end
+
+    def init_generator(properties={})
+      super
+      @escapefunc ||= "escape"
+      @indent = properties[:indent] || ''
+      @out = properties[:out] || 'stdout'
+    end
+
+    def add_preamble(src)
+      src << "#line 1 \"#{self.filename}\"\n" if self.filename
+    end
+
+    def escape_text(text)
+      @@table_ ||= { "\r"=>"\\r", "\n"=>"\\n", "\t"=>"\\t", '"'=>'\\"', "\\"=>"\\\\" }
+      text.gsub!(/[\r\n\t"\\]/) { |m| @@table_[m] }
+      return text
+    end
+
+    def escaped_expr(code)
+      return "#{@escapefunc}(#{code.strip}, #{@out})"
+    end
+
+    def add_text(src, text)
+      return if text.empty?
+      src << (src.empty? || src[-1] == ?\n ? @indent : ' ')
+      src << "fputs("
+      i = 0
+      text.each_line do |line|
+        src << "\n" << @indent << '      ' if i > 0
+        i += 1
+        src << '"' << escape_text(line) << '"'
+      end
+      src << ", #{@out});"   #<< (text[-1] == ?\n ? "\n" : "")
+      src << "\n" if text[-1] == ?\n
+    end
+
+    def add_stmt(src, code)
+      src << code
+    end
+
+    def add_expr_literal(src, code)
+      src << @indent if src.empty? || src[-1] == ?\n
+      src << " fprintf(#{@out}, " << code.strip << ');'
+    end
+
+    def add_expr_escaped(src, code)
+      src << @indent if src.empty? || src[-1] == ?\n
+      src << ' ' << escaped_expr(code) << ';'
+    end
+
+    def add_expr_debug(src, code)
+      code.strip!
+      s = nil
+      if code =~ /\A\".*?\"\s*,\s*(.*)/
+        s = $1.gsub(/[%"]/, '\\\1') + '='
+      end
+      src << @indent if src.empty? || src[-1] == ?\n
+      src << " fprintf(stderr, \"*** debug: #{s}\" #{code});"
+    end
+
+    def add_postamble(src)
+      # empty
+    end
+
+  end
+
+
+  ##
+  ## engine for C
+  ##
+  class Ec < Basic::Engine
+    include CGenerator
+  end
+
+
+  class EscapedEc < Ec
+    include EscapeEnhancer
+  end
+
+
+  #class XmlEc < Ec
+  #  include EscapeEnhancer
+  #end
+
+  class PI::Ec < PI::Engine
+    include CGenerator
+
+    def init_converter(properties={})
+      @pi = 'c'
+      super(properties)
+    end
+
+  end
+
+
+end

data/gems/gems/erubis-2.6.5/lib/erubis/engine/ejava.rb

@@ -0,0 +1,110 @@
+##
+## $Release: 2.6.5 $
+## copyright(c) 2006-2009 kuwata-lab.com all rights reserved.
+##
+
+require 'erubis/engine'
+require 'erubis/enhancer'
+
+
+module Erubis
+
+
+  module JavaGenerator
+    include Generator
+
+    def self.supported_properties()   # :nodoc:
+      return [
+              [:indent,   '',       "indent spaces (ex. '  ')"],
+              [:buf,      '_buf',   "output buffer name"],
+              [:bufclass, 'StringBuffer', "output buffer class (ex. 'StringBuilder')"],
+            ]
+    end
+
+    def init_generator(properties={})
+      super
+      @escapefunc ||= 'escape'
+      @indent = properties[:indent] || ''
+      @buf = properties[:buf] || '_buf'
+      @bufclass = properties[:bufclass] || 'StringBuffer'
+    end
+
+    def add_preamble(src)
+      src << "#{@indent}#{@bufclass} #{@buf} = new #{@bufclass}();"
+    end
+
+    def escape_text(text)
+      @@table_ ||= { "\r"=>"\\r", "\n"=>"\\n", "\t"=>"\\t", '"'=>'\\"', "\\"=>"\\\\" }
+      return text.gsub!(/[\r\n\t"\\]/) { |m| @@table_[m] } || text
+    end
+
+    def add_text(src, text)
+      return if text.empty?
+      src << (src.empty? || src[-1] == ?\n ? @indent : ' ')
+      src << @buf << ".append("
+      i = 0
+      text.each_line do |line|
+        src << "\n" << @indent << '          + ' if i > 0
+        i += 1
+        src << '"' << escape_text(line) << '"'
+      end
+      src << ");" << (text[-1] == ?\n ? "\n" : "")
+    end
+
+    def add_stmt(src, code)
+      src << code
+    end
+
+    def add_expr_literal(src, code)
+      src << @indent if src.empty? || src[-1] == ?\n
+      code.strip!
+      src << " #{@buf}.append(#{code});"
+    end
+
+    def add_expr_escaped(src, code)
+      add_expr_literal(src, escaped_expr(code))
+    end
+
+    def add_expr_debug(src, code)
+      code.strip!
+      src << @indent if src.empty? || src[-1] == ?\n
+      src << " System.err.println(\"*** debug: #{code}=\"+(#{code}));"
+    end
+
+    def add_postamble(src)
+      src << "\n" if src[-1] == ?;
+      src << @indent << "return " << @buf << ".toString();\n"
+      #src << @indent << "System.out.print(" << @buf << ".toString());\n"
+    end
+
+  end
+
+
+  ##
+  ## engine for Java
+  ##
+  class Ejava < Basic::Engine
+    include JavaGenerator
+  end
+
+
+  class EscapedEjava < Ejava
+    include EscapeEnhancer
+  end
+
+
+  #class XmlEjava < Ejava
+  #  include EscapeEnhancer
+  #end
+
+  class PI::Ejava < PI::Engine
+    include JavaGenerator
+
+    def init_converter(properties={})
+      @pi = 'java'
+      super(properties)
+    end
+
+  end
+
+end

data/gems/gems/erubis-2.6.5/lib/erubis/engine/ejavascript.rb

@@ -0,0 +1,119 @@
+##
+## $Release: 2.6.5 $
+## copyright(c) 2006-2009 kuwata-lab.com all rights reserved.
+##
+
+require 'erubis/engine'
+require 'erubis/enhancer'
+
+
+module Erubis
+
+
+  module JavascriptGenerator
+    include Generator
+
+    def self.supported_properties()   # :nodoc:
+      list = []
+      #list << [:indent,   '',       "indent spaces (ex. '  ')"]
+      #list << [:buf,      '_buf',   "output buffer name"]
+      list << [:docwrite, true,     "use 'document.write()' when true"]
+      return list
+    end
+
+    def init_generator(properties={})
+      super
+      @escapefunc ||= 'escape'
+      @indent = properties[:indent] || ''
+      @buf = properties[:out] || '_buf'
+      @docwrite = properties[:docwrite] != false  # '!= false' will be removed in the next release
+    end
+
+    def add_preamble(src)
+      src << "#{@indent}var #{@buf} = [];"
+    end
+
+    def escape_text(text)
+      @@table_ ||= { "\r"=>"\\r", "\n"=>"\\n\\\n", "\t"=>"\\t", '"'=>'\\"', "\\"=>"\\\\" }
+      return text.gsub!(/[\r\n\t"\\]/) { |m| @@table_[m] } || text
+    end
+
+    def add_indent(src, indent)
+      src << (src.empty? || src[-1] == ?\n ? indent : ' ')
+    end
+
+    def add_text(src, text)
+      return if text.empty?
+      add_indent(src, @indent)
+      src << @buf << '.push("'
+      s = escape_text(text)
+      if s[-1] == ?\n
+        s[-2, 2] = ''
+        src << s << "\");\n"
+      else
+        src << s << "\");"
+      end
+    end
+
+    def add_stmt(src, code)
+      src << code
+    end
+
+    def add_expr_literal(src, code)
+      add_indent(src, @indent)
+      code.strip!
+      src << "#{@buf}.push(#{code});"
+    end
+
+    def add_expr_escaped(src, code)
+      add_expr_literal(src, escaped_expr(code))
+    end
+
+    def add_expr_debug(src, code)
+      add_indent(src, @indent)
+      code.strip!
+      src << "alert(\"*** debug: #{code}=\"+(#{code}));"
+    end
+
+    def add_postamble(src)
+      src << "\n" if src[-1] == ?;
+      if @docwrite
+        src << @indent << 'document.write(' << @buf << ".join(\"\"));\n"
+      else
+        src << @indent << @buf << ".join(\"\");\n"
+      end
+    end
+
+  end
+
+
+  ##
+  ## engine for JavaScript
+  ##
+  class Ejavascript < Basic::Engine
+    include JavascriptGenerator
+  end
+
+
+  class EscapedEjavascript < Ejavascript
+    include EscapeEnhancer
+  end
+
+
+  #class XmlEjavascript < Ejavascript
+  #  include EscapeEnhancer
+  #end
+
+
+  class PI::Ejavascript < PI::Engine
+    include JavascriptGenerator
+
+    def init_converter(properties={})
+      @pi = 'js'
+      super(properties)
+    end
+
+  end
+
+
+end