erubis-bmp 2.7.0.bmp

data/examples/pi/Makefile

@@ -0,0 +1,54 @@
+all = example.rb example.php example.c example.java example.scm example.pl example.js
+
+all:  $(all)
+
+example.rb:   example.eruby
+	erubis --pi -l ruby example.eruby > example.rb
+
+
+example.php:  example.ephp
+	erubis --pi -l php example.ephp > example.php
+
+example.c:    example.ec
+	erubis --pi -bl c example.ec > example.c
+
+example.java: example.ejava
+	erubis --pi -bl java example.ejava > example.java
+
+example.scm:  example.escheme
+	erubis --pi -l scheme --func=display example.escheme > example.scm
+#	erubis --pi -l scheme example.escheme > example.scm
+
+example.pl:   example.eperl
+	erubis --pi -l perl example.eperl > example.pl
+
+example.js:   example.ejs
+	erubis --pi -l javascript example.ejs > example.js
+
+
+###----------
+
+src = example.eruby example.ephp example.ec example.ejava example.escheme example.eperl example.ejs Makefile
+
+clean:
+	rm -f `ruby -e 'puts(Dir.glob("*.*") - %w[$(src)])'`
+#	rm -f $(all)
+
+compile:  example.bin example.class
+
+example.bin:   example.c
+	cc -o example.bin example.c
+
+example.class:  example.java
+	jikes example.java
+
+output:  $(all) example.bin example.class
+	erubis --pi example.eruby > example.ruby.result
+	#ruby example.rb > example.ruby.result
+	php example.php > example.php.result
+	./example.bin '<aaa>' 'b&b' '"ccc"' > example.c.result
+	java example > example.java.result
+	gosh example.scm > example.scm.result
+	#guile example.scm > example.scm.result
+	perl example.pl > example.pl.result
+

data/examples/pi/example.ec

@@ -0,0 +1,42 @@
+<?c
+#include <stdio.h>
+
+void escape(char *str, FILE *out);
+
+int main(int argc, char *argv[])
+{
+    int i;
+
+?>
+<p>Hello @!{argv[0]}@!</p>
+<table>
+  <tbody>
+    <?c for (i = 1; i < argc; i++) { ?>
+    <tr bgcolor="@{i % 2 == 0 ? "#FFCCCC" : "#CCCCFF"}@">
+      <td>@!{"%d", i}@</td>
+      <td>@{argv[i]}@</td>
+    </tr>
+    <?c } ?>
+  </tbody>
+</table>
+<?c
+
+    return 0; 
+}
+
+void escape(char *str, FILE *out)
+{
+    char *pch;
+    for (pch = str; *pch != '\0'; pch++) {
+        switch (*pch) {
+        case '&':   fputs("&amp;",  out);  break;
+        case '>':   fputs("&gt;",   out);  break;
+        case '<':   fputs("&lt;",   out);  break;
+        case '"':   fputs("&quot;", out);  break;
+        case '\'':  fputs("&#039;", out);  break;
+        default:    fputc(*pch, out);
+        }
+    }
+}
+
+?>

data/examples/pi/example.ejava

@@ -0,0 +1,45 @@
+<?java
+import java.util.*;
+
+public class example {
+
+  public static void main(String[] args) {
+    String user = "Erubis";
+    String[] list = { "<aaa>", "b&b", "\"ccc\"" };
+    StringBuffer _buf = new StringBuffer();
+?>
+<p>Hello @{user}@!</p>
+<table>
+  <tbody>
+    <?java for (int i = 0; i < list.length; i++) { ?>
+    <tr bgcolor="@{i % 2 == 0 ? "#FFCCCC" : "#CCCCFF"}@">
+      <td>@!{i + 1}@</td>
+      <td>@{list[i]}@</td>
+    </tr>
+    <?java } ?>
+  </tbody>
+</table>
+<?java
+    System.out.print(_buf.toString());
+  }
+
+  public static String escape(String s) {
+    StringBuffer sb = new StringBuffer();
+    for (int i = 0; i < s.length(); i++) {
+      char ch = s.charAt(i);
+      switch (ch) {
+      case '<':   sb.append("&lt;"); break;
+      case '>':   sb.append("&gt;"); break;
+      case '&':   sb.append("&amp;"); break;
+      case '"':   sb.append("&quot;"); break;
+      default:    sb.append(ch);
+      }
+    }
+    return sb.toString();
+  }
+
+  public static String escape(int i) {
+    return Integer.toString(i);
+  }
+}
+?>

