tartan 0.1.0

data/lib/tartan_markdown.rb

@@ -0,0 +1,8 @@
+#$Id: tartan_markdown.rb 148 2006-07-22 14:04:20Z larry $
+
+require 'tartan'
+require 'tartan_markdown_def'
+
+class TartanMarkdown < Tartan
+  include TartanMarkdownDef
+end

data/lib/tartan_markdown_def.rb

@@ -0,0 +1,7 @@
+#$Id: tartan_markdown_def.rb 153 2006-07-22 20:39:45Z larry $
+
+require 'tartan'
+
+module TartanMarkdownDef
+  yaml 'markdown.yml'
+end

data/lib/tartan_table_def.rb

@@ -0,0 +1,7 @@
+require 'tartan'
+
+# This module should be included into a Tartan subclass to add table mark-up.
+
+module TartanTableDef
+  yaml "table.yml"
+end

data/lib/tartan_test_base_def.rb

@@ -0,0 +1,5 @@
+require 'tartan'
+
+module TartanTestBaseDef
+  yaml "test_base.yml"
+end

data/lib/tartan_wikilink_def.rb

@@ -0,0 +1,14 @@
+require 'tartan'
+
+module TartanWikilinkDef
+  def wiki_link_body(page_name, link_body)
+    link_body = page_name if "" == link_body
+    link_body
+  end
+  
+  def wiki_link_tag(page_name)
+    raise "wiki_link_tag not properly defined in WikiHelper class"
+  end
+
+  yaml "wikilink.yml"
+end

data/lib/test_base.yml

@@ -0,0 +1,18 @@
+# $Id$
+block: 
+  - title: main_block
+  - title: html_comment
+  - title: paragraph
+    match: "/((?:^\S.*?$)(?:\n\S[^\n]*)*)/m"
+    subparse: span
+    html: 
+      end_mark: "</p>"
+      start_mark: "<p>"
+span: 
+  - title: pre_emphasis
+  - title: amp
+  - title: italic
+    html: 
+      replace: "<em>\\1</em>"
+    match: "/\*(.*?)\*/m"
+  - rescan

data/lib/wiki-test.rb

@@ -0,0 +1,94 @@
+#$Id: wiki-test.rb 159 2006-07-24 08:13:02Z larry $
+
+require 'test/unit'
+require 'yaml'
+require 'benchmark'
+require 'breakpoint'
+require 'core_ext/file'
+
+class WikiTestCases
+  def initialize(parserKlass, testfiles, targets=[:html, :db])
+
+    # if either the testfile or target argument is a single value, turn
+    # it into a single element array
+    testfiles = testfiles.to_a
+
+    targests = targets.to_a
+
+    Class.new Test::Unit::TestCase do
+
+      define_method 'parserClass' do
+        parserKlass
+      end
+
+      def assert_wiki(expected, wiki_text, options, type=:html)
+        # time limit in seconds
+        time_limit = options['time_limit'] ? options['time_limit'] : 1.0
+
+        parser = parserClass.new(wiki_text, options)
+
+        out = nil
+        wtimes = Benchmark.measure do
+          out = parser.to_type(type)
+        end
+
+        time_elapsed = wtimes.utime + wtimes.stime
+
+        if $DEBUG || options['debug'] || options[:debug]
+          print "time_limit:   #{'%0.3f' % time_limit}\n"+
+          "time_elapsed: #{'%0.3f' % time_elapsed}"
+        end
+
+        assert_equal(expected, out)
+        assert time_elapsed <= time_limit,
+        "elapsed time expected <= #{'%0.3f' % time_limit}"+
+        " but was #{'%0.3f' % time_elapsed}\n"
+      end
+
+      sequence = 0
+      globalOptions = (defined? WikiOptions) ? WikiOptions.dup : {}
+      globalSubs = {}
+      testfiles.each do |testfile|
+        file = File.find_file_in_path(testfile)
+
+        YAML::load_documents( File.open( file ) ) do |doc|
+          next unless doc
+
+          globalOptions = doc['options.global'] if doc['options.global']
+
+          options = globalOptions
+
+          options = options.merge(doc['options']) if doc['options']
+
+          globalSubs = doc['subs.global'] if doc['subs.global']
+
+          subs = globalSubs
+
+          subs = subs.merge(options)
+
+          subs = subs.merge(doc['subs']) if doc['subs']
+
+          next unless doc['in']
+          
+          input = doc['in'].gsub(/\{\{\{(.*?)\}\}\}/) {|sub| subs[$1]}
+
+          title = doc['title'] ? doc['title'] : (sequence += 1).to_s
+
+          targets.each do |target| 
+            target = target.to_sym if target.is_a? String
+            target_name = target.id2name if target.is_a? Symbol
+
+            next unless doc[target_name]
+
+            expected \
+              = doc[target_name].gsub(/\{\{\{(.*?)\}\}\}/) {|sub| subs[$1]}
+
+            define_method  "test_#{target_name}_" + title do
+              assert_wiki expected, input, options.dup, target
+            end # define_method
+          end # targests.each
+        end # YAML::load_documents
+      end  # testfiles.each
+    end # Class.new
+  end # intialize
+end # class WikiTestCases

