kwartz 3.0.0

data/examples/table1/table1.jstl.plogic

@@ -0,0 +1,21 @@
+#row {
+  attrs:  "bgcolor" color;
+  logic: {
+    <c:forEach var="item" items="${list}" varStatus="loop">
+      <c:set var="color" value="${loop.index % 2 == 0 ? '#FFCCCC' : '#CCCCFF'}"/>
+      _elem
+    </c:forEach>
+  }
+}
+
+#name {
+  value:  item.name;
+}
+
+#mail {
+  value:  item.mail;
+}
+
+#dummy1 {
+  logic: { }   /* ignore this element */
+}

data/examples/table1/table1.php.plogic

@@ -0,0 +1,22 @@
+#row {
+  attrs:  "bgcolor" $color;
+  logic: {
+    $i = 0;
+    foreach ($list as $item) {
+      $color = ++$i % 2 == 0 ? '#FFCCCC' : '#CCCCFF';
+      _elem();
+    }
+  }
+}
+
+#name {
+  value:  $item['name'];
+}
+
+#mail {
+  value:  $item['mail'];
+}
+
+#dummy1 {
+  logic: { }   /* ignore this element */
+}

data/kwartz.gemspec

@@ -0,0 +1,55 @@
+#!/usr/bin/ruby
+
+###
+### RubyGems Specification file for Kwartz-ruby
+###
+### $Rev: 117 $
+### $Release: 3.0.0 $
+### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
+###
+
+require 'rubygems'
+
+spec = Gem::Specification.new do |s|
+  ## package information
+  s.name        = 'kwartz'
+  s.author      = 'Makoto Kuwata'
+  s.version     = ("$Release: 3.0.0 $" =~ /[\.\d]+/) && $&
+  s.platform    = Gem::Platform::RUBY
+  s.homepage    = 'http://www.kuwata-lab.com/kwartz'
+  s.summary     = "a template system for Ruby, PHP, and Java"
+  s.description = <<-'END'
+  Kwartz is a template system which realized the concept
+  'Independence of Presentation Logic'(IoPL).
+  It means that Kwartz can separates presentation logics from
+  both business logics (= main program) and presentation data
+  file (= HTML file), thus HTML design is not breaded at all.
+  In addition, Kwartz supports eRuby, PHP, JSP, and ePerl.
+  END
+  
+  ## files
+  files = []
+  files += Dir.glob('lib/**/*')
+  files += Dir.glob('bin/**/*')
+  files += Dir.glob('examples/**/*')
+  files += Dir.glob('test/**/*')
+  #files += Dir.glob('man/**/*')
+  files += [ "doc/users-guide.html",
+             "doc/reference.html",
+             "doc/p-pattern.html",
+             "doc/docstyle.css",
+             #"doc/design.css", "doc/design.html",
+           ]
+  files += Dir.glob('doc-api/**/*')
+  files += %w[README.txt ChangeLog COPYING setup.rb kwartz.gemspec]
+  s.files       = files
+  s.executables = ["kwartz"]
+  s.bindir      = "bin"
+  s.test_file   = 'test/test.rb'
+  s.add_dependency('abstract', ['>= 1.0.0'])
+end
+
+if $0 == __FILE__
+  Gem::manage_gems
+  Gem::Builder.new(spec).build
+end

data/lib/kwartz.rb

@@ -0,0 +1,13 @@
+###
+### $Rev: 103 $
+### $Release: 3.0.0 $
+### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
+###
+
+require 'kwartz/config'
+require 'kwartz/error'
+require 'kwartz/assert'
+require 'kwartz/node'
+require 'kwartz/parser'
+require 'kwartz/converter'
+require 'kwartz/translator'

data/lib/kwartz/assert.rb

@@ -0,0 +1,31 @@
+####
+#### $Rev: 103 $
+#### $Release: 3.0.0 $
+#### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
+####
+
+
+require 'kwartz/error'
+
+
+module Kwartz
+
+
+  class AssertionError < KwartzError
+    def initialize(message)
+      super(message)
+    end
+  end
+  
+
+  module Assertion
+    
+    def assert(message="")
+      raise AssertionError.new("*** assertion failed: #{message}")
+    end
+
+    module_function :assert
+  end
+
+
+end

data/lib/kwartz/binding/eperl.rb

