tartan 0.1.1 → 0.2.0

data/lib/tartan/wiki_rule.rb

@@ -0,0 +1,242 @@
+# $Id: wiki_rule.rb 181 2007-01-05 20:59:06Z bitherder $
+require 'core_ext/regexp'
+
+module Tartan
+  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
+end # Tartan

data/lib/tartan/wikilink/rules.rb

@@ -0,0 +1,18 @@
+require 'core_ext'
+
+module Tartan
+  module Wikilink
+    module Rules
+      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 "tartan/wikilink/wikilink.yml"
+    end
+  end
+end

data/lib/{wikilink.yml → tartan/wikilink/wikilink.yml}

@@ -1,7 +1,9 @@
 span: 
   - title: wikilinkWithText
-    beginning: true
-    match: "/\[\[([^|]+)[|]([^\]]*)\]\]/"
+    after: code_done
+    match: '/ \[\[ \s* (.+?) (?= \s* (?:\]\] | \| ) ) \s* \| \s* (.*?) \s* \]\] /x'
+#    match: '/\[\[ ((?: . (?! \]\] | \| ) )+.) \| (.*?)\]\] /x'
+#    match: "/\[\[([^\]|]+?)[|]([^\]]*)\]\]/"
     shelve: true
     subparse: 
       context: span