trac-wiki 0.2.16 → 0.2.20

data/lib/trac-wiki.rb

@@ -1,6 +1,7 @@
 require 'trac-wiki/parser'
 require 'trac-wiki/tree'
 require 'trac-wiki/version'
+require 'trac-wiki/env'
 
 module TracWiki
   # Convert the argument in Trac format to HTML and return the

data/lib/trac-wiki/env.rb

@@ -0,0 +1,256 @@
+module TracWiki
+
+  class Env
+    def initialize(parser, env = {})
+      @parser = parser
+      @env = env
+    end
+
+    def parse_macro_all(macro_name, str)
+      #print "macro_all: #{macro_name}, str:#{str}.\n"
+      if macro_name =~ /\A!/
+         # {{!cmd}}
+         mac_out, rest, lines = parse_macro_cmd(macro_name, str)
+      else
+         # {{$cmd}},  {{template}}, ...
+         mac_out, rest, lines = parse_macro_vartempl(macro_name, str)
+      end
+      return mac_out || '', rest, lines
+    end
+
+    # read to args to }}  (while balancing {{ and }})
+    # ret: (arg, rest, lines)
+    # mac_out  -- string to }} (macros inside expanded)
+    # rest -- str aftrer }}
+    # lines -- howmany \n eaten from str (from begining to }})
+    def parse_macro_vartempl(macro_name, str)
+      str_orig = str
+      lines = 0
+      arg = ''
+      # FIXME: MACRO_REX
+      #              prefix  }}...    {{macro_name
+      while str =~ TracWiki::Parser::MACRO_END_REX
+        prefix, bracket, sub_macro_name, str = $1, $2, $3, $'
+        arg << prefix
+        lines += prefix.count("\n")
+        if bracket == '}}'
+          #print "prefix: #{prefix}\n"
+          return do_macro_var($1, arg), str, lines if macro_name =~ /^\$(.*)/
+          return do_macro_templ(macro_name, arg), str, lines
+        end
+
+        # we need to go deeper!
+        mac_out, str, l = parse_macro_all(sub_macro_name, str)
+        arg << mac_out
+        lines += l
+      end
+      print "Error parsing macro(#{macro_name}) near '#{str}'(#{str_orig}) (arg:#{arg}, lines=#{lines})\n"
+      raise "Error parsing macro near '#{str}' (arg:#{arg}, lines=#{lines})"
+    end
+
+    # parse to next }} (with balanced {{..}})
+    # like parse_macro_vartempl but not expand content
+    # r: [expansion, rest_of_str, count_of_consumed_lines]
+    def parse_macro_cmd(macro_name, str)
+      str.sub!(/\A\s*\|?/, '')
+      return do_macro_cmd(macro_name, []), $', 0 if str =~ /\A}}/
+      #print "parse_macro_cmd: #{macro_name}, str#{str}\n"
+      dep = 0
+      lines = 0
+      args = ['']
+      while str =~ /{{|}}|\|/
+        prefix, match, str  = $`, $&, $'
+        args[-1] += prefix
+        lines += prefix.count("\n")
+        if match == '{{'
+          dep += 1
+          args[-1]  += $&
+        elsif match == '}}'
+          dep -= 1
+          return do_macro_cmd(macro_name, args), str, lines if dep < 0
+          args[-1]  += $&
+        elsif match == '|' && dep == 0
+          args.push('')
+        else
+          args[-1]  += $&
+        end
+      end
+      raise "eol in parsing macro params"
+    end
+
+    # calls {{!cmd}} (if exists
+    # r: result of  {{!cmd}}
+    def do_macro_cmd(macro_name, args)
+      return '|' if macro_name == '!'
+      if @parser.plugins.key?(macro_name)
+        @env['args'] =  args
+        @env['arg0'] =  macro_name
+        #print "mac: #{macro_name} env:" ; pp (@env)
+        ret = @parser.plugins[macro_name].call(self)
+        return ret
+      end
+      "UCMD(#{macro_name}|#{@env['arg']})"
+    end
+    def arg(idx)
+      @env['args'][idx] || ''
+    end
+
+    def prepare_y
+      #print "prepare_y\n"
+      return if @env.key? 'y'
+      arg = @env['arg']
+      return if arg.nil?
+      begin
+        @env['y'] = YAML.load(arg)
+        #print "y"
+        #pp @env['y']
+      rescue
+        @env['y'] = nil
+        #print "y:nil\n"
+      end
+    end
+
+    def at(key, default = nil, to_str = true)
+      #print "at(#{key}), env:"
+      #pp @env
+      return @env[key] || default if key.is_a? Symbol
+      prepare_y if key =~ /^y\./
+      cur = @env
+      key.split(/\./).each do |subkey|
+        subkey = at($1, '') if subkey =~ /\A\$(.*)/
+        #print "at:subkey: #{subkey}\n"
+        if  cur.is_a? Hash
+          cur = cur[subkey]
+        elsif cur.is_a? Array
+          cur = cur[subkey.to_i]
+        else
+          #print "at(#{key})->: default"
+          return default
+        end
+        #print "at(#{key}) -> default\n" if cur.nil?
+        return default if cur.nil?
+      end
+      #print "at(#{key})->#{cur}\n"
+      to_str ? cur.to_s : cur
+    end
+    def atput(key, val = nil)
+      #print "atput: #{key}, #{val} env:"
+      #pp @env
+      cur = @env
+      if val.is_a? Symbol
+        @env[key] = val
+        return
+      end
+      keys = key.split(/\./)
+      lastkey = keys.pop
+      keys.each do |subkey|
+        if cur.is_a? Hash
+          cur = cur[subkey]
+        elsif cur.is_a? Array
+          cur = cur[subkey.to_i]
+        else
+          return
+        end
+      end
+      if  cur.is_a? Hash
+        cur[lastkey] = val
+      elsif cur.is_a? Array
+        cur[lastkey.to_i] = val
+      end
+      #print "atput:env:"
+      #pp @env
+    end
+
+    def [](key)
+      at(key)
+    end
+
+    def []=(key,val)
+      #print "set #{key} to #{val}\n"
+      atput(key,val)
+    end
+
+    # expand macro `macro_name` with `args`
+    # afer expansion all {{macros}} will be expanded recursively
+    # r: expanded string
+    def do_macro_templ(macro_name, arg)
+      return "!{{toc}}" if macro_name == 'toc'
+      return arg.strip  if macro_name == '#echo'
+      return '' if macro_name == '#'
+
+      env = do_macro_arg_to_env(arg, @env[:depth])
+
+      #print "templ:#{macro_name}env:"
+      #pp(env)
+
+      if ! @parser.template_handler.nil?
+        str = @parser.template_handler.call(macro_name, env)
+        if !str.nil?
+          #print "dep:#{env[:depth]}(#{macro_name}, #{str})\n"
+          if env[:depth] > 32
+             return "TOO_DEEP_RECURSION(`#{str}`)\n"
+             #return "TOO_DEEP_RECURSION"
+          end
+          # FIXME: melo by nahlasit jestli to chce expandovat | wiki expadnovat |raw html
+          #print "temp(#{macro_name}) --> : #{str}\n"
+          #print "bf ex: [#{str}]\n"
+          str = env.expand(str)
+          #print "af ex: [#{str}]\n"
+          return str
+        end
+      end
+      #print "UMACRO(#{macro_name}|#{arg})\n"
+      "UMACRO(#{macro_name}|#{arg})"
+    end
+
+    def do_macro_arg_to_env(arg, depth)
+      arg.sub!(/\A\s*\|?/, '')
+      env  = { 'arg' => arg , depth: (depth||0) + 1  }
+      idx = 1
+      arg.split(/\|/).each do |val|
+        if val =~ /\A\s*(\w+)\s*=\s*(.*)/s
+          env[$1] = $2
+        else
+          env[idx.to_s] = val
+          idx+=1
+        end
+      end
+      return Env.new(@parser, env)
+    end
+
+    def do_macro_var(var_name, arg)
+      #print "var(#{var_name})env:"
+      #pp(@env)
+      ret = at(var_name, nil)
+      return ret if !ret.nil?
+      return arg.sub(/\A\s*\|?/, '') if arg
+      "UVAR(#{macro_name}|#{@env['arg']})"
+    end
+
+    # template expand
+    def expand_arg(idx)
+      expand(@env['args'][idx])
+    end
+
+    def pp_env
+      pp(@env)
+    end
+    def expand(str)
+      ret = ''
+      return '' if str.nil?
+      while str =~ TracWiki::Parser::MACRO_BEG_INSIDE_REX
+          prefix, macro_name2, str = $1, $2, $'
+          ret << prefix
+          # FIXME if macro_name2 =~ /^!/
+          mac_out, str, lines = parse_macro_all(macro_name2, str)
+          ret << mac_out
+          #print "Too long macro expadion" if ret.size > 1_000_000
+          raise TooLongException if ret.size > 1_000_000
+      end
+      #print "text: #{text.nil?}\n"
+      #print "ret: #{ret.nil?}\n"
+      return ret + str
+    end
+  end
+
+end