@@ -0,0 +1,166 @@
+###
+### $Rev: 117 $
+### $Release: 3.0.0 $
+### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
+###
+
+require 'kwartz/assert'
+require 'kwartz/converter'
+require 'kwartz/translator'
+
+
+
+module Kwartz
+
+
+
+  ##
+  ## directive handler for ePerl
+  ##
+  class EperlHandler < Handler
+
+
+    PERL_DIRECTIVE_PATTERN = /\A(\w+)(?:\s*\(\s*(.*)\))?\z/
+
+    def directive_pattern
+      return PERL_DIRECTIVE_PATTERN
+    end
+
+
+    PERL_MAPPING_PATTERN = /\A'([-:\w]+)',\s*(.*)\z/
+
+    def mapping_pattern
+      return PERL_MAPPING_PATTERN
+    end
+
+
+    PERL_DIRECTIVE_FORMAT = '%s(%s)'
+
+    def directive_format
+      return PERL_DIRECTIVE_FORMAT
+    end
+
+
+    def handle(directive_name, directive_arg, directive_str, stag_info, etag_info, cont_stmts, attr_info, append_exprs, stmt_list)
+      ret = super
+      return ret if ret
+
+      d_name = directive_name
+      d_arg  = directive_arg
+      d_str  = directive_str
+
+      case directive_name
+
+      when :foreach, :Foreach, :FOREACH, :list, :List, :LIST
+        is_foreach = d_name == :foreach || d_name == :Foreach || d_name == :FOREACH
+        unless d_arg =~ /\A(\$\w+)(?:,\s*(\$\w+))?\s+in\s+(.*)\z/
+          raise convert_error("'#{d_str}': invalid argument.", stag_info.linenum)
+        end
+        loopvar = $1 ;  loopval = $2 ;  looplist = $3
+        counter = d_name == :foreach || d_name == :list ? nil : "#{loopvar}_ctr"
+        toggle  = d_name != :FOREACH && d_name != :LIST ? nil : "#{loopvar}_tgl"
+        stmt_list  <<  build_print_stmt(stag_info, attr_info, append_exprs)   if !is_foreach
+        stmt_list  <<  NativeStatement.new("my #{counter} = 0;") if counter
+        if loopval
+          stmt_list << NativeStatement.new("foreach my #{loopvar} (keys #{looplist}) {", :foreach)
+          stmt_list << NativeStatement.new("  my #{loopval} = #{looplist.sub(/\A%/,'$')}{#{loopvar}};")
+        else
+          stmt_list << NativeStatement.new("foreach my #{loopvar} (#{looplist}) {", :foreach)
+        end
+        stmt_list  <<  NativeStatement.new("  #{counter}++;") if counter
+        stmt_list  <<  NativeStatement.new("  my #{toggle} = #{counter}%2==0 ? #{self.even} : #{self.odd};") if toggle
+        stmt_list  <<  build_print_stmt(stag_info, attr_info, append_exprs)   if is_foreach
+        stmt_list.concat(cont_stmts)
+        stmt_list  <<  build_print_stmt(etag_info, nil, nil)                  if is_foreach
+        stmt_list  <<  NativeStatement.new("}", :foreach)
+        stmt_list  <<  build_print_stmt(etag_info, nil, nil)                  if !is_foreach
+
+      when :while, :loop
+        is_while = d_name == :while
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if !is_while
+        stmt_list << NativeStatement.new("while (#{d_arg}) {", :while)
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if is_while
+        stmt_list.concat(cont_stmts)
+        stmt_list << build_print_stmt(etag_info, nil, nil)                  if is_while
+        stmt_list << NativeStatement.new("}", :while)
+        stmt_list << build_print_stmt(etag_info, nil, nil)                  if !is_while
+
+      when :set
+        stmt_list << NativeStatement.new("#{d_arg};", :set)
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
+        stmt_list.concat(cont_stmts)
+        stmt_list << build_print_stmt(etag_info, nil, nil)
+
+      when :if
+        stmt_list << NativeStatement.new("if (#{d_arg}) {", :if)
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
+        stmt_list.concat(cont_stmts)
+        stmt_list << build_print_stmt(etag_info, nil, nil)
+        stmt_list << NativeStatement.new("}", :if)
+
+      when :elsif, :else
+        unless !stmt_list.empty? && (st=stmt_list[-1]).is_a?(NativeStatement) && (st.kind == :if || st.kind == :elseif)
+          raise convert_error("'#{d_str}': previous statement should be 'if' or 'elsif'.", stag_info.linenum)
+        end
+        stmt_list.pop    # delete 'end'
+        if d_name == :else
+          kind = :else
+          stmt_list << NativeStatement.new("} else {", :else)
+        else
+          kind = :elseif
+          stmt_list << NativeStatement.new("} elsif (#{d_arg}) {", :elseif)
+        end
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
+        stmt_list.concat(cont_stmts)
+        stmt_list << build_print_stmt(etag_info, nil, nil)
+        stmt_list << NativeStatement.new("}", kind)
+
+      when :default, :Default, :DEFAULT
+        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
+        stmt_list << NativeStatement.new_without_newline("if (#{d_arg}) {", :if)
+        flag_escape = d_name == :default ? nil : (d_name == :Default)
+        stmt_list << PrintStatement.new([ NativeExpression.new(d_arg, flag_escape) ])
+        stmt_list << NativeStatement.new_without_newline("} else {", :else)
+        stmt_list.concat(cont_stmts)
+        stmt_list << NativeStatement.new_without_newline("}", :else)
+        stmt_list << build_print_stmt(etag_info, nil, nil)
+
+      else
+        return false
+
+      end #case
+      return true
+
+    end #def
+
+
+  end #class
+  Handler.register_class('eperl', EperlHandler)
+
+
+
+  ##
+  ## translator for ePerl
+  ##
+  class EperlTranslator < BaseTranslator
+
+
+    EPERL_EMBED_PATTERNS = [
+      '<? ',  ' !>',                 # statement
+      '<?= ', ' !>',                 # expression
+      '<?= encode_entities(', ') !>' # escaped expression
+    ]
+
+
+    def initialize(properties={})
+      super(EPERL_EMBED_PATTERNS, properties)
+    end
+
+
+  end
+  Translator.register_class('eperl', EperlTranslator)
+
+
+
+end #module

