Pimki 1.7.092 → 1.8.092

data/app/models/chunks/category.rb

@@ -1,33 +1,33 @@
-require 'chunks/chunk'
-
-# The category chunk looks for "category: news" on a line by
-# itself and parses the terms after the ':' as categories.
-# Other classes can search for Category chunks within
-# rendered content to find out what categories this page
-# should be in.
-#
-# Category lines can be hidden using ':category: news', for example
-class Category < Chunk::Abstract
-  def self.pattern() return /^(:)?category\s*:(.*)$/i end
-
-  attr_reader :hidden, :list
-
-  def initialize(match_data, revision)
-    super(match_data, revision)
-    @hidden = match_data[1]
-    @list = match_data[2].split(',').map { |c| c.strip }
-  end
-
-  # Mark this chunk's start and end points but allow the terms
-  # after the ':' to be marked up.
-  def mask(content) pre_mask + list.join(', ') + post_mask end
-
-  # If the chunk is hidden, erase the mask and return this chunk
-  # otherwise, surround it with a 'div' block.
-  def unmask(content)
-    #replacement = ( hidden ? '' : '<div class="property">category:\1</div>' )
-    self if content.sub!( Regexp.new( pre_mask+'(.*)?'+post_mask ) ) {
-      "<div class='property'>category:#{$1.split(',').map { |c| c.strip!; "<a href='../list/?category=#{c}'>#{c}</a> " }}</div>"
-    }
-  end
-end
+require 'chunks/chunk'
+
+# The category chunk looks for "category: news" on a line by
+# itself and parses the terms after the ':' as categories.
+# Other classes can search for Category chunks within
+# rendered content to find out what categories this page
+# should be in.
+#
+# Category lines can be hidden using ':category: news', for example
+class Category < Chunk::Abstract
+  def self.pattern() return /^(:)?category\s*:(.*)$/i end
+
+  attr_reader :hidden, :list
+
+  def initialize(match_data, revision)
+    super(match_data, revision)
+    @hidden = match_data[1]
+    @list = match_data[2].split(',').map { |c| c.strip }
+  end
+
+  # Mark this chunk's start and end points but allow the terms
+  # after the ':' to be marked up.
+  def mask(content) pre_mask + list.join(', ') + post_mask end
+
+  # If the chunk is hidden, erase the mask and return this chunk
+  # otherwise, surround it with a 'div' block.
+  def unmask(content)
+    #replacement = ( hidden ? '' : '<div class="property">category:\1</div>' )
+    self if content.sub!( Regexp.new( pre_mask+'(.*)?'+post_mask ) ) {
+      "<div class='property'>category:#{$1.split(',').map { |c| c.strip!; "<a href='../list/?category=#{c}'>#{c}</a> " }}</div>"
+    }
+  end
+end

data/app/models/chunks/category_test.rb

@@ -1,21 +1,21 @@
-require 'chunks/category'
-require 'chunks/match'
-require 'test/unit'
-
-class CategoryTest < Test::Unit::TestCase
-  include ChunkMatch
-
-  def test_single_category
-	match(Category, 'category: test', :list => ['test'], :hidden => nil)
-	match(Category, 'category :   chunk test   ', :list => ['chunk test'], :hidden => nil)
-	match(Category, ':category: test', :list => ['test'], :hidden => ':')
-  end
-
-  def test_multiple_categories
-	match(Category, 'category: test, multiple', :list => ['test', 'multiple'], :hidden => nil)
-	match(Category, 'category : chunk test , multi category,regression test case  ', 
-		:list => ['chunk test','multi category','regression test case'], :hidden => nil
-	)
-  end
-
-end
+require 'chunks/category'
+require 'chunks/match'
+require 'test/unit'
+
+class CategoryTest < Test::Unit::TestCase
+  include ChunkMatch
+
+  def test_single_category
+	match(Category, 'category: test', :list => ['test'], :hidden => nil)
+	match(Category, 'category :   chunk test   ', :list => ['chunk test'], :hidden => nil)
+	match(Category, ':category: test', :list => ['test'], :hidden => ':')
+  end
+
+  def test_multiple_categories
+	match(Category, 'category: test, multiple', :list => ['test', 'multiple'], :hidden => nil)
+	match(Category, 'category : chunk test , multi category,regression test case  ', 
+		:list => ['chunk test','multi category','regression test case'], :hidden => nil
+	)
+  end
+
+end

