kwartz 3.0.0 → 3.1.0

data/lib/kwartz/main.rb

@@ -1,18 +1,21 @@
 ###
-### $Rev: 113 $
-### $Release: 3.0.0 $
+### $Rev: 136 $
+### $Release: 3.1.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
 
 require 'kwartz'
 require 'kwartz/binding/eruby'
+require 'kwartz/binding/ruby'
 require 'kwartz/binding/php'
 require 'kwartz/binding/eperl'
 require 'kwartz/binding/rails'
 require 'kwartz/binding/jstl'
 require 'kwartz/binding/struts'
 require 'kwartz/binding/erubis'
+require 'kwartz/binding/pierubis'
+require 'kwartz/util'
 
 
 
@@ -190,8 +193,10 @@ module Kwartz
       [ ?D, :debug,        nil ],
       [ ?t, :untabify,     nil ],
       [ ?S, :intern,       nil ],
+      [ ?N, :notext,       nil ],
       [ ?l, :lang,         'lang name' ],
       [ ?k, :kanji,        'kanji code' ],
+      [ ?a, :action,       'action name' ],
       [ ?r, :requires,     'library name' ],
       [ ?p, :plogics,      'file name' ],
       [ ?P, :pstyle,       'parser style' ],
@@ -327,8 +332,24 @@ module Kwartz
         properties[:nl] ||= "\r\n"
       end
       translator = translator_class.new(properties)
+      if options.notext
+        translator.extend(Kwartz::NoTextEnhancer)
+      end
       output = translator.translate(stmt_list)
 
+      ## action
+      if options.action
+        case options.action
+        when 'compile'
+          # nothing
+        when 'defun'
+          basename = File.basename(pdata_filenames.first).sub(/\.\w+/, '')
+          output = Kwartz::Defun.defun(basename, output, lang, properties)
+        else
+          option_error("-#{options.chr(:action)} #{options.aciton}: invalid action.")
+        end
+      end
+
       ## load YAML file and evaluate eRuby script
       if options.yamlfile
         eruby_script = output
@@ -351,14 +372,14 @@ module Kwartz
           raise option_error("#{s}: file not found.")
         end
         str = File.read(options.yamlfile)
-        str = untabify(str) if options.untabify
+        str = Kwartz::Util.untabify(str) if options.untabify
         require 'yaml'
         ydoc = YAML.load(str)
         unless ydoc.is_a?(Hash)
           s = "-#{options.chr(:yamlfile)} #{options.yamlfile}"
           raise option_error("#{s}: not a mapping.")
         end
-        intern_hash_keys(ydoc) if options.intern
+        Kwartz::Util.intern_hash_keys(ydoc) if options.intern
         context = Object.new
         ydoc.each do |key, val|
           context.instance_variable_set("@#{key}", val)
@@ -379,12 +400,13 @@ module Kwartz
       sb = []
       sb << "kwartz - a template system which realized 'Independence of Presentation Logic'\n"
       sb << "Usage: #{@command} [..options..] [-p plogic] file.html [file2.html ...]\n"
-      sb << "  -h             : help\n"
+      sb << "  -h, --help     : help\n"
       sb << "  -v             : version\n"
       #sb << "  -D             : debug mode\n"
       sb << "  -e             : alias of '--escape=true'\n"
-      sb << "  -l lang        : eruby/php/eperl/rails/jstl (default 'eruby')\n"
+      sb << "  -l lang        : eruby/ruby/rails/php/jstl/eperl/erubis/pierubis (default 'eruby')\n"
       sb << "  -k kanji       : euc/sjis/utf8 (default nil)\n"
+      sb << "  -a action      : compile/defun (default 'compile')\n"
       sb << "  -r library,... : require libraries\n"
       sb << "  -p plogic,...  : presentation logic files\n"
       sb << "  -i pdata,...   : import presentation data files\n"
@@ -394,6 +416,7 @@ module Kwartz
       sb << "  -f yamlfile    : YAML file for context values\n"
       sb << "  -t             : expand tab character in YAML file\n"
       sb << "  -S             : convert mapping key from string to symbol in YAML file\n"