data/lib/kwartz/binding/erubis.rb

@@ -0,0 +1,61 @@
+###
+### $Rev: 110 $
+### $Release: 3.0.0 $
+### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
+###
+
+require 'kwartz/converter'
+require 'kwartz/translator'
+require 'kwartz/binding/eruby'
+
+
+
+module Kwartz
+
+
+
+  class ErubisHandler < ErubyHandler
+
+
+  end #class
+  Handler.register_class('erubis', ErubisHandler)
+
+
+
+  ##
+  ## translator for Erubis
+  ##
+  class ErubisTranslator < BaseTranslator
+
+
+    ERUBIS_EMBED_PATTERNS = [
+      '<% ',    ' %>',        # statement
+      '<%= ',   ' %>',        # expression
+      '<%== ',  ' %>',        # escaped expression
+    ]
+
+
+    def initialize(properties={})
+      super(ERUBIS_EMBED_PATTERNS, properties)
+      @escape = true if @escape == nil
+    end
+
+
+    #def translate_native_expr(expr)
+    #  assert unless expr.is_a?(NativeExpression)
+    #  flag_escape = expr.escape?
+    #  flag_escape = @escape if flag_escape == nil
+    #  if flag_escape == false
+    #    @sb << @expr_l << expr.code << @expr_r       # ex. <%== expr %>
+    #  else
+    #    @sb << @escape_l << expr.code << @escape_r   # ex. <%= expr %>
+    #  end
+    #end
+
+
+  end
+  Translator.register_class('erubis', ErubisTranslator)
+
+
+
+end #module

data/lib/kwartz/binding/eruby.rb