data/app/models/chunks/chunk.rb

@@ -1,20 +1,20 @@
-require 'digest/md5'
-require 'uri/common'
-
-# A chunk is a pattern of text that can be protected
-# and interrogated by a renderer. Each Chunk class has a 
-# +pattern+ that states what sort of text it matches.
-# Chunks are initalized by passing in the result of a
-# match by its pattern. 
-module Chunk
-  class Abstract
-	attr_reader :text, :revision
-
-	def initialize(match_data, revision) @text = match_data[0]; @revision = revision end
-	def pre_mask() "chunk#{self.object_id}start " end
-	def post_mask() " chunk#{self.object_id}end" end
-	def mask(content) "chunk#{self.object_id}chunk" end
-	def revert(content) content.sub!( Regexp.new(mask(content)), text ) end
-	def unmask(content) self if revert(content) end
-  end
-end
+require 'digest/md5'
+require 'uri/common'
+
+# A chunk is a pattern of text that can be protected
+# and interrogated by a renderer. Each Chunk class has a 
+# +pattern+ that states what sort of text it matches.
+# Chunks are initalized by passing in the result of a
+# match by its pattern. 
+module Chunk
+  class Abstract
+	attr_reader :text, :revision
+
+	def initialize(match_data, revision) @text = match_data[0]; @revision = revision end
+	def pre_mask() "chunk#{self.object_id}start " end
+	def post_mask() " chunk#{self.object_id}end" end
+	def mask(content) "chunk#{self.object_id}chunk" end
+	def revert(content) content.sub!( Regexp.new(mask(content)), text ) end
+	def unmask(content) self if revert(content) end
+  end
+end

data/app/models/chunks/engines.rb

@@ -1,48 +1,48 @@
-require 'rdocsupport'
-require 'chunks/chunk'
-
-# The markup engines are Chunks that call the one of RedCloth, BlueCloth
-# or RDoc to convert text. This markup occurs when the chunk is required
-# to mask itself.
-module Engines
-  
-  class MarkupEngine < Chunk::Abstract
-    def self.pattern() /^(.*)$/m end
-    def unmask(content) self end
-  end
-  
-  class Textile < MarkupEngine
-    def mask(content)
-      rc = RedCloth.new(text,content.options[:engine_opts])
-      rc.rules = [:textile] if RedCloth::VERSION >= '3.0.0'
-      rc.to_html
-    end
-  end
-
-  class RedMarkdown < MarkupEngine
-    def mask(content)
-      rc = RedCloth.new(text,content.options[:engine_opts])
-      rc.rules = [:markdown]
-      rc.to_html
-    end
-  end
-
-  class BlueMarkdown < MarkupEngine
-    def mask(content)
-      BlueCloth.new(text,content.options[:engine_opts]).to_html
-    end
-  end
-
-  class RDoc < MarkupEngine
-    def mask(content)
-      RDocSupport::RDocFormatter.new(text).to_html
-    end
-  end
-
-  MAP = { :textile => Textile, 
-          :red_markdown => RedMarkdown, 
-          :blue_markdown => BlueMarkdown,
-          :markdown => BlueMarkdown,
-          :rdoc => RDoc }
-end
-
+require 'rdocsupport'
+require 'chunks/chunk'
+
+# The markup engines are Chunks that call the one of RedCloth, BlueCloth
+# or RDoc to convert text. This markup occurs when the chunk is required
+# to mask itself.
+module Engines
+  
+  class MarkupEngine < Chunk::Abstract
+    def self.pattern() /^(.*)$/m end
+    def unmask(content) self end
+  end
+  
+  class Textile < MarkupEngine
+    def mask(content)
+      rc = RedCloth.new(text,content.options[:engine_opts])
+      rc.rules = [:textile] if RedCloth::VERSION >= '3.0.0'
+      rc.to_html
+    end
+  end
+
+  class RedMarkdown < MarkupEngine
+    def mask(content)
+      rc = RedCloth.new(text,content.options[:engine_opts])
+      rc.rules = [:markdown]
+      rc.to_html
+    end
+  end
+
+  class BlueMarkdown < MarkupEngine
+    def mask(content)
+      BlueCloth.new(text,content.options[:engine_opts]).to_html
+    end
+  end
+
+  class RDoc < MarkupEngine
+    def mask(content)
+      RDocSupport::RDocFormatter.new(text).to_html
+    end
+  end
+
+  MAP = { :textile => Textile, 
+          :red_markdown => RedMarkdown, 
+          :blue_markdown => BlueMarkdown,
+          :markdown => BlueMarkdown,
+          :rdoc => RDoc }
+end
+