data/lib/wiki_rule.rb

@@ -0,0 +1,240 @@
+# $Id: wiki_rule.rb 159 2006-07-24 08:13:02Z larry $
+require 'core_ext/regexp'
+
+class WikiRule < Hash
+    def initialize(matcher={})
+      matcher.each { |(a, v)| self[a] = v }
+    end
+    
+    def matcher
+      self
+    end
+    
+    # define methods to access elements of matcher hash
+    def method_missing(method_symbol)
+      self.class.send(:define_method, method_symbol) {self[method_symbol]}
+      self[method_symbol]
+    end
+    
+    def match
+      self[:match] ? self[:match].to_regexp : nil
+    end
+    
+    def strip_match
+      strip = self[:strip]
+      (strip and strip[:match]) ? strip[:match].to_regexp : nil
+    end
+
+    def unstrip_match
+      unstrip = self[:unstrip]
+      (unstrip and unstrip[:match]) ? unstrip[:match].to_regexp : nil
+    end
+
+    def strip_replace
+      self[:strip][:replace]
+    end
+    
+    def unstrip_replace
+      self[:unstrip][:replace]
+    end
+
+    def placed(position)
+      self.delete(position)
+    end
+    
+    def default_rule
+      self[:default]
+    end
+    
+    def start_mark(type)
+      return false if self[type].nil? or self[type].class == TrueClass
+
+      self[type][:start_mark]
+    end
+    
+    def end_mark(type)
+      return false if self[type].nil? or self[type].class == TrueClass
+
+      self[type][:end_mark]
+    end
+    
+    def replace_regex(type)
+      return false if self[type].nil? or self[type].class == TrueClass
+
+      self[type][:replace]
+    end
+
+    def target_position
+      self[:position]
+    end
+
+    def vars_to_set
+        self[:set]
+    end
+
+    def subparse_context
+      return nil if ! self.has_key?(:subparse)
+      
+      if self[:subparse].is_a?(Symbol) or self[:subparse].is_a?(String)
+        return self[:subparse]
+      elsif self[:subparse].has_key?(:context)
+        return self[:subparse][:context]
+      end
+      
+      return nil
+    end
+    
+    def subparse_match_group
+      if has_key?(:subparse) and 
+         self[:subparse].is_a?(Hash) and 
+         self[:subparse].has_key?(:match_group)
+        self[:subparse][:match_group]
+      else
+        nil
+      end
+    end
+    
+    def position_matches?(parsed, to_be_parsed, match_result)
+        return true if !target_position
+
+        pos = parsed.length
+
+        return true if target_position == pos
+        return true if :first == target_position && 0 == pos
+
+        if 0 == to_be_parsed.length && match_result.post_match.empty?
+            return true if :last == target_position
+            return true if :all == target_position && 0 == parsed.length
+        else
+            return true if :not_last == target_position
+        end
+
+        return false
+    end
+    
+    def has_type?(type)
+        if String == type.class
+            type = type.to_sym
+        end
+
+        return self[type]
+    end
+
+    def replace(parse_type, match_result, wikiparser)
+        return unless match_result
+        
+        wikiparser.substitute(replace_regex(parse_type), match_result)
+    end
+
+    def block(parse_type, text, match_result, wikiparser)
+        return unless match_result
+
+        mid = text
+
+        start_strip = ""
+        end_strip = ""
+        
+        if subparse_match_group
+          subparse_index = match_result.sym2index(subparse_match_group)
+
+          last_match = match_result.last_match_index
+          start_strip = match_result.pre_sub_match(subparse_index)
+          end_strip = match_result.post_sub_match(subparse_index)
+          mid = match_result[subparse_index]
+        end
+
+        if strip.is_a?(Hash) and strip[:match] and strip[:replace]
+          mid = mid.gsub(strip_match, strip_replace)
+        end
+
+        # need to evaluate the start_text before the execution of the
+        # sub-parse in case any of the wiki helper functions depend on
+        # ordering of the text
+        start_text = start_mark(parse_type)? 
+                      wikiparser.substitute(start_mark(parse_type), 
+                                             match_result): 
+                      ""
+        if subparse_context
+            mid = wikiparser.parse_by_context(parse_type, subparse_context, mid)
+        end
+        
+        mid = start_text + mid
+        
+        if end_mark(parse_type)
+          mid += wikiparser.substitute(end_mark(parse_type), match_result)
+        end
+
+        if ! has_key?(parse_type)
+          mid = start_strip + mid + end_strip
+          
+          if unstrip
+            mid.gsub!(unstrip_match, unstrip_replace)
+          end
+        end
+        
+        mid
+    end
+
+    def handle_match(parse_type, parsed, to_be_parsed, match_result, wikiparser)
+        debug_opt = wikiparser.get_var('debug') 
+        if $DEBUG || debug || true == debug_opt || debug_opt == title
+            puts "\n%s matches [[%s<<\n%s\n>>%s]]" %
+                 [title, match_result.pre_match, match_result, 
+                    match_result.post_match] 
+        end
+
+        wikiparser.set_vars(vars_to_set, match_result)
+        
+        mid = match_result[0]
+        
+        if replace_regex(parse_type)
+          mid = replace(parse_type, match_result, wikiparser)
+        elsif true == self[parse_type] or
+           start_mark(parse_type) or
+           end_mark(parse_type) or
+           subparse
+           
+          mid = block(parse_type, mid, match_result, wikiparser)
+        end
+        
+        if shelve && mid
+            mid = wikiparser.shelve(mid)
+        end
+
+        if "" != match_result.pre_match
+          parsed.add_text(false, match_result.pre_match)
+        end
+        
+        parsed.add_text(true, mid) if "" != mid
+        
+        if "" != match_result.post_match
+          to_be_parsed.add_back_text(false, match_result.post_match)
+        end
+        
+        return parsed, to_be_parsed
+    end
+
+    def parse_element(parse_type, to_be_parsed, wikiparser)
+        parsed = ParsedTextList.new
+
+        position = 0
+        while element = to_be_parsed.shift
+            if element.claimed? then parsed.add(element); next ; end
+
+            match_result = match.match(element)
+
+            unless match_result then parsed.add(element); next; end
+
+            if !position_matches?(parsed, to_be_parsed, match_result)
+                parsed.add(element)
+                next
+            end
+            
+            parsed, to_be_parsed = handle_match(parse_type, parsed, 
+                                                to_be_parsed, 
+                                                match_result, wikiparser)
+        end
+
+        parsed
+    end    
+end