@@ -0,0 +1,164 @@
+###
+### $Rev: 111 $
+### $Release: 3.0.0 $
+### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
+###
+
+require 'kwartz/converter'
+require 'kwartz/translator'
+
+
+
+module Kwartz
+
+
+
+  ##
+  ## directive handler for eRuby
+  ##
+  class ErubyHandler < Handler
+
+
+    ERUBY_DIRECTIVE_PATTERN = /\A(\w+)(?:[:\s]\s*(.*))?\z/
+
+    def directive_pattern
+      return ERUBY_DIRECTIVE_PATTERN
+    end
+
+
+    ERUBY_MAPPING_PATTERN = /\A'([-:\w]+)'\s+(.*)\z/
+
+    def mapping_pattern
+      return ERUBY_MAPPING_PATTERN
+    end
+
+
+    ERUBY_DIRECTIVE_FORMAT = '%s: %s'
+
+    def directive_format
+      return ERUBY_DIRECTIVE_FORMAT
+    end
+
+
+    def handle(directive_name, directive_arg, directive_str, stag_info, etag_info, cont_stmts, attr_info, append_exprs, stmt_list)
+      ret = super
+      return ret if ret
+
+      d_name = directive_name
+      d_arg  = directive_arg
+      d_str  = directive_str
+
+      case directive_name
+
+      when :for, :For, :FOR, :list, :List, :LIST
+        unless d_arg =~ /\A(\w+)(?:,\s*(\w+))?\s+in\s+(.*)\z/ || d_arg =~ /\A(\w+)(?:,(\w+))?\s*[:=]\s*(.*)\z/
+          raise convert_error("#'{d_str}': invalid argument.", stag_info.linenum)
+        end
+        loopvar = $1 ;  loopval = $2 ;  looplist = $3
+        is_foreach = d_name == :for || d_name == :For || d_name == :FOR
+        counter = d_name == :for || d_name == :list ? nil : "#{loopvar}_ctr"
+        toggle  = d_name != :FOR && d_name != :LIST ? nil : "#{loopvar}_tgl"
+        stmt_list  <<  build_print_stmt(stag_info, attr_info, append_exprs)   if !is_foreach
+        stmt_list  <<  NativeStatement.new("#{counter} = 0") if counter
+        if loopval
+          stmt_list << NativeStatement.new("#{looplist}.each do |#{loopvar}, #{loopval}|", :foreach)
+        else
+          stmt_list << NativeStatement.new("for #{loopvar} in #{looplist} do", :foreach)
+        end
+        stmt_list  <<  NativeStatement.new("  #{counter} += 1") if counter
+        stmt_list  <<  NativeStatement.new("  #{toggle} = #{counter}%2==0 ? #{self.even} : #{self.odd}") if toggle
+        stmt_list  <<  build_print_stmt(stag_info, attr_info, append_exprs)   if is_foreach
+        stmt_list.concat(cont_stmts)
+        stmt_list  <<  build_print_stmt(etag_info, nil, nil)                  if is_foreach
+        stmt_list  <<  NativeStatement.new("end", :foreach)
+        stmt_list  <<  build_print_stmt(etag_info, nil, nil)                  if !is_foreach
+
+      when :while, :loop
+        is_while = d_name == :while
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if !is_while
+        stmt_list << NativeStatement.new("while #{d_arg} do", :while)
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if is_while
+        stmt_list.concat(cont_stmts)
+        stmt_list << build_print_stmt(etag_info, nil, nil)                  if is_while
+        stmt_list << NativeStatement.new("end", :while)
+        stmt_list << build_print_stmt(etag_info, nil, nil)                  if !is_while
+
+      when :set
+        stmt_list << NativeStatement.new(d_arg, :set)
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
+        stmt_list.concat(cont_stmts)
+        stmt_list << build_print_stmt(etag_info, nil, nil)
+
+      when :if
+        stmt_list << NativeStatement.new("if #{d_arg} then", :if)
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
+        stmt_list.concat(cont_stmts)
+        stmt_list << build_print_stmt(etag_info, nil, nil)
+        stmt_list << NativeStatement.new("end", :if)
+
+      when :elsif, :else
+        unless !stmt_list.empty? && (st=stmt_list[-1]).is_a?(NativeStatement) && (st.kind == :if || st.kind == :elseif)
+          raise convert_error("'#{d_str}': previous statement should be 'if' or 'elsif'.", stag_info.linenum)
+        end
+        stmt_list.pop    # delete 'end'
+        if d_name == :else
+          kind = :else
+          stmt_list << NativeStatement.new("else", :else)
+        else
+          kind = :elseif
+          stmt_list << NativeStatement.new("elsif #{d_arg} then", :elseif)
+        end
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
+        stmt_list.concat(cont_stmts)
+        stmt_list << build_print_stmt(etag_info, nil, nil)
+        stmt_list << NativeStatement.new("end", kind)
+
+      when :default, :Default, :DEFAULT
+        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
+        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
+        stmt_list << NativeStatement.new_without_newline("if (#{d_arg}) && !(#{d_arg}).to_s.empty? then", :if)
+        flag_escape = d_name == :default ? nil : (d_name == :Default)
+        stmt_list << PrintStatement.new([ NativeExpression.new(d_arg, flag_escape) ])
+        stmt_list << NativeStatement.new_without_newline("else", :else)
+        stmt_list.concat(cont_stmts)
+        stmt_list << NativeStatement.new_without_newline("end", :else)
+        stmt_list << build_print_stmt(etag_info, nil, nil)
+
+      else
+        return false
+
+      end #case
+      return true
+
+    end #def
+
+
+  end #class
+  Handler.register_class('eruby', ErubyHandler)
+
+
+
+  ##
+  ## translator for eRuby
+  ##
+  class ErubyTranslator < BaseTranslator
+
+
+    ERUBY_EMBED_PATTERNS = [
+      '<% ',    ' %>',        # statement
+      '<%= ',   ' %>',        # expression
+      '<%=h ',  ' %>',        # escaped expression
+    ]
+
+
+    def initialize(properties={})
+      super(ERUBY_EMBED_PATTERNS, properties)
+    end
+
+
+  end #class
+  Translator.register_class('eruby', ErubyTranslator)
+
+
+
+end #module