data/app/models/chunks/include.rb

@@ -7,7 +7,7 @@ require 'chunks/wiki'
 # of changes to that page.
 # If the included page could not be found, a warning is displayed.
 class Include < WikiChunk::WikiLink
-  def self.pattern() /^\[\[!include(.*)\]\]\s*$/i end
+  def self.pattern() /^\s*\[\[!include([^\]]*)\]\]\s*$/i end
 
   attr_reader :page_name
 

data/app/models/chunks/match.rb

@@ -8,7 +8,7 @@ module ChunkMatch
 	pattern = type.pattern
     assert_match(pattern, test_text)
     pattern =~ test_text   # Previous assertion guarantees match
-    chunk = type.new($~)
+    chunk = type.new($~, nil)
     
     # Test if requested parts are correct.
     for method_sym, value in expected do

data/app/models/chunks/nowiki.rb

@@ -15,7 +15,7 @@ require 'chunks/chunk'
 # Created: 8th June 2004
 class NoWiki < Chunk::Abstract
 
-  def self.pattern() Regexp.new('<nowiki>(.*?)</nowiki>') end
+  def self.pattern() Regexp.new('<nowiki>(.*?)</nowiki>', Regexp::MULTILINE) end
 
   attr_reader :plain_text
 

data/app/models/chunks/nowiki_test.rb

@@ -9,6 +9,11 @@ class NoWikiTest < Test::Unit::TestCase
 	match(NoWiki, 'This sentence contains <nowiki>[[raw text]]</nowiki>. Do not touch!',
 		:plain_text => '[[raw text]]'
 	)
+	match(NoWiki, 'This sentence contains <nowiki>
+                  MultiLine [[raw text]]
+                  </nowiki>. Do not touch!',
+		:plain_text => "\n                  MultiLine [[raw text]]\n                  "
+	)
   end
 
 end

data/app/models/chunks/todo.rb

@@ -12,6 +12,7 @@ class Todo < Chunk::Abstract
     super(match_data, revision)
     @context = match_data[1]
     @context = @context.nil? || @context.empty? ? [] : @context.delete('@').split(',')
+    @context += revision.page.categories
     @text = match_data[2]
     begin
       d = ParseDate.parsedate(@text)

data/app/models/chunks/wiki.rb