data/lib/wikilink.yml

@@ -0,0 +1,18 @@
+span: 
+  - title: wikilinkWithText
+    beginning: true
+    match: "/\[\[([^|]+)[|]([^\]]*)\]\]/"
+    shelve: true
+    subparse: 
+      context: span
+      match_group: 2
+    html: 
+      start_mark: "#{wiki_link_tag(\1)}"
+      end_mark: </a>
+    
+  - title: wikilink
+    after: wikilinkWithText
+    match: "/\[\[([^\]]+)\]\]/"
+    shelve: true
+    html: 
+      replace: "#{wiki_link_tag(\1)}\1</a>"

data/test/MarkdownTest_1.0/Amps and angle encoding.html

@@ -0,0 +1,17 @@
+<p>AT&amp;T has an ampersand in their name.</p>
+
+<p>AT&amp;T is another way to write it.</p>
+
+<p>This &amp; that.</p>
+
+<p>4 &lt; 5.</p>
+
+<p>6 > 5.</p>
+
+<p>Here's a <a href="http://example.com/?foo=1&amp;bar=2">link</a> with an ampersand in the URL.</p>
+
+<p>Here's a link with an amersand in the link text: <a href="http://att.com/" title="AT&amp;T">AT&amp;T</a>.</p>
+
+<p>Here's an inline <a href="/script?foo=1&amp;bar=2">link</a>.</p>
+
+<p>Here's an inline <a href="/script?foo=1&amp;bar=2">link</a>.</p>

data/test/MarkdownTest_1.0/Amps and angle encoding.text

@@ -0,0 +1,21 @@
+AT&T has an ampersand in their name.
+
+AT&T is another way to write it.
+
+This & that.
+
+4 < 5.
+
+6 > 5.
+
+Here's a [link] [1] with an ampersand in the URL.
+
+Here's a link with an amersand in the link text: [AT&T] [2].
+
+Here's an inline [link](/script?foo=1&bar=2).
+
+Here's an inline [link](</script?foo=1&bar=2>).
+
+
+[1]: http://example.com/?foo=1&bar=2
+[2]: http://att.com/  "AT&T"