instiki 0.10.0 → 0.10.1

data/app/helpers/application_helper.rb

@@ -1,68 +1,68 @@
-# 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
+# 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,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
-  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
+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,86 +1,86 @@
-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
+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,54 +1,61 @@
-$: << 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
+$: << File.dirname(__FILE__) + "../../lib"
+
+require 'redcloth'
+require 'bluecloth_tweaked'
+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 = RedCloth.new(@content, [:hard_breaks] + @content.options[:engine_opts])
+      redcloth.filter_html = false
+      redcloth.no_span_caps = false  
+      redcloth.to_html(:textile)
+    end
+  end
+
+  class Markdown < AbstractEngine
+    def mask
+      BlueCloth.new(@content, @content.options[:engine_opts]).to_html
+    end
+  end
+
+  class Mixed < AbstractEngine
+    def mask
+      redcloth = RedCloth.new(@content, @content.options[:engine_opts])
+      redcloth.filter_html = false
+      redcloth.no_span_caps = false
+      redcloth.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