kwartz 3.1.2 → 3.2.0

data/lib/kwartz/defun.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 136 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 

data/lib/kwartz/error.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 112 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 

data/lib/kwartz/helper/rails.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 148 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 

data/lib/kwartz/main.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 141 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -9,6 +9,7 @@ require 'kwartz'
 require 'kwartz/binding/eruby'
 require 'kwartz/binding/ruby'
 require 'kwartz/binding/php'
+require 'kwartz/binding/perl'
 require 'kwartz/binding/eperl'
 require 'kwartz/binding/rails'
 require 'kwartz/binding/jstl'
@@ -66,7 +67,7 @@ module Kwartz
     end
 
     def _find_entry(key)
-      if key.is_a?(Fixnum)
+      if key.is_a?(Fixnum) || (key.is_a?(String) && key.length == 1)
         return @_option_table.find { |row| row[0] == key }
       else
         key = key.to_s.intern unless key.is_a?(Symbol)
@@ -76,7 +77,7 @@ module Kwartz
     private :_find_entry
 
     def [](key)
-      if key.is_a?(Fixnum)
+      if key.is_a?(Fixnum) || (key.is_a?(String) && key.length == 1)
         entry = _find_entry(key)  or return
         key = entry[1]
       end

data/lib/kwartz/node.rb

@@ -1,6 +1,6 @@
 ####
-#### $Rev: 122 $
-#### $Release: 3.1.2 $
+#### $Rev$
+#### $Release: 3.2.0 $
 #### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ####
 
@@ -144,7 +144,7 @@ module Kwartz
   class ExpandStatement < Statement
 
 
-    def initialize(kind, name)
+    def initialize(kind, name=nil)
       @kind = kind    # symbol
       @name = name    # string
     end
@@ -200,67 +200,62 @@ module Kwartz
 
 
   ##
-  ## .[abstract] ruleset entry in presentation logic file
+  ## ruleset in presentation logic file
   ##
   class Ruleset
-  end
-
-
-
-  ##
-  ## represents '#name { ... }' entry in presentation logic file
-  ##
-  class ElementRuleset < Ruleset
 
 
-    def initialize(name)
-      @name = name
+    def initialize(selectors)
+      @selectors = selectors      # list of string ('#id', '.class', or 'tagname')
     end
+    attr_accessor :selectors
+    attr_accessor :stag, :cont, :etag, :elem   # NativeExpression
+    attr_accessor :attrs     # Hash(key: attribute name, value: NativeExpression)
+    attr_accessor :append    # list of NativeExpression
+    attr_accessor :remove    # list of attribute name
+    attr_accessor :tagname   # string
+    attr_accessor :logic, :before, :after   # block statement
 
 
-    attr_accessor :name, :stag, :cont, :etag, :elem
-    attr_accessor :value, :attrs, :append, :remove, :tagname, :logic
-
-
-    def set_stag(str, escape_flag=nil)
-      @stag = NativeExpression.new(str, escape_flag)
+    def set_stag(str, flag_escape=nil)
+      @stag = NativeExpression.new(str, flag_escape)
     end
 
 
-    def set_cont(str, escape_flag=nil)
-      @cont = NativeExpression.new(str, escape_flag)
+    def set_cont(str, flag_escape=nil)
+      @cont = NativeExpression.new(str, flag_escape)
     end
 
 
-    def set_etag(str, escape_flag=nil)
-      @etag = NativeExpression.new(str, escape_flag)
+    def set_etag(str, flag_escape=nil)
+      @etag = NativeExpression.new(str, flag_escape)
     end
 
 
-    def set_elem(str, escape_flag=nil)
-      @elem = NativeExpression.new(str, escape_flag)
+    def set_elem(str, flag_escape=nil)
+      @elem = NativeExpression.new(str, flag_escape)
     end
 
 
-    def set_value(str, escape_flag=nil)
-      set_cont(str, escape_flag)
+    def set_value(str, flag_escape=nil)
+      set_cont(str, flag_escape)
     end
 
 
-    def set_attrs(hash, escape_flag=nil)
-      hash.each do |name, expr_str|
+    def set_attrs(hash, flag_escape=nil)
+      hash.each do |aname, expr_str|
         next if !expr_str || expr_str.empty?
         @attrs ||= {}