+      sb << "  -N             : print only program code (text is ignored)\n"
       #sb << "  -P style       : style of presentation logic (css/ruby/yaml)\n"
       sb << "  --dattr=str    : directive attribute name\n"
       sb << "  --odd=value    : odd value for FOREACH/LOOP directive (default \"'odd'\")\n"
@@ -409,8 +432,7 @@ module Kwartz
 
 
     def version
-      v = ('$Release: 3.0.0 $' =~ /[.\d]+/) && $&
-      return v
+      return RELEASE
     end
 
 
@@ -419,36 +441,6 @@ module Kwartz
     end
 
 
-    def untabify(str, width=8)
-      sb = ''
-      str.scan(/(.*?)\t/m) do |s, |
-        len = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
-        sb << s << (" " * (width - len % width))
-      end
-      return $' ? (sb << $') : str
-    end
-
-
-    def intern_hash_keys(obj, done={})
-      return if done.key?(obj.__id__)
-      case obj
-      when Hash
-        done[obj.__id__] = obj
-        obj.keys.each do |key|
-          obj[key.intern] = obj.delete(key) if key.is_a?(String)
-        end
-        obj.values.each do |val|
-          intern_hash_keys(val, done) if val.is_a?(Hash) || val.is_a?(Array)
-        end
-      when Array
-        done[obj.__id__] = obj
-        obj.each do |val|
-          intern_hash_keys(val, done) if val.is_a?(Hash) || val.is_a?(Array)
-        end
-      end
-    end
-
-
   end #class
 
 

data/lib/kwartz/node.rb

@@ -1,6 +1,6 @@
 ####
-#### $Rev: 117 $
-#### $Release: 3.0.0 $
+#### $Rev: 122 $
+#### $Release: 3.1.0 $
 #### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ####
 
@@ -125,7 +125,7 @@ module Kwartz
 
 
     def _inspect(indent=0)
-      return @code.inspect
+      return "<%#{@code}%>\n"
     end
 
 
@@ -154,9 +154,9 @@ module Kwartz
 
     def _inspect(indent=0)
       if @kind == :element || @kind == :content
-        return "_#{@kind}(#{@name.inspect})"
+        return "_#{@kind}(#{@name})\n"
       else
-        return "_#{@kind}"
+        return "_#{@kind}\n"
       end
     end
 
@@ -186,7 +186,7 @@ module Kwartz
       list = @args.collect { |arg|
         arg.is_a?(NativeExpression) ? "<%=#{arg.code}%>" : arg.inspect
       }
-      return "[ " + list.join(', ') + "]"
+      return "print(" + list.join(', ') + ")\n"
     end
 
 
@@ -312,38 +312,49 @@ module Kwartz
     end
 
 
+    def duplicate(name)
+      ruleset = dup()
+      ruleset.name   = name
+      ruleset.attrs  = @attrs.dup()  if @attrs
+      ruleset.append = @append.dup() if @append
+      ruleset.remove = @remove.dup() if @remove
+      ruleset.logic  = @logic.dup()  if @logic
+      return ruleset
+    end
+
+
     def _inspect(indent=0)
       space = '  ' * indent
       sb = []
-      sb << space <<   "name: #{@name.inspect}\n"
-      #sb << space <<   "value: #{@value == nil ? '' : @value.inspect}\n"
-      sb << space <<   "stag: #{@stag.code.inspect}\n" unless @stag.nil?
-      sb << space <<   "cont: #{@cont.code.inspect}\n" unless @cont.nil?
-      sb << space <<   "etag: #{@etag.code.inspect}\n" unless @etag.nil?
-      sb << space <<   "elem: #{@elem.code.inspect}\n" unless @elem.nil?
+      sb << space <<   "- name: #{@name}\n"
+      #sb << space <<   "  value: #{@value == nil ? '' : @value}\n"
+      sb << space <<   "  stag: #{@stag.code}\n" unless @stag.nil?
+      sb << space <<   "  cont: #{@cont.code}\n" unless @cont.nil?
+      sb << space <<   "  etag: #{@etag.code}\n" unless @etag.nil?
+      sb << space <<   "  elem: #{@elem.code}\n" unless @elem.nil?
       #
