instiki 0.9.2 → 0.10.0

data/{libraries/view_helper.rb → app/helpers/application_helper.rb}

@@ -1,33 +1,68 @@
-module ViewHelper
-  # Accepts a container (hash, array, enumerable, your type) and returns a string of option tags. Given a container 
-  # where the elements respond to first and last (such as a two-element array), the "lasts" serve as option values and
-  # the "firsts" as option text. Hashes are turned into this form automatically, so the keys become "firsts" and values
-  # become lasts. If +selected+ is specified, the matching "last" or element will get the selected option-tag.
-  #
-  # Examples (call, result):
-  #   html_options([["Dollar", "$"], ["Kroner", "DKK"]])
-  #     <option value="$">Dollar</option>\n<option value="DKK">Kroner</option>
-  #
-  #   html_options([ "VISA", "Mastercard" ], "Mastercard")
-  #     <option>VISA</option>\n<option selected>Mastercard</option>
-  #
-  #   html_options({ "Basic" => "$20", "Plus" => "$40" }, "$40")
-  #     <option value="$20">Basic</option>\n<option value="$40" selected>Plus</option>
-  def html_options(container, selected = nil)
-    container = container.to_a if Hash === container
-  
-    html_options = container.inject([]) do |options, element| 
-      if element.respond_to?(:first) && element.respond_to?(:last)
-        if element.last != selected
-          options << "<option value=\"#{element.last}\">#{element.first}</option>"
-        else
-          options << "<option value=\"#{element.last}\" selected>#{element.first}</option>"
-        end
-      else
-        options << ((element != selected) ? "<option>#{element}</option>" : "<option selected>#{element}</option>")
-      end
-    end
-    
-    html_options.join("\n")
-  end
-end
+# The methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+
+  # Accepts a container (hash, array, enumerable, your type) and returns a string of option tags. Given a container 
+  # where the elements respond to first and last (such as a two-element array), the "lasts" serve as option values and
+  # the "firsts" as option text. Hashes are turned into this form automatically, so the keys become "firsts" and values
+  # become lasts. If +selected+ is specified, the matching "last" or element will get the selected option-tag.
+  #
+  # Examples (call, result):
+  #   html_options([["Dollar", "$"], ["Kroner", "DKK"]])
+  #     <option value="$">Dollar</option>\n<option value="DKK">Kroner</option>
+  #
+  #   html_options([ "VISA", "Mastercard" ], "Mastercard")
+  #     <option>VISA</option>\n<option selected>Mastercard</option>
+  #
+  #   html_options({ "Basic" => "$20", "Plus" => "$40" }, "$40")
+  #     <option value="$20">Basic</option>\n<option value="$40" selected>Plus</option>
+  def html_options(container, selected = nil)
+    container = container.to_a if Hash === container
+  
+    html_options = container.inject([]) do |options, element| 
+      if element.respond_to?(:first) && element.respond_to?(:last)
+        if element.last != selected
+          options << "<option value=\"#{element.last}\">#{element.first}</option>"
+        else
+          options << "<option value=\"#{element.last}\" selected>#{element.first}</option>"
+        end
+      else
+        options << ((element != selected) ? "<option>#{element}</option>" : "<option selected>#{element}</option>")
+      end
+    end
+    
+    html_options.join("\n")
+  end
+
+  # Creates a hyperlink to a Wiki page, without checking if the page exists or not
+  def link_to_existing_page(page, text = nil, html_options = {})
+    link_to(
+        text || page.name, 
+        {:web => @web.address, :action => 'show', :id => page.name, :only_path => true},
+        html_options)
+  end
+  
+  
+  # Creates a hyperlink to a Wiki page, or to a "new page" form if the page doesn't exist yet
+  def link_to_page(page_name, web = @web, text = nil, options = {})
+    raise 'Web not defined' if web.nil?
+    home_page_url = url_for :web => web.address, :action => 'show', :id => 'HomePage', :only_path => true
+    base_url = home_page_url.sub(%r-/show/HomePage/?$-, '')
+    web.make_link(page_name, text, options.merge(:base_url => base_url))
+  end
+
+  # Creates a menu of categories
+  def categories_menu
+    if @categories.empty?
+      ''
+    else 
+      "<div id=\"categories\">\n" +
+      '<strong>Categories</strong>:' +
+      '[' + link_to_unless_current('Any', :web => @web.address, :action => @action_name) + "]\n" +
+      @categories.map { |c| 
+        link_to_unless_current(c, :web => @web.address, :action => @action_name, :category => c)
+      }.join(', ') + "\n" +
+      '</div>'
+    end
+  end
+
+end

data/app/models/author.rb

@@ -1,4 +1,4 @@
-class Author < String
-  attr_accessor :ip
-  def initialize(name, ip) @ip = ip; super(name) end
+class Author < String
+  attr_accessor :ip
+  def initialize(name, ip) @ip = ip; super(name) end
 end

data/app/models/chunks/category.rb