-        @attrs[name] = NativeExpression.new(expr_str, escape_flag)
+        @attrs[aname] = NativeExpression.new(expr_str, flag_escape)
       end if hash
     end
 
 
-    def set_append(list, escape_flag=nil)
+    def set_append(list, flag_escape=nil)
       list.each do |expr_str|
         next if !expr_str || expr_str.empty?
         @append ||= []
-        @append << NativeExpression.new(expr_str, escape_flag)
+        @append << NativeExpression.new(expr_str, flag_escape)
       end
     end
 
@@ -276,13 +271,31 @@ module Kwartz
 
 
     def set_logic(logic_str)
+      stmt_list = _parse_logic_str(logic_str)
+      @logic = stmt_list
+    end
+
+
+    def set_before(logic_str)
+      stmt_list = _parse_logic_str(logic_str)
+      @before = stmt_list
+    end
+
+
+    def set_after(logic_str)
+      stmt_list = _parse_logic_str(logic_str)
+      @after = stmt_list
+    end
+
+
+    def _parse_logic_str(logic_str)
       return unless logic_str
       stmt_list = []
       logic_str.each_line do |line|
         if line =~ /^\s*_(stag|cont|etag|elem)(?:\(\))?;?\s*(?:\#.*)?$/
           kind = $1
-          stmt_list << ExpandStatement.new(kind.intern, @name)
-        elsif line =~ /^\s*(_(element|content)([()'"\w\s]*));?\s*(?:\#.*)?$/
+          stmt_list << ExpandStatement.new(kind.intern)
+        elsif line =~ /^\s*(_(element|content)([-()'"\w\s]*));?\s*(?:\#.*)?$/
           str, kind, arg  = $1, $2, $3
           arg.strip!
           if arg =~ /\A\((.*)\)\z/ then arg = $1 end
@@ -290,44 +303,63 @@ module Kwartz
             raise parse_error("'#{str}': element name required.", nil)
           end
           case arg
-          when /\A"(.*)"\z/  ;  name = $1
-          when /\A'(.*)'\z/  ;  name = $1
-          when /\A(\w+)\z/   ;  name = $1
+          when /\A"(.*)"\z/   ;  name = $1
+          when /\A'(.*)'\z/   ;  name = $1
+          when /\A([-\w]+)\z/ ;  name = $1
           else
             raise parse_error("'#{str}': invalid pattern.", nil)
           end
-          unless name =~ /\A\w+\z/
+          unless name =~ /\A[-\w]+\z/
             raise parse_error("'#{name}': invalid #{kind} name.", nil)
           end
           stmt_list << ExpandStatement.new(kind.intern, name)
         #elsif line =~ /^\s*print(?:\s+(\S+)|\((.+)\))\s*;?\s*(?:\#.*)?$/
-        elsif line =~ /^\s*print(?:\s+(.*?)|\((.+)\))\s*;?\s*$/
+        elsif line =~ /^\s*print(?:\s+(.*?)|\((.*)\))\s*;?\s*$/
           arg = $1 || $2
           stmt_list << PrintStatement.new([NativeExpression.new(arg)])
         else
           stmt_list << NativeStatement.new(line.chomp, nil)
         end
       end
-      @logic = stmt_list
+      return stmt_list
     end
 
 
-    def duplicate(name)
+    def duplicate()
       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
+      r = ruleset
+      r.selectors = nil
+      r.attrs  = @attrs.dup()  if @attrs
+      r.append = @append.dup() if @append
+      r.remove = @remove.dup() if @remove
+      r.logic  = @logic.dup()  if @logic
+      r.before = @before.dup() if @before
+      r.after  = @after.dup()  if @after
+      return r
+    end
+
+
+    def merge(ruleset)
+      r = ruleset
+      r2 = duplicate()
+      r2.stag  = r.stag  if r.stag
+      r2.etag  = r.etag  if r.etag
+      r2.cont  = r.cont  if r.cont
+      (r2.attrs ||= {}).update(r.attrs) if r.attrs
+      r2.append += r.append if r.append
+      r2.remove += r.remove if r.remove
+      r2.tagname = r.tagname if r.tagname
+      r2.logic  = r.logic  if r.logic
+      r2.before = r.before if r.before
+      r2.after  = r.after  if r.after
+      return r2
     end
 
 
     def _inspect(indent=0)
       space = '  ' * indent
       sb = []
-      sb << space <<   "- name: #{@name}\n"
-      #sb << space <<   "  value: #{@value == nil ? '' : @value}\n"
+      sb << space <<   "- selectors: #{@selectors.inspect}\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?
@@ -357,6 +389,16 @@ module Kwartz
         sb << space << "    - " << stmt._inspect()
       end if @logic
       #
+      sb << space <<   "  before:\n" if @before
+      @before.each do |stmt|
+        sb << space << "    - " << stmt._inspect()
+      end if @before
+      #
+      sb << space <<   "  after:\n" if @after
+      @after.each do |stmt|
+        sb << space << "    - " << stmt._inspect()
+      end if @after
+      #
       return sb.join
     end
 
@@ -372,98 +414,4 @@ module Kwartz
   end #class
 
 
-
-  ##
-  ## represents '#DOUMENT { ... }' entry in presentation logic file
-  ##
-  class DocumentRuleset < Ruleset
-
-
-    def initialize(name='DOCUMENT')
-      @name = name
-    end
-    attr_accessor :name, :global, :local, :fixture, :begin, :end  #:before, :after
-
-    def set_global(list)
-      @global = list if list
-    end
-
-    def set_local(list)
-      @local = list if list
-    end
-
-    def set_fixture(str)
-      @fixture = NativeStatement.new(str.chomp, nil) if str
-    end
-
-    def set_begin(str)
-      stmt_list = _parse_stmts(str)
-      @begin = stmt_list
-    end
-
-    def set_end(str)
-      stmt_list = _parse_stmts(str)
-      @end = stmt_list
-    end
-
-
-    private
-
-
-    def _parse_stmts(str)
-      return unless str
-      stmt_list = []
-      str.each_line do |line|
-        #if line =~ /^\s*print(?:\s+(.*?)|\((.+)\))\s*;?\s*(?:\#.*)?$/
-        if line =~ /^\s*print(?:\s+(.*?)|\((.+)\))\s*;?\s*$/
-          arg = $1 || $2
-          stmt_list << PrintStatement.new([NativeExpression.new(arg)])
-        else
-          stmt_list << NativeStatement.new(line.chomp, nil)
-        end
-      end
-      return stmt_list
-    end
-
-
-    public
-
-
-    def _inspect(indent=0)
-      space = '  ' * indent
-      sb = []
-      sb << space <<   "- name: #{@name}\n"
-      if @global
-        sb << space <<   "  global:\n"
-        @global.each do |item|
-          sb << space << "    - #{item}\n"
-        end
-      end
-      if @local
-        sb << space <<   "  local:\n"
-        @local.each do |item|
-          sb << space << "    - #{item}\n"
-        end
-      end
-      if @begin
-        sb << space << "  begin:\n"
-        @begin.each do |stmt|
-          sb << space << "    - #{stmt._inspect}"
-        end
-      end
-      if @end
-        sb << space << "  end:\n"
-        @end.each do |stmt|
-          sb << space << "    - #{stmt._inspect}"
-        end
-      end
-      #
-      return sb.join
-    end
-
-
-  end #class
-
-
-
 end #module

data/lib/kwartz/parser.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 124 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -95,7 +95,7 @@ module Kwartz
       table[word.capitalize] = sym
       table[word.upcase]     = sym
     end
-    %w[element remove tagname logic document global local fixture before after].each do |word|
+    %w[remove tagname logic before after begin end global local].each do |word|
       table[word] = word.intern
     end
     PLOGIC_KEYWORDS = table
@@ -218,6 +218,7 @@ module Kwartz
       #not_implemented
     end
 
+
     ## .[abstract] detect parser-specific keywords
     ##
     ## return symbol if keyword is token, else return nil
@@ -225,6 +226,7 @@ module Kwartz
       not_implemented
     end
 
+
     ## scan token
     def scan
       ## skip whitespaces
@@ -437,7 +439,7 @@ module Kwartz
     def keywords(keyword)
       return RUBYSTYLE_KEYWORDS[keyword]
     end
-    RUBYSTYLE_KEYWORDS = { 'BEGIN' => :BEGIN, 'END' => :END }
+    RUBYSTYLE_KEYWORDS = { 'BEGIN'=>:BEGIN, 'END'=>:END, 'element'=>:element, 'document'=>:document }
 
 
     def parse_document_ruleset
@@ -446,7 +448,7 @@ module Kwartz
       unless @token == :'{'
         raise parse_error("'#{@value}': document requires '{'.")
       end
-      ruleset = DocumentRuleset.new
+      ruleset = Ruleset.new
       while @token
         scan()
         case @token
@@ -583,8 +585,8 @@ module Kwartz
   ##
   ## example of presentation logic in css style:
   ##
-  ##   // comment
-  ##   #list {
+  ##   /* comment */
+  ##   #idname, .classname, tagname {
   ##     value:   @var;
   ##     attrs:   "class" @classname, "bgcolro" color;
   ##     append:  @value==item['list'] ? ' checked' : '';
@@ -600,32 +602,50 @@ module Kwartz
   class CssStyleParser < PresentationLogicParser
 
 
+    def initialize(*args)
+      super
+      @mode = :selector           # :selector or :declaration
+    end
+
+    attr_accessor :mode
+
+
     def parse(input, filename='')
       reset(input, filename)
       scan()
       rulesets = []
-      while @token == ?@
-        c = getch();
-        scan_ident()
-        name = @value
-        if name == 'import'
+      while @token == :command     # '@import'
+        command = @value
+        case command
+        when '@import'
           imported_rulesets = parse_import_command()
           rulesets += imported_rulesets
+        when '@from'
+          # TODO
+        when '@import_pdata'
+          # TODO
         else
-          raise parse_error("@#{name}: unsupported command.")
+          raise parse_error("#{command}: unsupported command.")
         end
       end
-      while @token == ?#
-        scan_ident()
-        name = @value
-        if name == 'DOCUMENT'
-          rulesets << parse_document_ruleset()
-        else
-          rulesets += parse_element_ruleset()
+      while @token == :selector
+        selectors = parse_selectors()
+        unless @token == :'{'
+          raise parse_error("'#{@value}': '{' is expected.")  #'
+        end
+        @mode = :declaration
+        _linenum, _column = @linenum, @column
+        ruleset = Ruleset.new(selectors)
+        parse_declaration(ruleset)
+        unless @token
+          raise parse_error("'#{selectors.first}': is not closed by '}'.", _linenum, _column)
         end
+        @mode = :selector
+        rulesets << ruleset
+        scan()
       end
       unless @token == nil
-        raise parse_error("'#{@value}': '#name' is expected.")
+        raise parse_error("'#{@value}': selector is expected.")
       end
       return rulesets
     end
@@ -665,22 +685,46 @@ module Kwartz
         end #if
       end #if
 
-      ## '#mark'
-      if c == ?#
-        c = getch()
-        unless is_alpha(c)
-          @error = :invalid_char
-          @value = '#'
-          return @token = :error
+      ##
+      if @mode == :selector
+        # '#name' or '.name'
+        if c == ?# || c == ?.
+          start_char = c
+          name = ''
+          while is_identchar(c = getch()) || c == ?-
+            name << c
+          end
+          if name.empty?
+            @error = :invalid_char
+            @value = start_char.chr
+            return @token = :error
+          end
+          @value = start_char.chr + name
+          return @token = :selector
+        end
+        # 'tagname'
+        if is_identchar(c) || c == ?-
+          name = c.chr
+          while is_identchar(c = getch()) || c == ?- || c == ?:
+            name << c
+          end
+          @value = name
+          return @token = :selector
+        end
+        # '@import'
+        if c == ?@
+          name = ''
+          while is_identchar(c = getch())
+            name << c
+          end
+          if name.empty?
+            @error = :invalid_char
+            @value = '@'
+            return @token = :error
+          end
+          @value = '@' + name
+          return @token = :command
         end
-        @value = '#'
-        return @token = ?#
-      end #if
-
-      ## '@import "foo.plogic"'
-      if c == ?@
-        @value = '@'
-        return @token = ?@
       end
 
       return false
@@ -694,39 +738,6 @@ module Kwartz
     CSSSTYLE_KEYWORDS = { 'begin'=>:begin, 'end'=>:end }
 
 
-    def parse_document_ruleset
-      assert unless @value == 'DOCUMENT'
-      start_linenum = @linenum
-      scan()
-      unless @token == :'{'
-        raise parse_error("'#{@value}': '{' is expected.")
-      end
-      ruleset = DocumentRuleset.new
-      while @token
-        scan()
-        case @token
-        when :'}'      ;  break
-        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 :before   ;  has_colon?();  ruleset.set_before   _parse_block()
-        #when :after    ;  has_colon?();  ruleset.set_after    _parse_block()
-        else
-          unless @token
-            raise parse_error("'#DOCUMENT': is not closed by '}'.", start_linenum)
-          else
-            raise parse_error("'#{@value}': unexpected token.")
-          end
-        end
-      end
-      assert unless @token == :'}'
-      scan()
-      return ruleset
-    end
-
-
     def has_colon?
       unless @ch == ?:
         raise parse_error("'#{@value}': ':' is required.")
@@ -735,57 +746,50 @@ module Kwartz
     end
 
 
-    def parse_element_ruleset
-      assert unless @token == :ident
+    def parse_selectors
+      assert unless @token == :selector
       start_linenum = @linenum
-      name = @value
-      #names = [name]
-      names = []
+      selectors = [ @value ]
       scan()
       while @token == :','
         scan()
-        unless @token == ?#
-          raise parse_error("'#{@value}': '#name' is expected.")
+        unless @token == :selector
+          raise parse_error("'#{@value}': selector is expected (or additional comma exists).") #'
         end
-        scan_ident()
-        names << @value
+        selectors << @value
         scan()
       end
-      unless @token == :'{'
-        raise parse_error("'#{@value}': '{' is expected.")
-      end
+      return selectors
+    end
 
-      ruleset = ElementRuleset.new(name)
+
+    def parse_declaration(ruleset)
+      assert unless @token == :'{'
       while true
         scan()
         flag_escape = escape?(@value)
         case @token
         when nil     ;  break
         when :'}'    ;  break
-        when :stag   ;  has_colon?();  ruleset.set_stag   _parse_expr() , flag_escape
-        when :cont   ;  has_colon?();  ruleset.set_cont   _parse_expr() , flag_escape
-        when :etag   ;  has_colon?();  ruleset.set_etag   _parse_expr() , flag_escape
-        when :elem   ;  has_colon?();  ruleset.set_elem   _parse_expr() , flag_escape
-        when :value  ;  has_colon?();  ruleset.set_value  _parse_expr() , flag_escape
-        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 :stag   ;  has_colon?();  ruleset.set_stag    _parse_expr() , flag_escape
+        when :cont   ;  has_colon?();  ruleset.set_cont    _parse_expr() , flag_escape
+        when :etag   ;  has_colon?();  ruleset.set_etag    _parse_expr() , flag_escape
+        when :elem   ;  has_colon?();  ruleset.set_elem    _parse_expr() , flag_escape
+        when :value  ;  has_colon?();  ruleset.set_value   _parse_expr() , flag_escape
+        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 :logic  ;  has_colon?();  ruleset.set_logic  _parse_block()
+        when :logic  ;  has_colon?();  ruleset.set_logic   _parse_block()
+        when :before ;  has_colon?();  ruleset.set_before  _parse_block()
+        when :after  ;  has_colon?();  ruleset.set_after   _parse_block()
+        when :begin  ;  has_colon?();  ruleset.set_before  _parse_block()
+        when :end    ;  has_colon?();  ruleset.set_after   _parse_block()
         else
-          raise parse_error("'#{@value}': unexpected token.")
+          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 rulesets
+      return ruleset
     end
 
 
@@ -800,13 +804,18 @@ module Kwartz
         filename = dir + '/' + filename if dir != '.'
       end
       test(?f, filename)  or raise parse_error("'#{filename}': import file not found.")
+      _linenum, _column = @linenum, @column
       c = @ch
       c = getch() while is_whitespace(c)
       c == ?; or raise parse_error("';' required.")
       c = getch()
       scan()
       parser = self.class.new(@properties)
-      ruleset_list = parser.parse(File.read(filename), filename)
+      begin
+        ruleset_list = parser.parse(File.read(filename), filename)
+      rescue => ex
+        parse_error(ex.message, _linenum, _column)
+      end
       return ruleset_list
     end