-      sb << space <<   "attrs:\n" if @attrs
+      sb << space <<   "  attrs:\n" if @attrs
       @attrs.keys.sort.each do |key|
         val = @attrs[key]
-        sb << space << "  - name:  #{key.inspect}\n"
-        sb << space << "    value: #{val.code.inspect}\n"
+        sb << space << "    - name:  #{key}\n"
+        sb << space << "      value: #{val.code}\n"
       end if @attrs
       #
-      sb << space <<   "append:\n" if @append
+      sb << space <<   "  append:\n" if @append
       @append.each do |expr|
-        sb << space << "  - #{expr.code.inspect}\n"
+        sb << space << "    - #{expr.code}\n"
       end if @append
       #
-      sb << space <<   "remove:\n" if @remove
+      sb << space <<   "  remove:\n" if @remove
       @remove.each do |name|
-        sb << space << "  - #{name.inspect}\n"
+        sb << space << "    - #{name}\n"
       end if @remove
       #
-      sb << space <<   "tagname: #{@tagname.inspect}\n" unless @tagname.nil?
+      sb << space <<   "  tagname: #{@tagname}\n" unless @tagname.nil?
       #
-      sb << space <<   "logic:\n" if @logic
+      sb << space <<   "  logic:\n" if @logic
       @logic.each do |stmt|
-        sb << space << "  - " << stmt._inspect() << "\n"
+        sb << space << "    - " << stmt._inspect()
       end if @logic
       #
       return sb.join
@@ -395,8 +406,10 @@ module Kwartz
       @end = stmt_list
     end
 
+
     private
 
+
     def _parse_stmts(str)
       return unless str
       stmt_list = []
@@ -412,34 +425,36 @@ module Kwartz
       return stmt_list
     end
 
+
     public
 
+
     def _inspect(indent=0)
       space = '  ' * indent
       sb = []
-      sb << space <<   "name: #{@name.inspect}\n"
+      sb << space <<   "- name: #{@name}\n"
       if @global
-        sb << space <<   "global:\n"
+        sb << space <<   "  global:\n"
         @global.each do |item|
-          sb << space << "  - #{item}\n"
+          sb << space << "    - #{item}\n"
         end
       end
       if @local
-        sb << space <<   "local:\n"
+        sb << space <<   "  local:\n"
         @local.each do |item|
-          sb << space << "  - #{item}\n"
+          sb << space << "    - #{item}\n"
         end
       end
       if @begin
-        sb << space << "begin:\n"
+        sb << space << "  begin:\n"
         @begin.each do |stmt|
-          sb << space << "  - #{stmt._inspect}\n"
+          sb << space << "    - #{stmt._inspect}"
         end
       end
       if @end
-        sb << space << "end:\n"
+        sb << space << "  end:\n"
         @end.each do |stmt|
-          sb << space << "  - #{stmt._inspect}\n"
+          sb << space << "    - #{stmt._inspect}"
         end
       end
       #

data/lib/kwartz/parser.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 117 $
-### $Release: 3.0.0 $
+### $Rev: 124 $
+### $Release: 3.1.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -69,6 +69,7 @@ module Kwartz
 
     ## called from parse() and initialize parser object
     def reset(input, filename='')
+      input  or raise ArgumentError.new("#{self.class.name}#reset() requires string argument.")
       @input   = input
       @filename = filename
       @linenum = 1       # 1 start
@@ -212,7 +213,7 @@ module Kwartz
     end
 
 
-    ## called from scan()
+    ## called from scan(),  return false when not hooked
     def scan_hook
       #not_implemented
     end
@@ -240,7 +241,7 @@ module Kwartz
 
       ## scan hook
       ret = scan_hook()    # scan_hook() is overrided in subclass
-      return ret if ret
+      return ret if ret != false
 
       ## keyword or identifer
       if is_identchar(c)
@@ -273,6 +274,13 @@ module Kwartz
         return @token = :'}'
       end
 
+      ## ','
+      if c == ?,
+        @value = ","
+        getch()
+        return @token = :','
+      end
+
       ##
       @value = c.chr
       @error = :invalid_char