data/lib/trac-wiki/parser.rb

@@ -1,6 +1,7 @@
 require 'cgi'
 require 'uri'
 require 'iconv'
+require 'yaml'
 
 # :main: TracWiki
 
@@ -38,6 +39,9 @@ require 'iconv'
 # Inherit this to provide custom handling of links. The overrideable
 # methods are: make_local_link
 module TracWiki
+  class TooLongException < Exception
+  end
+
   class Parser
 
     # Allowed url schemes
@@ -85,18 +89,23 @@ module TracWiki
 
     # when id_from_heading, non ascii char are transliterated to ascii
     attr_writer :id_translit
+    attr_accessor :plugins
+    @plugins = {}
 
     # string begins with macro
-    MACRO_BEG_REX =  /\A\{\{ ( [\$]?\w+ | \#\w* ) /x
-    MACRO_BEG_INSIDE_REX =  /(.*?)(?<!\{)\{\{ ( \$\w+ | \#\w* | \w+ ) /x
+    MACRO_BEG_REX =  /\A\{\{ ( \$[\$\.\w]+ | [\#!]\w* |\w+ ) /x
+    MACRO_BEG_INSIDE_REX =  /\A(.*?)(?<!\{)\{\{ ( \$[\$\.\w]+ | [\#!]\w* | \w+ ) /xm
     # find end of marcro or begin of inner macro
-    MACRO_END_REX =  /\A(.*?) ( \}\} | \{\{ (\$\w+|\#\w*|\w+)  )/mx
+    MACRO_END_REX =  /\A(.*?) ( \}\} | \{\{ ( \$[\$\.\w]+ | [\#!]\w* | \w+)  )/mx
     def id_translit?; @id_translit; end
 
     # Create a new Parser instance.
     def initialize(text, options = {})
+      init_plugins
       @allowed_schemes = %w(http https ftp ftps)
       @anames = {}
+      plugins = options.delete :plugins
+      @plugins.merge! plugins if ! plugins.nil?
       @text = text
       @no_escape = nil
       @base = ''
@@ -104,8 +113,47 @@ module TracWiki
       @base += '/' if !@base.empty? && @base[-1] != '/'
     end
 
+    def init_plugins
+      @plugins = {
+        '!ifeq'  => proc { |env| env.expand_arg(0) == env.expand_arg(1) ? env.expand_arg(2) : env.expand_arg(3) },
+        '!ifdef' => proc { |env| env.at(env.expand_arg(0), nil, false).nil? ? env.expand_arg(2) : env.expand_arg(1) },
+        '!set'   => proc { |env| env[env.expand_arg(0)] = env.expand_arg(1); '' },
+        '!yset'  => proc { |env| env[env.expand_arg(0)] = YAML.load(env.arg(1)); '' },
+
+        '!html'  => proc { |env| "\n{{{!\n#{env.arg(0)}\n}}}\n" },
+        '!sub'   => proc { |env| pat = env.expand_arg(1)
+                                 pat = Regexp.new(pat[1..-2]) if pat =~ /\A\/.*\/\Z/
+                                 env.expand_arg(0).gsub(pat, env.expand_arg(2))
+                         },
+        '!for'   => proc { |env| i_name = env.arg(0)
+                               top = env.arg(1)
+                               tmpl = env.arg(2)
+                               #print "top#{top}\n"
+                               if top =~ /^\d+/
+                                 set = (0..(top.to_i-1))
+                               else
+                                 set = env.at(top, nil, false)
+                                 if set.is_a?(Hash)
+                                   set = set.keys.sort
+                                 elsif set.is_a?(Array)
+                                   set = (0 .. set.size-1)
+                                 else
+                                   print "error top(#{top}), set#{set} #{set.class}\n"
+                                   env.pp_env
+                                   raise "Error in {{!for #{i_name}|#{top}|#{tmpl}}}"
+                                 end
+                               end
+                               set.map do |i|
+                                 env[i_name] = i.to_s
+                                 env.expand(tmpl)
+                               end.join('')
+                       },
+      }
+
+    end
+
     # th(macroname) -> template_text
-    attr_writer :template_handler
+    attr_accessor :template_handler
 
     @was_math = false
     def was_math?; @was_math; end
@@ -138,6 +186,12 @@ module TracWiki
       @tree.to_html
     end
 
+    def add_plugin(name, &block)
+        @plugins[name] = block
+    end
+
+
+
     protected
 
     # Escape any characters with special meaning in HTML using HTML
@@ -407,11 +461,13 @@ module TracWiki
 
     def parse_inline_tag(str)
       case
-      when str =~ /\A\{\{\{(.*?\}*)\}\}\}/     # inline pre (tt)
+      when raw_html? && str =~ /\A\{\{\{!(.*?\}*)\}\}\}/     # inline {{{! raw html }}}
+        do_raw_html($1, true)
+      when str =~ /\A\{\{\{(.*?\}*)\}\}\}/     # inline {{{ }}} pre (tt)
         @tree.tag(:tt, $1)
       when str =~ MACRO_BEG_REX                # macro  {{
         str, lines = parse_macro($1, $')
-        #print "MACRO.inline(#{$1})"
+        #print "MACRO.inline(#{$1}), next:#{str}"
         return str
       when str =~ /\A`(.*?)`/                  # inline pre (tt)
         @tree.tag(:tt, $1)
@@ -421,7 +477,7 @@ module TracWiki
         #@tree.tag(:span, {class:'math'},  $1)
         @was_math = true
       when str =~ /\A(\&\w*;)/       # html entity 
-        print "add html ent: #{$1}\n"
+        #print "add html ent: #{$1}\n"
         @tree.add_raw($1)
       when str =~ /\A([:alpha:]|[:digit:])+/
         @tree.add($&)                      # word
@@ -455,103 +511,31 @@ module TracWiki
       return $'
     end
 
+    #################################################################
+    # macro {{ }}
+    #  convetntion {{!cmd}} {{template}} {{$var}} {{# comment}} {{!}} (pipe)
+
     # r: expanded macro + rest of str, count lines taken from str
     # sideefect: parse result of macro
     def parse_macro(macro_name, str)
+      @env = Env.new(self) if @env.nil?
       begin
-        mac_out, rest, lines = parse_macro_arg(macro_name, str, {})
-        #parse_inline(mac)
-        #@tree.add(mac)
-        #print "MACOUT:'#{mac_out}'\n"
+        mac_out, rest, lines = @env.parse_macro_all(macro_name, str)
+        #print "mac: '#{mac_out}' rest: '#{rest}'\n"
         return mac_out + rest, lines
-      rescue  Exception => a
-        return "TOO_LONG_EXPANSION_OF_MACRO(#{macro_name})QUIT"
-      end
-    end
-
-    # read to args to }}  (while balancing {{ and }})
-    # ret: (arg, rest, lines)
-    # mac_out  -- string to }} (macros inside expanded)
-    # rest -- str aftrer }}
-    # lines -- howmany \n eaten from str (from begining to }})
-    def parse_macro_arg(macro_name, str, env)
-
-      lines = 0
-      arg = ''
-      # FIXME: MACRO_REX
-      #              prefix  }}...    {{macro_name
-      while str =~ MACRO_END_REX
-        prefix, bracket, sub_macro_name, str = $1, $2, $3, $'
-        arg << prefix
-        lines += prefix.count("\n")
-        if bracket == '}}'
-          #print "prefix: #{prefix}\n"
-          env = do_macro_arg_to_env(arg, env[:depth])
-          return do_macro(macro_name, env), str, lines
-        end
-
-        # we need to go deeper!
-        mac_out, str, l = parse_macro_arg(sub_macro_name, str, env)
-        arg << mac_out
-        lines += l
+      rescue  TooLongException => e
+        return "TOO_LONG_EXPANSION_OF_MACRO(#{macro_name})QUIT", 0
       end
-      raise "Error parsing macro near '#{str}' (arg:#{arg}, lines=#{lines})"
     end
 
-    # expand macro `macro_name` with `args`
-    # afer expansion all {{macros}} will be expanded recursively
-    # r: expanded string
-    def do_macro(macro_name, env)
-      return "!{{toc}}" if macro_name == 'toc'
-      return env[:arg].strip  if macro_name == '#echo'
-      return '' if macro_name == '#'
 
-      return do_macro_var(macro_name, env) if macro_name =~ /^\$/
 
-
-      if ! @template_handler.nil?
-        text = @template_handler.call(macro_name, env)
-        if !text.nil?
-          #print "dep:#{env[:depth]}(#{macro_name}, #{text})\n"
-          if env[:depth] > 32
-             return "TOO_DEEP_RECURSION(`#{text}`)\n"
-             #return "TOO_DEEP_RECURSION"
-          end
-          # FIXME: melo by nahlasit jestli to chce expandovat | wiki expadnovat |raw html
-          #print "temp(#{macro_name}) --> : #{text}\n"
-          text = do_macro_expand_result(text, env)
-          #print "af expand:#{text}\n"
-
-          return text
-        end
-      end
-      "UMACRO(#{macro_name}#{env[:arg]})"
-    end
-
-    def do_macro_var(macro_name, env)
-      "VAR(#{macro_name})"
-    end
-
-    def do_macro_arg_to_env(arg, depth)
-      { arg: arg , depth: (depth||0) + 1  }
-    end
-
-    # template expand
-    def do_macro_expand_result(text, env)
-      ret = ''
-      while text =~ MACRO_BEG_INSIDE_REX
-          prefix, macro_name2, text = $1, $2, $'
-          ret << prefix
-          mac_out, text, lines = parse_macro_arg(macro_name2, text, env)
-          ret << mac_out
-          raise "Too long macro expadion" if ret.size > 1_000_000
-      end
-      return ret + text
-    end
+    #################################################################
 
 
     def parse_table_row(str)
       start_tag('tr') if !@stack.include?('tr')
+      str.sub!(/\r/, '')
       colspan = 1
       print_tr = true
       last_tail  = ''
@@ -674,8 +658,8 @@ module TracWiki
       @tree.tag(:pre, nowikiblock)
     end
 
-    def do_raw_html(text)
-      end_paragraph
+    def do_raw_html(text, inline=false)
+      end_paragraph if !inline
       @tree.add_raw(text)
     end
 
@@ -741,7 +725,8 @@ module TracWiki
         # macro
         when str =~ MACRO_BEG_REX
           str, lines = parse_macro($1, $')
-          #print "MACRO.block(#{$1})\n"
+          #print "MACRO.block(#{$1})next:#{str}\n"
+          @line_no += lines
           next
         # display math $$
         when math? && str =~ /\A\$\$(.*?)\$\$/m
@@ -778,7 +763,7 @@ module TracWiki
           do_citation($1.count('>'), $2)
         # ordinary line
         when str =~ /\A(\s*)(\S+.*?)$(\r?\n)?/
-          do_ord_line($1.size, $2) 
+          do_ord_line($1.size, $2)
         else # case str
           raise "Parse error at #{str[0,30].inspect}"
         end
@@ -786,7 +771,7 @@ module TracWiki
         str = $'
       end
       end_paragraph
-      @headings.last[:eline] = @line_no - 1 
+      @headings.last[:eline] = @line_no - 1
     end
 
     def aname_nice(aname, title)

data/lib/trac-wiki/tree.rb

@@ -145,9 +145,11 @@ module TracWiki
 
      def san_conf
         return @san_conf if @san_conf
-        conf = { elements:   ['form', 'input'],
+        conf = { elements:   ['form', 'input', 'span', 'div'],
                  attributes: { 'form'  =>  ['action', 'meth'],
                                'input' =>  ['type', 'value'],
+                               'span'  =>  ['class'],
+                               'div'   =>  ['class'],
                              },
                }
                    

data/lib/trac-wiki/version.rb

@@ -1,3 +1,3 @@
 module TracWiki
-  VERSION = '0.2.16'
+  VERSION = '0.2.20'
 end

data/test/parser_test.rb

@@ -5,13 +5,26 @@ require 'pp'
 
 class Bacon::Context
   def tc(html, wiki, options = {})
-    #options[:template_handler] = proc {|tname,env| template_handler(tname, env) }
+    options[:plugins] = { '!print' => proc { |env| env.arg(0) + '! ' }, 
+                        }
     options[:template_handler] = self.method(:template_handler)
-    TracWiki.render(wiki, options).should.equal html
+
+    parser = TracWiki.parser(wiki, options)
+    parser.to_html.should.equal html
   end
 
   def template_handler(tname, env)
     case tname
+    when 'ifeqtest'
+      "{{!ifeq {{$1}}|{{$2}}|TRUE|FALSE}}"
+    when 'vartest2'
+      "{{vartest {{$1}}|{{$dva}}|p={{$p}}|{{$3   |tridef}}}}"
+    when 'ytest'
+      "{{$y.ahoj}},{{$y.bhoj.1}}"
+    when 'ytest2'
+      "{{!set i|ahoj}}{{$y.$i}},{{$y.bhoj.1}}"
+    when 'vartest'
+      "jedna:{{$1}},dve:{{$2}},p:{{$p}},arg:{{$arg}}"
     when 'test'
       "{{west}}"
     when 'west'
@@ -20,6 +33,8 @@ class Bacon::Context
       "{{deep}}"
     when 'wide'
       "0123456789{{wide}}" * 10
+    when 'fortest'
+      "{{$y.data.a}},({{!for i|y.data|AHOJ({{$i}})\n{{$y.data.$i}};\n}}),{{$y.data.a}}"
     else
       nil
       #"UNK_TEMPL(#{tname})"
@@ -574,6 +589,8 @@ describe TracWiki::Parser do
 
   it 'should parse table' do
     tc "<table><tr><td>Hello</td><td>World!</td></tr></table>", "||Hello||World!||"
+    tc "<table><tr><td>Hello</td><td>World!</td></tr><tr><td>Hello</td><td>World!</td></tr></table>", "||Hello||World!||\n||Hello||World!||\n\n"
+    tc "<table><tr><td>Hello</td><td>World!</td></tr><tr><td>Hello</td><td>World!</td></tr></table>", "||Hello||World!||\r\n||Hello||World!||\r\n\n"
     tc "<table><tr><td>Hello</td><td>World!</td></tr></table>", "||Hello||\\\n||World!||"
     tc "<table><tr><td>He</td><td>llo</td><td>World!</td></tr></table>", "||He||llo||\\\n||World!||"
     tc "<table><tr><td>Hello</td><td colspan=\"2\">World!</td></tr></table>", "||Hello||||World!||"
@@ -893,12 +910,12 @@ eos
 
     tc "<h1>h1</h1>" , "{{# co{{HUU}}mment }}\n\n\n= h1 =\n{{# Comment2}}\n" 
 
-    tc "<p>UMACRO(macr ahoj )</p>\n" , "{{macr\nahoj\n}}"
-    tc "<p>ahoj UMACRO(macrUMACRO(o))</p>\n" , "ahoj {{macr{{o}}}}"
-    tc "<p>ahoj UMACRO(macro)</p>\n" , "ahoj {{macro}}"
-    tc "<p>ahoj {{%macrUMACRO(o)}}</p>\n" , "ahoj {{%macr{{o}}}}"
-    tc "<p>ahoj UMACRO(macrUMACRO(mac <strong>o</strong>))</p>\n" , "ahoj {{macr{{mac **o**}}}}"
-    tc "<p>ahoj VAR($mac)</p>\n" , "ahoj {{$mac|ahoj}}"
+    tc "<p>UMACRO(macr|ahoj )</p>\n" , "{{macr\nahoj\n}}"
+    tc "<p>ahoj UMACRO(macr|UMACRO(o|))</p>\n" , "ahoj {{macr{{o}}}}"
+    tc "<p>ahoj UMACRO(macro|)</p>\n" , "ahoj {{macro}}"
+    tc "<p>ahoj {{%macrUMACRO(o|)}}</p>\n" , "ahoj {{%macr{{o}}}}"
+    tc "<p>ahoj UMACRO(macr|UMACRO(mac|<strong>o</strong>))</p>\n" , "ahoj {{macr{{mac **o**}}}}"
+    tc "<p>ahoj ahoj</p>\n" , "ahoj {{$mac|ahoj}}"
   end
 
   it 'should do temlate' do
@@ -908,23 +925,84 @@ eos
     # macro errors:
     tc "<p>TOO_DEEP_RECURSION(<tt>{{deep}}</tt>) 3</p>\n", "{{deep}}3"
     tc "<p>TOO_LONG_EXPANSION_OF_MACRO(wide)QUIT</p>\n", "{{wide}}3"
-    tc "<p>UMACRO(unknown)3</p>\n", "{{unknown}}3"
+    tc "<p>UMACRO(unknown|)3</p>\n", "{{unknown}}3"
+  end
+  it 'should do temlate with args' do
+    tc "<p>jedna:VARTESTPARAM,dve:,p:DVE,arg:VARTESTPARAM|p=DVE</p>\n", "{{vartest VARTESTPARAM|p=DVE}}"
+    tc "<p>jedna:VARTESTPARAM,dve:TRI,p:DVE,arg:VARTESTPARAM|p=DVE|TRI</p>\n", "{{vartest VARTESTPARAM|p=DVE|TRI}}"
+    tc "<p>jedna:VARTESTPARAM,dve:TRI,p:DVE,arg:VARTESTPARAM|TRI|p=DVE|tridef</p>\n", "{{vartest2 VARTESTPARAM|p=DVE|dva=TRI}}"
+    tc "<p>ahoj |</p>\n", "ahoj {{!}}"
+    #FIXME: should be: '... jedna:be||no to be,dve: ..'
+    tc "<p>jedna:be,dve:,p:,arg:be||not to be</p>\n", "{{vartest be{{!}}{{!}}not to be}}"
   end
   it 'should support options' do
     tc "<h3>h1<a class=\"editheading\" href=\"?edit=1\">edit</a></h3>", "=== h1 ==", edit_heading: true
   end
   it 'should not html' do
-    tc "<p>{{{! &lt;a&gt;&lt;/a&gt; }}}</p>\n", "{{{!\n<a></a>\n}}}\n"
+    #tc "<p>{{{! &lt;a&gt;&lt;/a&gt; }}}</p>\n", "{{{!\n<a></a>\n}}}\n"
     tc '<a></a>', "{{{!\n<a></a>\n}}}\n", raw_html: true
     tc '<a></a>', "{{{!\n<a></a>\n}}}\n", raw_html: true
     tc "<form meth=\"POST\" action=\"http://www.example.com\"><input type=\"hidden\" value=\"VAL\"></form>",
        "{{{!\n<form meth=\"POST\" action=\"http://www.example.com\"><input type=\"hidden\" value=\"VAL\"/></form>\n}}}\n", raw_html: true
     tc 'alert(444);', "{{{!\n<script>alert(444);</script>\n}}}\n", raw_html: true
   end
-  it 'should not entity' do
+  it 'should entity' do
     tc "<p>\u00a0</p>\n", "&nbsp;"
     tc "<p>„text“</p>\n", "&bdquo;text&ldquo;"
   end
+  it 'should plugin' do
+    tc "<p>AHOJTE!</p>\n", "{{!print AHOJTE}}"
+    tc "<p>test:AHOJTE! AHOJTE! </p>\n", "test:{{!print AHOJTE}}{{!print AHOJTE}}"
+    tc "<p>FALSE</p>\n", "{{ifeqtest JEDNA|DVE}}"
+    tc "<p>TRUE</p>\n", "{{ifeqtest JEDNA|JEDNA}}"
+    tc "<p>AHOJ</p>\n", "{{!set ahoj|AHOJ}}{{$ahoj}}"
+    tc "<p>BHOJ</p>\n", "{{!ifeq a|b|{{!set ahoj|AHOJ}}|{{!set ahoj|BHOJ}}}}{{$ahoj}}"
+    tc "<p>AHOJ</p>\n", "{{!ifeq a|a|{{!set ahoj|AHOJ}}|{{!set ahoj|BHOJ}}}}{{$ahoj}}"
+    tc "<p>TRUE</p>\n", "{{!set a|a}}{{!ifeq {{$a}}|a|TRUE|FALSE}}"
+    tc "<p>FALSE</p>\n", "{{!set a|a}}{{!ifeq {{$a}}|b|TRUE|FALSE}}"
+    tc "<p>,AHOJ! ,FALSE</p>\n", "{{!set a|a}},{{!print AHOJ}},{{!ifeq {{$a}}|b|TRUE|FALSE}}"
+    tc "", "{{!ifeq a|b|TRUE}}"
+    tc "<p>AHOJ,dve</p>\n", "{{ytest \nahoj: AHOJ\nbhoj: [ jedna, dve ]\n}}"
+    tc "<p>,malo</p>\n", "{{!yset ahoj|data: [1,2]\ndesc: malo}},{{$ahoj.desc}}"
+    tc "<p>,BETA</p>\n", "{{!yset ahoj|data: [ALFA,BETA]\ndesc: malo}},{{$ahoj.data.1}}"
+    tc "<p>,GAMA</p>\n", "{{!yset ahoj|data: [ALFA,BETA]\ndesc: malo}},{{!set ahoj.data.3|GAMA}}{{$ahoj.data.3}}"
+    tc "<p>,2</p>\n", "{{!yset ahoj|data: [1,2]\ndesc: malo}},{{$ahoj.data.1}}"
+    tc "<p>AHOJ,dve</p>\n", "{{ytest2 \nahoj: AHOJ\nbhoj: [ jedna, dve ]\n}}"
+    tc "<p>,,BHOJ</p>\n", "{{!set ahoj|AHOJ}},{{!set AHOJ|BHOJ}},{{$$ahoj}}"
+    tc "<p>(0),(1),(2),</p>\n", "{{!for i|3|({{$i}}),}}", raw_html: true
+    tc "<p>(0),(1),(2),(3),</p>\n", "{{!for i|4|({{$i}}),}}", raw_html: true
+    tc "<p>,(ALFA),(BETA),</p>\n", "{{!yset data|[ALFA,BETA]}},{{!for i|data|({{$data.$i}}),}}"
+    tc "<p>,(1),(2),</p>\n", "{{!yset data|[1,2]}},{{!for i|data|({{$data.$i}}),}}"
+    tc "<p>,(alfa:ALFA),(beta:BETA),</p>\n", "{{!yset data|beta: BETA\nalfa: ALFA\n}},{{!for i|data|({{$i}}:{{$data.$i}}),}}"
+
+    tc "<p>,FALSE</p>\n", "{{!yset data|[1,2]}},{{!ifdef data.55|TRUE|FALSE}}"
+    tc "<p>,TRUE</p>\n", "{{!yset data|[1,2]}},{{!ifdef data.1|TRUE|FALSE}}"
+    tc "<p>,TRUE</p>\n", "{{!yset data|{a: 1, b: 2} }},{{!ifdef data.a|TRUE|FALSE}}"
+    tc "<p>,FALSE</p>\n", "{{!yset data|{a: 1, b: 2} }},{{!ifdef data.q|TRUE|FALSE}}"
+    tc "<p>,1,(1;2;),1</p>\n", "{{!yset data|{a: 1, b: 2} }},{{$data.a}},({{!for i|data|{{$data.$i}};}}),{{$data.a}}"
+    tc "<p>1,(AHOJ(a) 1; AHOJ(b) 2; ),1</p>\n", "{{fortest data:\n a: 1\n b: 2 }}"
+  end
+
+  it 'should {{!sub}}' do
+    tc "<p>ahoj_you_one</p>\n", "{{!sub ahoj you one| |_}}"
+    tc "<p>-h-j --- -n-</p>\n", "{{!sub ahoj you one|/[aeiouy]/|-}}"
+    tc "<p>ahoj MATCH(you) one</p>\n", "{{!sub ahoj you one|/(y.u)/|MATCH(\\1)}}"
+  end
+
+  it 'should {{!html}}' do
+    tc "alert(666)", "{{!html <script>alert(666)</script>}}", raw_html: true
+    tc "<p><b>T</b>E</p>", "{{!html <p><b>T</b>E</p>}}\n", raw_html: true
+    tc "<span>Span</span>", "{{!html <span>Span</span>}}\n", raw_html: true
+    #tc "<span>Span</span>", "**{{!html <span>Span</span>}}**\n", raw_html: true
+    tc "<div class=\"ahoj\">Div</div>", "{{!html <div class=\"ahoj\">Div</div>}}\n", raw_html: true
+    tc "<span>Span</span><span>Span</span>", "{{!html <span>Span</span>}}{{!html <span>Span</span>}}\n", raw_html: true
+    tc "<p>ahoj <span class=\"spanclass\">span</span> bhoj dhoj choj</p>\n", "ahoj {{{!<span class=\"spanclass\">span</span> bhoj}}} dhoj \nchoj\n", raw_html: true
+    tc "<p>ahoj Q<span class=\"spanclass\">span</span> bhojQ dhoj choj</p>\n", "ahoj Q{{{!<span class=\"spanclass\">span</span> bhoj}}}Q dhoj \nchoj\n", raw_html: true
+  end
+#  it 'last test' do
+#    #tc "<p>1,(AHOJ(a) 1; AHOJ(b) 2; ),1</p>\n", "{{fortest data:\n a: 1\n b: 2 }}"
+#
+#  end
   end
 end
 # vim: tw=0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trac-wiki
 version: !ruby/object:Gem::Version
-  version: 0.2.16
+  version: 0.2.20
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-27 00:00:00.000000000 Z
+date: 2014-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bacon
@@ -60,6 +60,7 @@ files:
 - Rakefile
 - bin/trac-wiki.rb
 - lib/trac-wiki.rb
+- lib/trac-wiki/env.rb
 - lib/trac-wiki/parser.rb
 - lib/trac-wiki/tree.rb
 - lib/trac-wiki/version.rb