data/examples/pi/example.ejs

@@ -0,0 +1,16 @@
+<?js
+   var user = 'Erubis';
+   var list = ['<aaa>', 'b&b', '"ccc"'];
+ ?>
+<p>Hello @{user}@!</p>
+<table>
+  <tbody>
+    <?js var i; ?>
+    <?js for (i = 0; i < list.length; i++) { ?>
+    <tr bgcolor="@{i % 2 == 0 ? '#FFCCCC' : '#CCCCFF'}@">
+      <td>@{i + 1}@</td>
+      <td>@{list[i]}@</td>
+    </tr>
+    <?js } ?>
+  </tbody>
+</table>

data/examples/pi/example.eperl

@@ -0,0 +1,16 @@
+<?perl
+   my $user = 'Erubis';
+   my @list = ('<aaa>', 'b&b', '"ccc"');
+?>
+<p>Hello @{$user}@!</p>
+<table>
+  <tbody>
+    <?perl $i = 0; ?>
+    <?perl for $item (@list) { ?>
+    <tr bgcolor=@!{++$i % 2 == 0 ? '#FFCCCC' : '#CCCCFF'}@">
+      <td>@!{$i}@</td>
+      <td>@{$item}@</td>
+    </tr>
+    <?perl } ?>
+  </tbody>
+</table>

data/examples/pi/example.ephp

@@ -0,0 +1,17 @@
+<?php
+   $user = "World";
+   $list = array('<aaa>', 'b&b', '"ccc"');
+?>
+<p>Hello @{$user}@!</p>
+<table>
+  <tbody>
+    <?php $i = 0 ?>
+    <?php foreach ($list as $item) { ?>
+    <?php   $i++; ?>
+    <tr bgcolor="@!{$i % 2 == 0 ? '#FFCCCC' : '#CCCCFF'}@">
+      <td>@!{$i}@</td>
+      <td>@{$item}@</td>
+    </tr>
+    <?php } ?>
+  </tbody>
+</table>

data/examples/pi/example.eruby

@@ -0,0 +1,15 @@
+<?rb
+   user = 'Erubis'
+   list = ['<aaa>', 'b&b', '"ccc"']
+ ?>
+<p>Hello @{user}@!</p>
+<table>
+  <tbody>
+    <?rb list.each_with_index do |item, i| ?>
+    <tr bgcolor="@!{i % 2 == 0 ? '#FFCCCC' : '#CCCCFF'}@">
+      <td>@!{i + 1}@</td>
+      <td>@{item}@</td>
+    </tr>
+    <?rb end ?>
+  </tbody>
+</table>

data/examples/pi/example.escheme