@@ -349,8 +357,8 @@ module Kwartz
           assert("@error=#{@error}")
         end
       end
-      @value.sub!(/\A\s*\n/, '')
-      @value.sub!(/^\s+\z/, '')
+      @value.sub!(/\A[ \t]*\n/, '')
+      @value.sub!(/^[ \t]+\z/, '')
       return @value
     end
 
@@ -422,7 +430,7 @@ module Kwartz
         scan_line
         return scan()
       end
-      return nil
+      return false
     end
 
 
@@ -611,11 +619,10 @@ module Kwartz
         scan_ident()
         name = @value
         if name == 'DOCUMENT'
-          ruleset = parse_document_ruleset()
+          rulesets << parse_document_ruleset()
         else
-          ruleset = parse_element_ruleset()
+          rulesets += parse_element_ruleset()
         end
-        rulesets << ruleset
       end
       unless @token == nil
         raise parse_error("'#{@value}': '#name' is expected.")
@@ -627,6 +634,7 @@ module Kwartz
     protected
 
 
+    ## return false when not hooked
     def scan_hook
       ## comment
       c = @ch
@@ -675,7 +683,7 @@ module Kwartz
         return @token = ?@
       end
 
-      return nil
+      return false
 
     end #def
 
@@ -701,8 +709,8 @@ module Kwartz
         when :global   ;  has_colon?();  ruleset.set_global   _parse_words()
         when :local    ;  has_colon?();  ruleset.set_local    _parse_words()
         when :fixture  ;  has_colon?();  ruleset.set_fixture  _parse_block()
-        when :begin    ;  has_colon?();  ruleset.set_begin   _parse_block()
-        when :end      ;  has_colon?();  ruleset.set_end    _parse_block()
+        when :begin    ;  has_colon?();  ruleset.set_begin    _parse_block()
+        when :end      ;  has_colon?();  ruleset.set_end      _parse_block()
         #when :before   ;  has_colon?();  ruleset.set_before   _parse_block()
         #when :after    ;  has_colon?();  ruleset.set_after    _parse_block()
         else
@@ -731,10 +739,22 @@ module Kwartz
       assert unless @token == :ident
       start_linenum = @linenum
       name = @value
+      #names = [name]
+      names = []
       scan()
+      while @token == :','
+        scan()
+        unless @token == ?#
+          raise parse_error("'#{@value}': '#name' is expected.")
+        end
+        scan_ident()
+        names << @value
+        scan()
+      end
       unless @token == :'{'
         raise parse_error("'#{@value}': '{' is expected.")
       end
+
       ruleset = ElementRuleset.new(name)
       while true
         scan()
@@ -750,18 +770,22 @@ module Kwartz
         when :attrs  ;  has_colon?();  ruleset.set_attrs  _parse_pairs(), flag_escape
         when :append ;  has_colon?();  ruleset.set_append _parse_exprs(), flag_escape
         when :remove ;  has_colon?();  ruleset.set_remove _parse_strs()
-        when :tagname;  has_colon?();  ruleset.set_tagname  _parse_str()
+        when :tagname;  has_colon?();  ruleset.set_tagname _parse_str()
         when :logic  ;  has_colon?();  ruleset.set_logic  _parse_block()
         else
           raise parse_error("'#{@value}': unexpected token.")
         end
       end
+      ## build rulesets
+      rulesets = [ruleset]
+      names.each do |name| rulesets << ruleset.duplicate(name) end
+
       unless @token
         raise parse_error("'##{name}': is not closed by '}'.", start_linenum)
       end
       assert "@token=#{@token.inspect}" unless @token == :'}'
       scan()
-      return ruleset
+      return rulesets
     end
 
 
@@ -771,6 +795,10 @@ module Kwartz
       t = scan_string()
       t == :string  or raise parse_error("@import: requires filename.")
       filename = @value
+      if @filename && !@filename.empty?
+        dir = File.dirname(@filename)
+        filename = dir + '/' + filename if dir != '.'
+      end
       test(?f, filename)  or raise parse_error("'#{filename}': import file not found.")
       c = @ch
       c = getch() while is_whitespace(c)