@@ -1,31 +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)
-    super(match_data)
-	@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 ), replacement )
-  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
+  CATEGORY_PATTERN = /^(:)?category\s*:(.*)$/i
+  def self.pattern() CATEGORY_PATTERN  end
+
+  attr_reader :hidden, :list
+
+def initialize(match_data, content)
+    super(match_data, content)
+    @hidden = match_data[1]
+    @list = match_data[2].split(',').map { |c| c.strip }
+    @unmask_text = ''
+    if @hidden
+      @unmask_text = ''
+    else
+      category_urls = @list.map { |category| url(category) }.join(', ')
+      @unmask_text = '<div class="property"> category: ' + category_urls + '</div>'
+    end
+  end
+
+  # TODO move presentation of page metadata to controller/view
+  def url(category)
+    %{<a class="category_link" href="../list/?category=#{category}">#{category}</a>}
+  end
+end

data/app/models/chunks/chunk.rb

@@ -1,20 +1,86 @@
-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
-
-	def initialize(match_data) @text = match_data[0] 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 '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
+
+    # automatically construct the array of derivatives of Chunk::Abstract
+    @derivatives = [] 
+
+    class << self 
+      attr_reader :derivatives 
+    end 
+    
+    def self::inherited( klass ) 
+      Abstract::derivatives << klass 
+    end 
+    
+    # the class name part of the mask strings
+    def self.mask_string
+      self.to_s.delete(':').downcase
+    end
+
+    # a regexp that matches all chunk_types masks
+    def Abstract::mask_re(chunk_types)
+      tmp = chunk_types.map{|klass| klass.mask_string}.join("|")
+      Regexp.new("chunk([0-9a-f]+n\\d+)(#{tmp})chunk")
+    end
+    
+    attr_reader :text, :unmask_text, :unmask_mode
+
+    def initialize(match_data, content) 
+      @text = match_data[0] 
+      @content = content
+      @unmask_mode = :normal
+    end
+
+    # Find all the chunks of the given type in content
+    # Each time the pattern is matched, create a new
+    # chunk for it, and replace the occurance of the chunk
+    # in this content with its mask.
+	def self.apply_to(content)
+	  content.gsub!( self.pattern ) do |match|	
+        new_chunk = self.new($~, content)
+        content.add_chunk(new_chunk)
+        new_chunk.mask
+      end
+    end
+
+    # should contain only [a-z0-9]
+    def mask
+      @mask ||="chunk#{@id}#{self.class.mask_string}chunk"
+    end
+
+    # We should not use object_id because object_id is not guarantied 
+    # to be unique when we restart the wiki (new object ids can equal old ones
+    # that were restored form madeleine storage)  
+    def id
+      @id ||= "#{@content.page_id}n#{@content.chunk_id}"
+    end
+
+    def unmask
+      @content.sub!(mask, @unmask_text)
+    end
+
+    def rendered?
+      @unmask_mode == :normal
+    end
+
+    def escaped?
+      @unmask_mode == :escape
+    end
+
+    def revert
+      @content.sub!(mask, @text)
+      # unregister
+      @content.delete_chunk(self)
+    end
+
+  end
+
+end

data/app/models/chunks/engines.rb

@@ -1,38 +1,54 @@
-$: << File.dirname(__FILE__) + "../../libraries"
-
-require 'redcloth'
-require 'bluecloth'
-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 Textile < Chunk::Abstract
-    def self.pattern() /^(.*)$/m end
-    def mask(content)
-      RedCloth.new(text,content.options[:engine_opts]).to_html
-    end
-    def unmask(content) self end
-  end
-
-  class Markdown < Chunk::Abstract
-    def self.pattern() /^(.*)$/m end
-    def mask(content)
-      BlueCloth.new(text,content.options[:engine_opts]).to_html
-    end
-    def unmask(content) self end
-  end
-
-  class RDoc < Chunk::Abstract
-    def self.pattern() /^(.*)$/m end
-    def mask(content)
-      RDocSupport::RDocFormatter.new(text).to_html
-    end
-    def unmask(content) self end
-  end
-
-  MAP = { :textile => Textile, :markdown => Markdown, :rdoc => RDoc }
-end
-
+$: << File.dirname(__FILE__) + "../../lib"
+
+require 'redcloth'
+require 'rdocsupport'
+require 'chunks/chunk'
+
+# The markup engines are Chunks that call the one of RedCloth
+# or RDoc to convert text. This markup occurs when the chunk is required
+# to mask itself.
+module Engines
+  class AbstractEngine < Chunk::Abstract
+
+    # Create a new chunk for the whole content and replace it with its mask.
+    def self.apply_to(content)
+      new_chunk = self.new(content)
+      content.replace(new_chunk.mask)
+    end
+
+    private 
+
+    # Never create engines by constructor - use apply_to instead
+    def initialize(content) 
+      @content = content
+    end
+
+  end
+
+  class Textile < AbstractEngine
+    def mask
+      RedCloth.new(@content, @content.options[:engine_opts]).to_html(:textile)
+    end
+  end
+
+  class Markdown < AbstractEngine
+    def mask
+      RedCloth.new(@content, @content.options[:engine_opts]).to_html(:markdown)
+    end
+  end
+
+  class Mixed < AbstractEngine
+    def mask
+      RedCloth.new(@content, @content.options[:engine_opts]).to_html
+    end
+  end
+
+  class RDoc < AbstractEngine
+    def mask
+      RDocSupport::RDocFormatter.new(@content).to_html
+    end
+  end
+
+  MAP = { :textile => Textile, :markdown => Markdown, :mixed => Mixed, :rdoc => RDoc,  }
+  MAP.default = Textile
+end

data/app/models/chunks/include.rb

@@ -1,29 +1,41 @@
-require 'chunks/wiki'
-
-# Includes the contents of another page for rendering.
-# The include command looks like this: "[[!include PageName]]".
-# It is a WikiLink since it refers to another page (PageName)
-# and the wiki content using this command must be notified
-# 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
-
-  attr_reader :page_name
-
-  def initialize(match_data)
-    super(match_data)
-    @page_name = match_data[1].strip
-  end
-
-  # This replaces the [[!include PageName]] text with
-  # the contents of PageName if it exists. Otherwise
-  # a warning is displayed.
-  def mask(content) 
-    page = content.web.pages[page_name]
-    (page ? page.content : "<em>Could not include #{page_name}</em>")
-  end
-
-  # Keep this chunk regardless of what happens.
-  def unmask(content) self end
-end
+require 'chunks/wiki'
+
+# Includes the contents of another page for rendering.
+# The include command looks like this: "[[!include PageName]]".
+# It is a WikiReference since it refers to another page (PageName)
+# and the wiki content using this command must be notified
+# of changes to that page.
+# If the included page could not be found, a warning is displayed.
+
+class Include < WikiChunk::WikiReference
+
+  INCLUDE_PATTERN = /\[\[!include(.*)\]\]\s*/i
+  def self.pattern() INCLUDE_PATTERN end
+
+
+  def initialize(match_data, content)
+    super
+    @page_name = match_data[1].strip
+    @unmask_text = get_unmask_text_avoiding_recursion_loops
+  end
+
+  private
+  
+  def get_unmask_text_avoiding_recursion_loops
+    if refpage then
+      if refpage.wiki_includes.include?(@content.page_name)
+        # this will break the recursion
+        @content.delete_chunk(self)
+        refpage.clear_display_cache
+        return "<em>Recursive include detected; #{@page_name} --> #{@content.page_name} " + 
+               "--> #{@page_name}</em>\n"
+      else
+        @content.merge_chunks(refpage.display_content)
+        return refpage.display_content.pre_rendered 
+      end
+    else
+      return "<em>Could not include #{@page_name}</em>\n"
+    end
+  end
+
+end

data/app/models/chunks/literal.rb

@@ -1,19 +1,31 @@
-require 'chunks/chunk'
-
-# These are basic chunks that have a pattern and can be protected.
-# They are used by rendering process to prevent wiki rendering
-# occuring within literal areas such as <code> and <pre> blocks
-# and within HTML tags.
-module Literal
-  # A literal chunk that protects 'code' and 'pre' tags from wiki rendering.
-  class Pre < Chunk::Abstract
-    PRE_BLOCKS = "a|pre|code"
-    def self.pattern() Regexp.new('<('+PRE_BLOCKS+')\b[^>]*?>.*?</\1>', Regexp::MULTILINE) end
-  end 
-
-  # A literal chunk that protects HTML tags from wiki rendering.
-  class Tags < Chunk::Abstract
-    TAGS = "a|img|em|strong|div|span|table|td|th|ul|ol|li|dl|dt|dd"
-    def self.pattern() Regexp.new('<(?:'+TAGS+')[^>]*?>', Regexp::MULTILINE) end
-  end
-end
+require 'chunks/chunk'
+
+# These are basic chunks that have a pattern and can be protected.
+# They are used by rendering process to prevent wiki rendering
+# occuring within literal areas such as <code> and <pre> blocks
+# and within HTML tags.
+module Literal
+
+  class AbstractLiteral < Chunk::Abstract
+
+    def initialize(match_data, content)
+      super
+      @unmask_text = @text
+    end
+
+  end
+
+  # A literal chunk that protects 'code' and 'pre' tags from wiki rendering.
+  class Pre < AbstractLiteral
+    PRE_BLOCKS = "a|pre|code"
+    PRE_PATTERN = Regexp.new('<('+PRE_BLOCKS+')\b[^>]*?>.*?</\1>', Regexp::MULTILINE)
+    def self.pattern() PRE_PATTERN end
+  end 
+
+  # A literal chunk that protects HTML tags from wiki rendering.
+  class Tags < AbstractLiteral
+    TAGS = "a|img|em|strong|div|span|table|td|th|ul|ol|li|dl|dt|dd"
+    TAGS_PATTERN = Regexp.new('<(?:'+TAGS+')[^>]*?>', Regexp::MULTILINE) 
+    def self.pattern() TAGS_PATTERN  end
+  end
+end