@@ -1,130 +1,130 @@
-require 'wiki_words'
-require 'chunks/chunk'
-require 'cgi'
-
-# Contains all the methods for finding and replacing wiki related
-# links.
-module WikiChunk
-  include Chunk
-
-  # A wiki link is the top-level class for anything that refers to
-  # another wiki page.
-  class WikiLink < Chunk::Abstract
-    # By default, no escaped text
-    def escaped_text() nil end
-
-    # Delimit the link text with markers to replace later unless
-    # the word is escaped. In that case, just return the link text
-    def mask(content) escaped_text || pre_mask + link_text + post_mask end
-
-    def regexp() Regexp.new(pre_mask + '(.*)?' + post_mask) end
-
-    def revert(content) content.sub!(regexp, text) end
-
-    # Do not keep this chunk if it is escaped.
-    # Otherwise, pass the link procedure a page_name and link_text and
-    # get back a string of HTML to replace the mask with.
-    def unmask(content)
-      return nil if escaped_text
-      return self if content.sub!(regexp) { |match| content.page_link(page_name, $1) }
-    end
-  end
-
-  # This chunk matches a WikiWord. WikiWords can be escaped
-  # by prepending a '\'. When this is the case, the +escaped_text+
-  # method will return the WikiWord instead of the usual +nil+.
-  # The +page_name+ method returns the matched WikiWord.
-  class Word < WikiLink
-    def self.pattern
-      Regexp.new('(\\\\)?(' + WikiWords::WIKI_WORD_PATTERN + ')(</a>)?', 0, "utf-8")
-    end # (chunk\d+chunk)?
-
-    attr_reader :page_name
-
-    def initialize(match_data, revision)
-      super(match_data, revision)
-      @escaped = match_data[1] || match_data[3]
-      @text.delete! '\\' if @escaped
-      @page_name = @link_text = match_data[2]
-    end
-
-    def mask(content) pre_mask + post_mask; end
-    def regexp() Regexp.new(pre_mask + post_mask) end
-    def escaped_text() (@escaped.nil? ? nil : page_name) end
-    def link_text() WikiWords.separate(page_name) end	
-  end
-
-  # This chunk handles [[bracketted wiki words]] and 
-  # [[AliasedWords|aliased wiki words]]. The first part of an
-  # aliased wiki word must be a WikiWord. If the WikiWord
-  # is aliased, the +link_text+ field will contain the
-  # alias, otherwise +link_text+ will contain the entire
-  # contents within the double brackets.
-  #
-  # NOTE: This chunk must be tested before WikiWord since
-  #       a WikiWords can be a substring of a WikiLink. 
-  class Link < WikiLink
-    def self.pattern() /\[\[([^\]]+)\]\]/ end
-    ALIASED_LINK_PATTERN= Regexp.new('^(.*)?\|(.*)$', 0, "utf-8")
-
-    attr_reader :page_name, :link_text
-
-    def initialize(match_data, revision)
-      super(match_data, revision)
-
-      # If the like is aliased, set the page name to the first bit
-      # and the link text to the second, otherwise set both to the
-      # contents of the double brackets.
-      if match_data[1] =~ ALIASED_LINK_PATTERN
-        @page_name, @link_text = $1, $2
-      else
-        @page_name, @link_text = match_data[1], match_data[1]
-      end
-      
-      @link_text = WikiWords.separate(@link_text) if @link_text.match /^#{WikiWords::WIKI_WORD_PATTERN}$/
-    end
-  end
-
-  # This chunk handles [bliki[entry name]].
-  # This format has been extended for some other pre-configured redirection.
-  # Probably a bad name now, as we're using this for any link outside the current
-  # web, but if I change the class name it'll break existing storages.
-  class BlikiLink < WikiLink
-    def self.pattern() /\[(\w+)\[([\w\d\s]+)\]\]/ end
-
-    attr_reader :page_name, :link_text, :entry
-  
-    def initialize(match_data, revision)
-      super(match_data, revision)
-      @target, @page_name, @link_text = match_data[1], match_data[2], match_data[2]
-    end
-
-    def mask(content) pre_mask + post_mask end
-
-    def unmask(content)
-      return self if content.sub!(regexp) { |match|
-        case @target
-        when 'bliki'
-          web = revision.page.web
-          entry = web.bliki[page_name]
-          if entry.nil?
-            #"<span style='background:lightgrey;font-style:italic'>Unknown Bliki entry: '#{page_name}'</span>"
-            "<a class='newWikiWord' href='/#{web.address}/bliki_new/?entry_name=#{CGI::escape page_name}'>Bliki::#{page_name}</a>"
-          else
-            "<a class='existingWikiWord' href='/#{web.address}/bliki_revision/#{entry.name}?rev=#{entry.revisions.size-1}'>Bliki::#{entry.name}</a>"
-          end
-          
-        when 'c2'
-          "<a href='http://c2.com/cgi/wiki?#{@page_name}'>C2::#{@page_name}</a>"
-          
-        else
-          if web = WikiService.instance.webs[@target]
-            "<a href='/#{web.address}@/show/#@page_name'>#{web.name}::#@page_name</a>"
-          else
-            "<i>#@text</i>"
-          end
-        end
-      }
-    end
-  end
-end
+require 'wiki_words'
+require 'chunks/chunk'
+require 'cgi'
+
+# Contains all the methods for finding and replacing wiki related
+# links.
+module WikiChunk
+  include Chunk
+
+  # A wiki link is the top-level class for anything that refers to
+  # another wiki page.
+  class WikiLink < Chunk::Abstract
+    # By default, no escaped text
+    def escaped_text() nil end
+
+    # Delimit the link text with markers to replace later unless
+    # the word is escaped. In that case, just return the link text
+    def mask(content) escaped_text || pre_mask + link_text + post_mask end
+
+    def regexp() Regexp.new(pre_mask + '(.*)?' + post_mask) end
+
+    def revert(content) content.sub!(regexp, text) end
+
+    # Do not keep this chunk if it is escaped.
+    # Otherwise, pass the link procedure a page_name and link_text and
+    # get back a string of HTML to replace the mask with.
+    def unmask(content)
+      return nil if escaped_text
+      return self if content.sub!(regexp) { |match| content.page_link(page_name, $1) }
+    end
+  end
+
+  # This chunk matches a WikiWord. WikiWords can be escaped
+  # by prepending a '\'. When this is the case, the +escaped_text+
+  # method will return the WikiWord instead of the usual +nil+.
+  # The +page_name+ method returns the matched WikiWord.
+  class Word < WikiLink
+    def self.pattern
+      Regexp.new('(\\\\)?(' + WikiWords::WIKI_WORD_PATTERN + ')(</a>)?', 0, "utf-8")
+    end # (chunk\d+chunk)?
+
+    attr_reader :page_name
+
+    def initialize(match_data, revision)
+      super(match_data, revision)
+      @escaped = match_data[1] || match_data[3]
+      @text.delete! '\\' if @escaped
+      @page_name = @link_text = match_data[2]
+    end
+
+    def mask(content) pre_mask + post_mask; end
+    def regexp() Regexp.new(pre_mask + post_mask) end
+    def escaped_text() (@escaped.nil? ? nil : page_name) end
+    def link_text() WikiWords.separate(page_name) end	
+  end
+
+  # This chunk handles [[bracketted wiki words]] and 
+  # [[AliasedWords|aliased wiki words]]. The first part of an
+  # aliased wiki word must be a WikiWord. If the WikiWord
+  # is aliased, the +link_text+ field will contain the
+  # alias, otherwise +link_text+ will contain the entire
+  # contents within the double brackets.
+  #
+  # NOTE: This chunk must be tested before WikiWord since
+  #       a WikiWords can be a substring of a WikiLink. 
+  class Link < WikiLink
+    def self.pattern() /\[\[([^\]]+)\]\]/ end
+    ALIASED_LINK_PATTERN= Regexp.new('^(.*)?\|(.*)$', 0, "utf-8")
+
+    attr_reader :page_name, :link_text
+
+    def initialize(match_data, revision)
+      super(match_data, revision)
+
+      # If the like is aliased, set the page name to the first bit
+      # and the link text to the second, otherwise set both to the
+      # contents of the double brackets.
+      if match_data[1] =~ ALIASED_LINK_PATTERN
+        @page_name, @link_text = $1, $2
+      else
+        @page_name, @link_text = match_data[1], match_data[1]
+      end
+      
+      @link_text = WikiWords.separate(@link_text) if @link_text.match /^#{WikiWords::WIKI_WORD_PATTERN}$/
+    end
+  end
+
+  # This chunk handles [bliki[entry name]].
+  # This format has been extended for some other pre-configured redirection.
+  # Probably a bad name now, as we're using this for any link outside the current
+  # web, but if I change the class name it'll break existing storages.
+  class BlikiLink < WikiLink
+    def self.pattern() /\[(\w+)\[([\w\d\s]+)\]\]/ end
+
+    attr_reader :page_name, :link_text, :entry
+  
+    def initialize(match_data, revision)
+      super(match_data, revision)
+      @target, @page_name, @link_text = match_data[1], match_data[2], match_data[2]
+    end
+
+    def mask(content) pre_mask + post_mask end
+
+    def unmask(content)
+      return self if content.sub!(regexp) { |match|
+        case @target
+        when 'bliki'
+          web = revision.page.web
+          entry = web.bliki[page_name]
+          if entry.nil?
+            #"<span style='background:lightgrey;font-style:italic'>Unknown Bliki entry: '#{page_name}'</span>"
+            "<a class='newWikiWord' href='/#{web.address}/bliki_new/?entry_name=#{CGI::escape page_name}'>Bliki::#{page_name}</a>"
+          else
+            "<a class='existingWikiWord' href='/#{web.address}/bliki_revision/#{entry.name}?rev=#{entry.revisions.size-1}'>Bliki::#{entry.name}</a>"
+          end
+          
+        when 'c2'
+          "<a href='http://c2.com/cgi/wiki?#{@page_name}'>C2::#{@page_name}</a>"
+          
+        else
+          if web = WikiService.instance.webs[@target]
+            "<a href='/#{web.address}/show/#@page_name'>#{web.name}::#@page_name</a>"
+          else
+            "<i>#@text</i>"
+          end
+        end
+      }
+    end
+  end
+end