@@ -0,0 +1,26 @@
+<?scheme
+(let ((user "Erubis")
+      (items '("<aaa>" "b&b" "\"ccc\""))
+      (i 0))
+ ?>
+<p>Hello @!{user}@!</p>
+<table>
+  <tbody>
+<?scheme
+  (for-each
+   (lambda (item)
+     (set! i (+ i 1))
+ ?>
+    <tr bgcolor="@!{(if (= (modulo i 2) 0) "#FFCCCC" "#CCCCFF")}@">
+      <td>@!{i}@</td>
+      <td>@!{item}@</td>
+    </tr>
+<?scheme
+   ) ; lambda end
+   items) ; for-each end
+ ?>
+  </tbody>
+</table>
+<?scheme
+) ; let end
+?>

data/lib/erubis.rb

@@ -0,0 +1,73 @@
+##
+## $Release:$
+## $Copyright$
+##
+
+##
+## an implementation of eRuby
+##
+## ex.
+##   input = <<'END'
+##    <ul>
+##     <% for item in @list %>
+##      <li><%= item %>
+##          <%== item %></li>
+##     <% end %>
+##    </ul>
+##   END
+##   list = ['<aaa>', 'b&b', '"ccc"']
+##   eruby = Erubis::Eruby.new(input)
+##   puts "--- code ---"
+##   puts eruby.src
+##   puts "--- result ---"
+##   context = Erubis::Context.new()   # or new(:list=>list)
+##   context[:list] = list
+##   puts eruby.evaluate(context)
+##
+## result:
+##   --- source ---
+##   _buf = ''; _buf << '<ul>
+##   ';  for item in @list 
+##    _buf << '  <li>'; _buf << ( item ).to_s; _buf << '
+##   '; _buf << '      '; _buf << Erubis::XmlHelper.escape_xml( item ); _buf << '</li>
+##   ';  end 
+##    _buf << '</ul>
+##   ';
+##   _buf.to_s
+##   --- result ---
+##    <ul>
+##      <li><aaa>
+##          &lt;aaa&gt;</li>
+##      <li>b&b
+##          b&amp;b</li>
+##      <li>"ccc"
+##          &quot;ccc&quot;</li>
+##    </ul>
+##
+
+
+module Erubis
+  VERSION = ('$Release: 0.0.0 $' =~ /([.\d]+)/) && $1
+end
+
+require 'erubis/engine'
+#require 'erubis/generator'
+#require 'erubis/converter'
+#require 'erubis/evaluator'
+#require 'erubis/error'
+#require 'erubis/context'
+#requier 'erubis/util'
+require 'erubis/helper'
+require 'erubis/enhancer'
+#require 'erubis/tiny'
+require 'erubis/engine/eruby'
+#require 'erubis/engine/enhanced'    # enhanced eruby engines
+#require 'erubis/engine/optimized'   # generates optimized ruby code
+#require 'erubis/engine/ephp'
+#require 'erubis/engine/ec'
+#require 'erubis/engine/ejava'
+#require 'erubis/engine/escheme'
+#require 'erubis/engine/eperl'
+#require 'erubis/engine/ejavascript'
+
+require 'erubis/local-setting'

data/lib/erubis/context.rb

@@ -0,0 +1,83 @@
+##
+## $Release:$
+## $Copyright$
+##
+
+
+module Erubis
+
+
+  ##
+  ## context object for Engine#evaluate
+  ##
+  ## ex.
+  ##   template = <<'END'
+  ##   Hello <%= @user %>!
+  ##   <% for item in @list %>
+  ##    - <%= item %>
+  ##   <% end %>
+  ##   END
+  ##
+  ##   context = Erubis::Context.new(:user=>'World', :list=>['a','b','c'])
+  ##   # or
+  ##   # context = Erubis::Context.new
+  ##   # context[:user] = 'World'
+  ##   # context[:list] = ['a', 'b', 'c']
+  ##
+  ##   eruby = Erubis::Eruby.new(template)
+  ##   print eruby.evaluate(context)
+  ##
+  class Context
+    include Enumerable
+
+    def initialize(hash=nil)
+      hash.each do |name, value|
+        self[name] = value
+      end if hash
+    end
+
+    def [](key)
+      return instance_variable_get("@#{key}")
+    end
+
+    def []=(key, value)
+      return instance_variable_set("@#{key}", value)
+    end
+
+    def keys
+      return instance_variables.collect { |name| name[1..-1] }
+    end
+
+    def each
+      instance_variables.each do |name|
+        key = name[1..-1]
+        value = instance_variable_get(name)
+        yield(key, value)
+      end
+    end
+
+    def to_hash
+      hash = {}
+      self.keys.each { |key| hash[key] = self[key] }
+      return hash
+    end
+
+    def update(context_or_hash)
+      arg = context_or_hash
+      if arg.is_a?(Hash)
+        arg.each do |key, val|
+          self[key] = val
+        end
+      else
+        arg.instance_variables.each do |varname|
+          key = varname[1..-1]
+          val = arg.instance_variable_get(varname)
+          self[key] = val
+        end
+      end
+    end
+
+  end
+
+
+end

data/lib/erubis/converter.rb

@@ -0,0 +1,357 @@
+##
+## $Release:$
+## $Copyright$
+##
+
+require 'erubis/util'
+
+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