zena 0.15.0

data/lib/zena/parser/zafu_rules.rb

@@ -0,0 +1,232 @@
+module Zena
+  module Parser
+
+    module ZafuRules
+      attr_reader :context
+      # This callback is run just after the block is initialized (Parser#initialize).
+      def start(mode)
+        # html_tag
+        @html_tag = @options.delete(:html_tag)
+        @html_tag_params = parse_params(@options.delete(:html_tag_params))
+
+        # end_tag
+        @end_tag = @html_tag || @options.delete(:end_do) || @options.delete(:end_tag) || "r:#{@method}"
+        @end_tag_count  = 1
+
+        # code indentation
+        @space_before = @options[:space_before]
+        @options.delete(:space_before)
+
+        # form capture (input, select, textarea, form)
+        @options[:form] ||= true if @method == 'form'
+
+        # puts "[#{@space_before}(#{@method})#{@space_after}]"
+        if @params =~ /\A([^>]*?)do\s*=('|")([^\2]*?[^\\])\2([^>]*)\Z/
+          # we have a sub 'do'
+          @params = parse_params($1)
+          @sub_do = $3 # this is used by replace_with
+
+          opts = {:method=>$3, :params=>$4}
+
+          # the matching zafu tag will be parsed by the last 'do', we must inform it to halt properly :
+          opts[:end_do] = @end_tag
+
+          sub = make(:void, opts)
+          @space_after = sub.instance_variable_get(:@space_after)
+          sub.instance_variable_set(:@space_after,"")
+        else
+          @params = parse_params(@params)
+        end
+
+        # set name used for include/replace from html_tag if not allready set by superclass
+        @name = @options[:name] || @params[:name] || @params[:id] || @html_tag_params[:id]
+
+        if !@html_tag && (@html_tag = @params.delete(:tag))
+          # get html tag parameters from @params
+          @html_tag_params = {}
+          [:class, :id].each do |k|
+            next unless @params[k]
+            @html_tag_params[k] = @params.delete(k)
+          end
+        end
+
+        if @method == 'include'
+          include_template
+        elsif mode == :tag && !sub
+          scan_tag
+        elsif !sub
+          enter(mode)
+        end
+      end
+
+      def before_parse(text)
+        text.gsub('<%', '&lt;%').gsub('%>', '%&gt;')
+      end
+
+      # scan rules
+      def scan
+        # puts "SCAN(#{@method}): [#{@text}]"
+        if @text =~ /\A([^<]*?)(^ *|)</m
+          flush $1
+          eat $2
+          if @text[1..1] == '/'
+            store $2
+            scan_close_tag
+          elsif @text[0..3] == '<!--'
+            scan_html_comment(:space_before=> $2)
+          elsif @text[0..8] == '<![CDATA['
+            flush '<![CDATA['
+          else
+            scan_tag(:space_before=> $2)
+          end
+        else
+          # no more tags
+          flush
+        end
+      end
+
+      def scan_close_tag
+        if @text =~ /\A<\/([^>]+)>( *\n+|)/m
+          # puts "CLOSE:[#{$&}]}" # ztag
+          # closing tag
+          if $1 == @end_tag
+            @end_tag_count -= 1
+            if @end_tag_count == 0
+              if @end_tag == 'script'
+                flush $& # keep closing tag
+              else
+                eat $&
+              end
+              @space_after = $2
+              leave
+            else
+              # keep the tag (false alert)
+              flush $&
+            end
+          elsif $1[0..1] == 'r:'
+            # /rtag
+            eat $&
+            if $1 != @end_tag
+              # error bad closing rtag
+              store "<span class='parser_error'>#{$&.gsub('<', '&lt;').gsub('>','&gt;')} should be &lt;/#{@end_tag}&gt;</span>"
+            end
+            leave
+          else
+            # other html tag closing
+            flush $&
+          end
+        else
+          # error
+          flush
+        end
+      end
+
+      def scan_html_comment(opts={})
+        if @text =~ /\A<!--\|(.*?)-->/m
+          # zafu html escaped
+          eat $&
+          @text = opts[:space_before] + $1 + @text
+        elsif @text =~ /\A<!--.*?-->/m
+          # html comment
+          flush $&
+        else
+          # error
+          flush
+        end
+      end
+
+      def scan_tag(opts={})
+        # puts "TAG(#{@method}): [#{@text}]"
+        if @text =~ /\A<r:([\w_]+)([^>]*?)(\/?)>/
+          # puts "RTAG:#{$~.to_a.inspect}" # ztag
+          eat $&
+          opts.merge!(:method=>$1, :params=>$2)
+          opts.merge!(:text=>'') if $3 != ''
+          make(:void, opts)
+        elsif @text =~ /\A<(\w+)([^>]*?)do\s*=('([^>]*?[^\\]|)'|"([^>]*?[^\\]|)")([^>]*?)(\/?)>/
+          #puts "DO:#{$~.to_a.inspect}" # do tag
+          eat $&
+          opts.merge!(:method=>($4||$5), :html_tag=>$1, :html_tag_params=>$2, :params=>$6)
+          opts.merge!(:text=>'') if $7 != ''
+          make(:void, opts)
+        elsif @options[:form] && @text =~ /\A<(input|select|textarea|form)([^>]*?)(\/?)>/
+          eat $&
+          method = $1 == 'form' ? 'form_tag' : $1 # <form> ==> r_form_tag, <r:form> ==> r_form
+          opts.merge!(:method=>method, :params=>$2)
+          opts.merge!(:text=>'') if $3 != ''
+          opts.merge!(:end_tag=>'form') if method == 'form_tag'
+          make(:void, opts)
+        elsif @text =~ /\A<(\w+)([^>]*?)id\s*=('[^>]*?[^\\]'|"[^>]*?[^\\]")([^>]*?)(\/?)>/
+          #puts "ID:#{$~.to_a.inspect}" # id tag
+          eat $&
+          opts.merge!(:method=>'void', :html_tag=>$1, :params=>{:id => $3[1..-2]}, :html_tag_params=>"#{$2}id=#{$3}#{$4}")
+          opts.merge!(:text=>'') if $5 != ''
+          make(:void, opts)
+        elsif @end_tag && @text =~ /\A<#{@end_tag}([^>]*?)(\/?)>/
+          #puts "SAME:#{$~.to_a.inspect}" # simple html tag same as end_tag
+          flush $&
+          @end_tag_count += 1 unless $2 == '/'
+        elsif @text =~ /\A<(link|img|script)/
+          #puts "HTML:[#{$&}]" # html
+          make(:asset)
+        elsif @text =~ /\A<style>/
+          flush $&
+          make(:style)
+        elsif @text =~ /\A[^>]*?>/
+          # html tag
+          #puts "OTHER:[#{$&}]"
+          store opts[:space_before]
+          flush $&
+        else
+          # never closed tag
+          flush
+        end
+      end
+
+      def scan_asset
+        # puts "ASSET(#{object_id}) [#{@text}]"
+        if @text =~ /\A<(\w*)([^>]*?)(\/?)>/
+          eat $&
+          @method = 'rename_asset'
+          @html_tag = @end_tag = $1
+          closed = ($3 != '')
+          @params = parse_params($2)
+          if closed
+            leave(:asset)
+          elsif @html_tag == 'script'
+            enter(:void)
+          else
+            enter(:inside_asset)
+          end
+        else
+          # error
+          @method = 'void'
+          flush
+        end
+      end
+
+      def scan_inside_asset
+        if @text =~ /\A(.*?)<\/#{@end_tag}>/m
+          flush $&
+          leave(:asset)
+        else
+          # never ending asset
+          flush
+        end
+      end
+
+      def scan_style
+        if @text =~ /\A(.*?)<\/style>/m
+          flush $&
+          @method = 'rename_asset'
+          @html_tag = 'style'
+          leave(:style)
+        else
+          # error
+          @method = 'void'
+          flush
+        end
+      end
+    end # ZafuRules
+  end # Parser
+end # Zena

data/lib/zena/parser/zafu_tags.rb

@@ -0,0 +1,197 @@
+module Zena
+  module Parser
+    module ZafuTags
+      attr_accessor :html_tag, :html_tag_params, :name, :sub_do
+
+      # Replace the 'original' element in the included template with our new version.
+      def replace_with(new_obj)
+        super
+        html_tag_params    = new_obj.html_tag_params
+        [:class, :id].each do |sym|
+          html_tag_params[sym] = new_obj.params[sym] if new_obj.params.include?(sym)
+        end
+        @html_tag = new_obj.html_tag || @html_tag
+        @html_tag_params.merge!(html_tag_params)
+        if new_obj.params[:method]
+          @method   = new_obj.params[:method] if new_obj.params[:method]
+        elsif new_obj.sub_do
+          @method = 'void'
+        end
+      end
+
+      # Pass the caller's 'html_tag' and 'html_tag_params' to the included part.
+      def include_part(obj)
+        obj.html_tag = @html_tag || obj.html_tag
+        obj.html_tag_params = !@html_tag_params.empty? ? @html_tag_params : obj.html_tag_params
+        @html_tag = nil
+        @html_tag_params = {}
+        super(obj)
+      end
+
+      def empty?
+        super && @html_tag_params == {} && @html_tag.nil?
+      end
+
+      def before_render
+        return unless super
+        @html_tag_done = false
+        unless @html_tag
+          if @html_tag = @params.delete(:tag)
+            @html_tag_params = {}
+            [:id, :class].each do |k|
+              next unless @params[k]
+              @html_tag_params[k] = @params.delete(k)
+            end
+          end
+        end
+        # [each] is run many times with different roles. Some of these change html_tag_params.
+        @html_tag_params_bak = @html_tag_params.dup
+        true
+      end
+
+      def after_render(text)
+        res = render_html_tag(super)
+        @html_tag_params = @html_tag_params_bak
+        res
+      end
+
+      def inspect
+        @html_tag_done = false
+        res = super
+        if @html_tag
+          if res =~ /\A\[(\w+)(.*)\/\]\Z/m
+            res = "[#{$1}#{$2}]<#{@html_tag}/>[/#{$1}]"
+          elsif res =~ /\A\[([^\]]+)\](.*)\[\/(\w+)\]\Z/m
+            res = "[#{$1}]#{render_html_tag($2)}[/#{$3}]"
+          end
+        end
+        res
+      end
+
+      def params_to_html(params)
+        para = []
+        params.each do |k,v|
+          if v.kind_of?(Array)
+            # Array is used to indicate that the code is already escaped.
+            para << " #{k}=#{v}"
+          elsif !v.to_s.include?("'")
+            para << " #{k}='#{v}'"
+          else
+            para << " #{k}=\"#{v.to_s.gsub('"','\"')}\"" # TODO: do this work in all cases ?
+          end
+        end
+        # puts para.inspect
+        para.sort.join('')
+      end
+
+      def render_html_tag(text,*append)
+        append ||= []
+        return text if @html_tag_done
+        if @html_tag
+          if text.blank? && ['meta','input'].include?(@html_tag)
+            res = "<#{@html_tag}#{params_to_html(@html_tag_params || {})}#{append.join('')}/>"
+          else
+            res = "<#{@html_tag}#{params_to_html(@html_tag_params || {})}#{append.join('')}>#{text}</#{@html_tag}>"
+          end
+        else
+          res = text
+        end
+        @html_tag_done = true
+        return res if @context && @context[:only] && !@context[:only].include?(:string)
+        (@space_before || '') + res + (@space_after || '')
+      end
+
+      def r_ignore
+        @html_tag_done = true
+        ''
+      end
+
+      alias r_ r_ignore
+
+      def r_rename_asset
+        return expand_with unless @html_tag
+        case @html_tag
+        when 'link'
+          key = :href
+          if @params[:rel].downcase == 'stylesheet'
+            type = :stylesheet
+          else
+            type = :link
+          end
+        when 'style'
+          @html_tag_done = true
+          return expand_with.gsub(/url\(('|")(.*?)\1\)/) do
+            if $2[0..6] == 'http://'
+              $&
+            else
+              quote   = $1
+              new_src = @options[:helper].send(:template_url_for_asset, :current_folder=>@options[:current_folder], :src => $2)
+              "url(#{quote}#{new_src}#{quote})"
+            end
+          end
+        else
+          key = :src
+          type = @html_tag.to_sym
+        end
+
+        src = @params[key]
+        if src && src[0..0] != '/' && src[0..6] != 'http://'
+          @params[key] = @options[:helper].send(:template_url_for_asset, :src => src, :current_folder => @options[:current_folder], :type => type)
+        end
+
+        res   = "<#{@html_tag}#{params_to_html(@params)}"
+        @html_tag_done = true
+        inner = expand_with
+        if inner == ''
+          res + "/>"
+        else
+          res + ">#{inner}"
+        end
+      end
+
+      def r_form
+        res   = "<#{@html_tag}#{params_to_html(@params)}"
+        @html_tag_done = true
+        inner = expand_with
+        if inner == ''
+          res + "/>"
+        else
+          res + ">#{inner}"
+        end
+      end
+
+      def r_select
+        res   = "<#{@html_tag}#{params_to_html(@params)}"
+        @html_tag_done = true
+        inner = expand_with
+        if inner == ''
+          res + "></#{@html_tag}>"
+        else
+          res + ">#{inner}"
+        end
+      end
+
+      def r_input
+        res   = "<#{@html_tag}#{params_to_html(@params)}"
+        @html_tag_done = true
+        inner = expand_with
+        if inner == ''
+          res + "/>"
+        else
+          res + ">#{inner}"
+        end
+      end
+
+      def r_textarea
+        res   = "<#{@html_tag}#{params_to_html(@params)}"
+        @html_tag_done = true
+        inner = expand_with
+        if inner == ''
+          res + "/>"
+        else
+          res + ">#{inner}"
+        end
+      end
+    end # ZafuTags
+  end # Parser
+end # Zena

data/lib/zena/parser/zazen_rules.rb

@@ -0,0 +1,427 @@
+# load
+Zena::CodeSyntax
+
+module Zena
+  module Parser
+    module ZazenRules
+      include Zena::Acts::Secure
+
+      PSEUDO_ID_REGEXP = ":[0-9a-zA-Z-]+\\+*|\\([^\\)]*\\)"
+
+      def start(mode)
+        @helper = @options[:helper]
+        # we do nothing, everything is done when 'render' is called
+      end
+
+      # rewrite store to optimize for our 'text only' parser
+      def store(str)
+        @blocks << str
+      end
+
+      def flush(str=@text)
+        @blocks << str
+        @text = @text[str.length..-1]
+      end
+
+      def scan
+        #puts "SCAN:[#{@text}]"
+        if @text =~ /\A([^\|!"<\n\[]*)/m
+          flush $&
+          if @text[0..0] == '!'
+            scan_exclam
+          elsif @text[0..0] == '"'
+            scan_quote
+          elsif @text[0..0] == '['
+            scan_bracket
+          elsif @text[0..0] == '|'
+            scan_pipe
+          elsif @text[0..4] == '<code'
+            # FIXME: implement <code..> and @@ instead of "extract"
+            flush
+            # implement !! scan_code
+          elsif @text[0..0] == '<'
+            flush '<'
+          elsif !@in_space_pre && @text[0..2] == "\n\n " && !@translate_ids
+            # space preserving paragraphe
+            @in_space_pre = true
+            store "\n\n<pre>"
+            eat 3
+          elsif @in_space_pre && @text[0..1] == "\n\n" && !@translate_ids
+            store "</pre>"
+            while @text[0..0] == "\n"
+              flush "\n"
+            end
+            @in_space_pre = false
+          elsif @text[0..1] == "\n\n"
+            while @text[0..0] == "\n"
+              flush "\n"
+            end
+          elsif @text[0..1] == "\n " && @in_space_pre && !@translate_ids
+            store "\n"
+            eat 2
+          elsif @text[0..1] == "\n|"
+            flush "\n|"
+          elsif @text[0..0] == "\n" && !@translate_ids
+            if @in_space_pre || @text == "\n" || @text[1..1] == '*' || @text[1..1] == '#'
+              flush "\n"
+            else
+              # forced line break
+              store "\n<br/>"
+              eat 1
+            end
+          elsif @text[0..0] == "\n"
+            flush "\n"
+          else
+            # error
+            flush
+          end
+        else
+          # nothing interesting
+          flush
+        end
+      end
+
+      def scan_exclam
+        #puts "EXCL:[#{@text}]"
+        if @text =~ /\A\!\[([^\]]*)\]\!/m
+          # create a gallery ![...]!
+          #puts "GALLERY:[#{$&}]"
+          eat $&
+          if @context[:images]
+            ids = parse_document_ids($1)
+            if @translate_ids
+              store "![#{ids.join(',')}]!"
+            else
+              store @helper.make_gallery(ids, :node=>@context[:node])
+            end
+          else
+            store @helper._('[gallery]')
+          end
+        elsif @text =~ /\A\!([^0-9]{0,2})\{([^\}]*)\}\!/m
+          # list of documents !<.{...}!
+          #puts "DOCS:[#{$&}]"
+          eat $&
+          style, ids = $1, $2
+          if @context[:images]
+            ids = parse_document_ids(ids)
+            if @translate_ids
+              store "!#{style}{#{ids.join(',')}}!"
+            else
+              store @helper.list_nodes(ids, :style=>style, :node=>@context[:node])
+            end
+          else
+            store @helper._('[documents]')
+          end
+        elsif @text =~ /\A\!([^0-9]{0,2})(#{PSEUDO_ID_REGEXP})(_([^\/\!]+)|)(\/([^\!]*)|)\!(:([^\s]+)|)/m
+          # image !<.:art++_pv/blah blah!:12
+          #puts "SHORCUT IMAGE:#{$~.to_a.inspect}"
+          eat $&
+          style, id, other_opts, mode, title_opts, title, link = $1, $2, $3, $4, $5, $6, $8
+          if node = find_node_by_pseudo(id)
+            if link && link =~ /^(#{PSEUDO_ID_REGEXP})(.*)$/
+              rest = $2
+              if link_node = find_node_by_pseudo($1)
+                link = link_node.pseudo_id(@context[:node], @translate_ids || :zip).to_s + rest
+              end
+            end
+
+            if @translate_ids
+              if node.kind_of?(Document)
+                # replace shortcut
+                store "!#{style}#{node.pseudo_id(@context[:node], @translate_ids || :zip)}#{other_opts}#{title_opts}!#{link ? ':' + link : ''}"
+              else
+                store $&
+              end
+            else
+              if node.kind_of?(Document)
+                store @helper.make_image(:style=>style, :id=>node[:zip].to_s, :node=>node, :mode=>mode, :title=>title, :link=>link, :images=>@context[:images])
+              else
+                store "[#{node.fullpath} is not a document]"
+              end
+            end
+          elsif @translate_ids
+            store $&
+          else
+            store "[#{id} not found]"
+          end
+        elsif @text =~ /\A\!([^0-9]{0,2})([0-9]+)(_([^\/\!]+)|)(\/([^\!]*)|)\!(:([^\s]+)|)/m
+          # image !<.12_pv/blah blah!:12
+          #puts "IMAGE:[#{$&}]"
+          eat $&
+          style, id, other_opts, mode, title_opts, title, link = $1, $2, $3, $4, $5, $6, $8
+          if link && link =~ /^(#{PSEUDO_ID_REGEXP})(.*)$/
+            rest = $2
+            if link_node = find_node_by_pseudo($1)
+              link = link_node[:zip].to_s + rest
+            end
+          end
+          if @translate_ids
+            if @translate_ids != :zip
+              node = find_node_by_pseudo(id)
+              id = node.pseudo_id(@context[:node], @translate_ids) if node
+            end
+            store "!#{style}#{id}#{other_opts}#{title_opts}!#{link ? ':' + link : ''}"
+          else
+            store @helper.make_image(:style=>style, :id=>id, :mode=>mode, :title=>title, :link=>link, :images=>@context[:images])
+          end
+        else
+          #puts "EAT:[#{$&}]"
+          # eat marker and continue scan
+          flush @text[0..0]
+        end
+      end
+
+      def scan_quote
+        if @text =~ /\A"([^"]*)":([0-9]+(_[a-z]+|)(\.[a-z]+|)(#[a-z_\/\[\]]*|))/m
+          #puts "LINK:[#{$&}]"
+          if @translate_ids == :zip
+            flush $&
+          elsif @translate_ids
+            eat $&
+            title, id = $1, $2
+            node = find_node_by_pseudo(id)
+            id = node.pseudo_id(@context[:node], @translate_ids) if node
+            store "\"#{title}\":#{id}"
+          else
+            eat $&
+            # link inside the cms "":34
+            title, id = $1, $2
+            if id =~ /(.*?)#(.*)/
+              id, sharp = $1, $2
+              sharp = 'true' if sharp == ''
+            end
+            store @helper.make_link(:title=>title,:id=>id,:sharp=>sharp)
+          end
+        elsif @text =~ /\A"([^"]*)":(#{PSEUDO_ID_REGEXP})((_[a-z]+|)(\.[a-z]+|)(#[a-z_\/\[\]]*|))/m
+          #puts "SHORTCUT_LINK:[#{$&}]"
+          eat $&
+          title, pseudo_id, mode_format, mode, format, dash = $1, $2, $3, $4, $5, $6
+          if node = find_node_by_pseudo(pseudo_id)
+            if @translate_ids
+              id = "#{node.pseudo_id(@context[:node], @translate_ids)}#{mode_format}"
+              # replace shortcut
+              store "\"#{title}\":#{id}"
+            else
+              id = "#{node.zip}#{mode_format}"
+              if format == '.data'
+                title = "#{node.fullpath}#{mode}.#{node.c_ext}#{dash}"
+              else
+                title = "#{node.fullpath}#{mode_format}"
+              end
+              if id =~ /(.*?)#(.*)/
+                id, sharp = $1, $2
+                sharp = 'true' if sharp == ''
+              end
+              store @helper.make_link(:title=>title,:id=>id,:sharp=>sharp,:node=>node)
+            end
+          elsif @translate_ids
+            store $&
+          else
+            pseudo_id = pseudo_id[1..-1] if pseudo_id[0..0] == ':'
+            store "[#{pseudo_id} not found]"
+          end
+        else
+          #puts "NOT A ZAZEN LINK"
+          flush @text[0..0]
+        end
+      end
+
+      def scan_bracket
+        # puts "BRACKET:[#{@text}]"
+        if @text =~ /\A\[(\w+)\](.*?)\[\/\1\]/m
+          if @translate_ids
+            flush $&
+          else
+            eat $&
+            # [math]....[/math] (we do not use <math> to avoid confusion with mathml)
+            store @helper.make_asset(:asset_tag => $1, :content => $2, :node => @context[:node], :preview => @context[:preview], :output => @context[:output])
+          end
+        else
+          # nothing interesting
+          flush '['
+        end
+      end
+
+      def scan_wiki
+        #puts "WIKI:[#{@text}]"
+        if @text =~ /\A([^\?])*/m
+          flush $&
+          scan_wiki_link
+        else
+          # nothing interesting
+          flush
+        end
+      end
+
+      def scan_wiki_link
+        if @text =~ /\A\?(\w[^\?]*?\w)\?([^\w:]|:([^\s<]+))/m
+          #puts "WIKI:[#{$&}]"
+          eat $&
+          title = $1
+          url   = $3
+          # wiki reference ?zafu? or ?zafu?:http://...
+          if url
+            if url =~ /[^\w0-9]$/
+              # keep trailing punctuation
+              store @helper.make_wiki_link(:title=>title, :url=>url[0..-2], :node=>@context[:node]) + $&
+            else
+              store @helper.make_wiki_link(:title=>title, :url=>url, :node=>@context[:node])
+            end
+          else
+            store @helper.make_wiki_link(:title=>title, :node=>@context[:node]) + $2
+          end
+        else
+          # false alert
+          flush @text[0..0]
+        end
+      end
+
+      def scan_pipe
+        #puts "PIPE:[#{@text}]"
+        if @text =~ /\A\|([<=>]\.|)([0-9]+\.|)([a-zA-Z_]+)(\/([^\|]*)|)\|/m
+          # table |<.34.shopping_list/blah blah|
+          # table |shopping_list|
+          #puts "TABLE:#{$~.to_a.inspect}"
+          eat $&
+          style, id, attribute, title_opts, title = $1, $2, $3, $4, $5
+          id = id[0..-2] if id != ''
+          if @translate_ids
+            if @translate_ids != :zip
+              node = find_node_by_pseudo(id)
+              id = node.pseudo_id(@context[:node], @translate_ids) if node
+            end
+            store "|#{style}#{id == '' ? '' : "#{id}."}#{attribute}#{title}|"
+          else
+            node = id == '' ? @context[:node] : find_node_by_pseudo(id)
+            store @helper.make_table(:style=>style, :node=>node, :attribute=>attribute, :title=>title)
+          end
+        elsif @text =~ /\A\|([<=>]\.|)(#{PSEUDO_ID_REGEXP})\.([a-zA-Z_]+)(\/([^\|]*)|)\|/m
+          # table |<.:art++.shopping_list/blah blah|
+          # table |shopping_list|
+          #puts "TABLE SHORTCUT:#{$~.to_a.inspect}"
+          eat $&
+          text = $&
+          style, id, attribute, title_opts, title = $1, $2, $3, $4, $5
+          if node = find_node_by_pseudo(id)
+            if @translate_ids
+              # replace shortcut
+              store "|#{style}#{node.pseudo_id(@context[:node], @translate_ids || :zip)}.#{attribute}#{title}|"
+            else
+              # write table
+              store @helper.make_table(:style=>style, :node=>node, :attribute=>attribute, :title=>title)
+            end
+          elsif @translate_ids
+            # node not found, ignore
+            store text
+          else
+            # node not found
+            store "[#{id} not found]"
+          end
+        else
+          #puts "EAT:[#{$&}]"
+          # eat marker and continue scan
+          flush @text[0..0]
+        end
+      end
+
+      def extract_code(fulltext)
+        @escaped_code = []
+        block_counter = -1
+        fulltext.gsub!( /<code([^>]*)>(.*?)<\/code>/m ) do
+          if @translate_ids
+            @escaped_code << $&
+            block_counter += 1
+            "\\ZAZENBLOCKCODE#{block_counter}ZAZENBLOCKCODE\\"
+          else
+            params, text = $1, $2
+            divparams = []
+            if params =~ /\A(.*)lang\s*=\s*("|')([^"']+)\2(.*)\Z/m
+              pre, lang, post = $1.strip, $3, $4.strip
+              divparams << pre if pre && pre != ""
+              divparams << post if post && post != ""
+            else
+              divparams << params.strip if params != ''
+              lang = ''
+            end
+            #divparams << "class='code'" unless params =~ /class\s*=/
+            divparams.unshift('') if divparams != []
+            @escaped_code << [lang, text]
+            block_counter += 1
+            "<pre#{divparams.join(' ')}>\\ZAZENBLOCKCODE#{block_counter}ZAZENBLOCKCODE\\</pre>"
+          end
+        end
+
+        @escaped_at = []
+        block_counter = -1
+        fulltext.gsub!( /(\A|[^\w])@(.*?)@(\Z|[^\w])/m ) do
+          @escaped_at << $2
+          block_counter += 1
+          "#{$1}\\ZAZENBLOCKAT#{block_counter}ZAZENBLOCKAT\\#{$3}"
+        end
+      end
+
+      def render_code(text)
+        text.gsub!( /\\ZAZENBLOCKCODE(\d+)ZAZENBLOCKCODE\\/ ) do
+          if @translate_ids
+            @escaped_code[$1.to_i]
+          else
+            lang, code = *(@escaped_code[$1.to_i])
+            if lang != ''
+              code_tag = "<code class='#{lang}'>"
+            else
+              code_tag = '<code>'
+            end
+            if Syntax::SYNTAX[lang] != Syntax::Default && @context[:pretty_code]
+              convertor = Syntax::Convertors::HTML.for_syntax(lang)
+              "#{code_tag}#{convertor.convert( code, false )}</code>"
+            else
+              RedCloth.new("#{code_tag}#{code}</code>").to_html
+            end
+            #code_tag + code.gsub(/\n( *)/m) { "<br/>\n" + ('&nbsp;' * $1.length) } + '</code>'
+          end
+        end
+
+        text.gsub!( /\\ZAZENBLOCKAT(\d+)ZAZENBLOCKAT\\/ ) do
+          code = @escaped_at[$1.to_i]
+          if @translate_ids
+            '@'+code+'@'
+          else
+            if code =~ /^(\w+)\|/ && Syntax::SYNTAX[$1]
+              lang = $1
+              if @context[:pretty_code]
+                convertor = Syntax::Convertors::HTML.for_syntax(lang)
+                res = convertor.convert( code[(lang.length+1)..-1], false )
+              else
+                res = code[(lang.length+1)..-1]
+              end
+              res = "<code class='#{lang}'>#{res}</code>"
+            else
+              res = RedCloth.new("<code>#{code}</code>").to_html
+            end
+            res
+          end
+        end
+      end
+
+      def find_node_by_pseudo(id, base_node = @context[:node])
+        secure(Node) { Node.find_node_by_pseudo(id, base_node) }
+      end
+
+      def parse_document_ids(str)
+        meth = @translate_ids || :zip
+        str.split(',').map do |id|
+          if id.strip =~ /\A(\d+|#{PSEUDO_ID_REGEXP})/
+            if node = find_node_by_pseudo($1)
+              # replace shortcut
+              node.pseudo_id(@context[:node], meth)
+            else
+              id  # keep
+            end
+          else
+            id
+          end
+        end.compact
+      end
+    end # ZazenRules
+  end # Parser
+end # Zena