olelo 0.9.0

data/plugins/editor/markup/script/init.js

@@ -0,0 +1,10 @@
+if (window.Olelo) {
+    var mime = Olelo.page_mime;
+    if (mime == 'application/x-empty' || mime == 'inode/directory') {
+        mime = Olelo.default_mime;
+    }
+    var match = /text\/x-(\w+)/.exec(mime);
+    if (match) {
+	$('#edit-content').markupEditor(match[1]);
+    }
+}

data/plugins/editor/preview.rb

@@ -0,0 +1,52 @@
+description  'Enhance editor form with preview and diff'
+dependencies 'aspects'
+
+class ::Olelo::Application
+  before :edit_buttons, 1000 do
+    %{<button data-target="enhanced-edit" type="submit" name="action" value="preview" accesskey="p">#{:preview.t}</button>
+      <button data-target="enhanced-edit" type="submit" name="action" value="changes" accesskey="c">#{:changes.t}</button>}
+  end
+
+  after :edit_buttons do
+    %{<div id="enhanced-edit">#{flash[:preview] || flash[:changes]}</div>}
+  end
+
+  def post_preview
+    raise 'No content' if !params[:content]
+    params[:content].gsub!("\r\n", "\n")
+
+    if page.new? || !params[:pos]
+      # Whole page edited, assign new content before aspect search
+      page.content = params[:content]
+      aspect = Aspects::Aspect.find(page, :layout => true)
+    else
+      # We assume that aspect stays the same if section is edited
+      aspect = Aspects::Aspect.find(page, :layout => true)
+      page.content = params[:content]
+    end
+    context = Aspects::Context.new(:page => page, :request => request, :private => {:preview => true})
+    preview = aspect && aspect.call(context, page)
+    flash.now[:preview] = preview ? %{<hr/>#{preview}} : nil
+    halt render(request.xhr? ? flash.now[:preview] : :edit)
+  end
+
+  def post_changes
+    raise 'No content' if !params[:content]
+    params[:content].gsub!("\r\n", "\n")
+
+    original = Tempfile.new('original')
+    original.write(params[:pos] ? page.content[params[:pos].to_i, params[:len].to_i] : page.content)
+    original.close
+
+    new = Tempfile.new('new')
+    new.write(params[:content].to_s)
+    new.close
+
+    # Read in binary mode and fix encoding afterwards
+    patch = IO.popen("diff -u '#{original.path}' '#{new.path}'", 'rb') {|io| io.read }
+    patch.force_encoding(Encoding.default_external)
+    changes = PatchParser.parse(patch, PatchFormatter.new).html
+    flash.now[:changes] = changes.blank? ? %{<div class="flash">#{:no_changes.t}</div>} : changes
+    halt render(request.xhr? ? flash.now[:changes] : :edit)
+  end
+end

data/plugins/editor/recaptcha.rb

@@ -0,0 +1,56 @@
+description 'reCAPTCHA support to avoid spamming'
+require 'net/http'
+
+RECAPTCHA_PUBLIC = Config['recaptcha.public']
+RECAPTCHA_PRIVATE = Config['recaptcha.private']
+
+class ::Olelo::Application
+  before :edit_buttons do
+    %{<br/><label for="recaptcha">#{:captcha.t}</label><br/><div id="recaptcha"></div><br/>} if flash[:show_captcha]
+  end
+
+  hook :script do
+    %{<script type="text/javascript" src="http://www.google.com/recaptcha/api/js/recaptcha_ajax.js"/>
+<script type="text/javascript">
+  $(function() {
+    Recaptcha.create('#{RECAPTCHA_PUBLIC}',
+      'recaptcha', {
+        theme: 'clean',
+        callback: Recaptcha.focus_response_field
+    });
+  });
+</script>} if flash[:show_captcha]
+  end
+
+  redefine_method :post_edit do
+    if captcha_valid?
+      super()
+    else
+      flash.info! :enter_captcha.t
+      flash.now[:show_captcha] = true
+      halt render(:edit)
+    end
+  end
+
+  private
+
+  def captcha_valid?
+    if Time.now.to_i < session[:olelo_recaptcha_timeout].to_i
+      true
+    elsif params[:recaptcha_challenge_field] && params[:recaptcha_response_field]
+      response = Net::HTTP.post_form(URI.parse('http://api-verify.recaptcha.net/verify'),
+                                     'privatekey' => RECAPTCHA_PRIVATE,
+                                     'remoteip'   => request.ip,
+                                     'challenge'  => params[:recaptcha_challenge_field],
+                                     'response'   => params[:recaptcha_response_field])
+      if response.body.split("\n").first == 'true'
+        session[:olelo_recaptcha_timeout] = Time.now.to_i + 3600
+        flash.info! :captcha_valid.t
+        true
+      else
+        flash.error! :captcha_invalid.t
+        false
+      end
+    end
+  end
+end

data/plugins/filters/creole.rb

@@ -0,0 +1,37 @@
+description  'Creole wiki text filter'
+require 'creole'
+
+class OleloCreole < ::Creole::Parser
+  include PageHelper
+  include Util
+
+  def make_image(path, title)
+    args = title.to_s.split('|')
+    image_path = path.dup
+    if path !~ %r{^(\w+)://}
+      geometry = args.grep(/(\d+x)|(x\d+)|(\d+%)/).first
+      image_path += (path.include?('?') ? '&' : '?') + 'aspect=image'
+      if geometry
+        args.delete(geometry)
+        image_path += "&geometry=#{geometry}"
+      end
+    end
+    image_path = escape_html(image_path)
+    path = escape_html(path)
+    nolink = args.delete('nolink')
+    box = args.delete('box')
+    alt = escape_html(args[0] ? args[0] : path)
+    if nolink
+      %{<img src="#{image_path}" alt="#{alt}"/>}
+    elsif box
+      caption = args[0] ? %{<span class="caption">#{escape_html args[0]}</span>} : ''
+      %{<span class="img"><a href="#{path}"><img src="#{image_path}" alt="#{alt}"/>#{caption}</a></span>}
+    else
+      %{<a href="#{path}" class="img"><img src="#{image_path}" alt="#{alt}"/></a>}
+    end
+  end
+end
+
+Filter.create :creole do |context, content|
+  OleloCreole.new(content, :extensions => true, :no_escape => true).to_html
+end

data/plugins/filters/disposition.rb

@@ -0,0 +1,9 @@
+description 'Filter which sets Content-Disposition'
+
+Filter.create :disposition do |context, content|
+  name = context.page.root? ? :root.t : context.page.name.gsub(/[^\w.\-_]/, '_')
+  name += '.' + options[:extension] if options[:extension]
+  context.header['Content-Disposition'] = %{attachment; filename="#{name}"}
+  context.header['Content-Length'] = content.bytesize.to_s
+  content
+end

data/plugins/filters/editsection.rb

@@ -0,0 +1,67 @@
+description 'Adds links for section editing for headlines'
+
+Page.attributes do
+  boolean :no_editsection
+end
+
+class EditSection < Filters::NestingFilter
+  def find_sections_regexp(content, regexp)
+    sections, offset = [], 0
+    while (offset = content.index(regexp, offset))
+      sections.last[1] = offset if sections.last
+      # [Section start, section end, Position to insert edit link, section text]
+      sections << [offset + $2.size, content.length, offset + $1.size, $3.strip]
+      offset += $&.size
+    end
+    sections
+  end
+
+  # Creole/Mediawiki style headlines (e.g. == Headline ==)
+  def find_sections_creole(content)
+    find_sections_regexp(content, /((\A|\s*\n)=+(.*?))=*\s*$/)
+  end
+
+  # ATX/Markdown style headlines (e.g. ## Headline)
+  def find_sections_atx(content)
+    find_sections_regexp(content, /((\A|\s*\n)#+(.*))$/)
+  end
+
+  # Returns section array
+  # [[Section start, section end, Position to insert edit link, section text], ...]
+  def find_sections(mime, content)
+    case mime.to_s
+    when %r{^text/x-(creole|mediawiki)$}
+      find_sections_creole(content)
+    when %r{^text/x-markdown}
+      find_sections_atx(content)
+    else
+      raise "Mime type #{mime} not supported by editsection filter"
+    end
+  end
+
+  def filter(context, content)
+    page = context.page
+    if context[:preview] || !page.head? || page.attributes['no_editsection']
+      subfilter(context, content)
+    else
+      sections = find_sections(context.page.mime, content)
+      offset = 0
+      prefix = "EDIT#{object_id}X"
+      sections.each_with_index do |h,i|
+        link = " #{prefix}#{i} "
+        content.insert(h[2] + offset, link)
+        offset += link.size
+      end
+      content = subfilter(context, content)
+      content.gsub!(/#{prefix}(\d+)/) do
+        i = $1.to_i
+        len = sections[i][1] - sections[i][0]
+        path = build_path(page, :action => :edit, :pos => sections[i][0], :len => len, :comment => :section_edited.t(:section => sections[i][3]))
+        %{<a class="editsection" href="#{escape_html path}" title="#{escape_html :edit_section.t(:section => sections[i][3])}">#{escape_html :edit.t}</a>}
+      end
+      content
+    end
+  end
+end
+
+Filters::Filter.register :editsection, EditSection

data/plugins/filters/fix_img_tag.rb

@@ -0,0 +1,16 @@
+description 'Add query parameter "aspect" to images'
+
+Filter.create :fix_img_tag do |context, content|
+ content.gsub!(/(<img[^>+]src=")([^"]+)"/) do |match|
+    prefix, path = $1, $2
+    if path =~ %r{^w+://} || path.starts_with?(build_path('_')) ||
+        (path.starts_with?('/') && !path.starts_with?(build_path(''))) ||
+        path.include?('aspect=')
+      match
+    else
+      path = unescape_html(path)
+      prefix + escape_html(path + (path.include?('?') ? '&' : '?') + 'aspect=image') + '"'
+    end
+  end
+  content
+end

data/plugins/filters/html_wrapper.rb

@@ -0,0 +1,12 @@
+description 'Wraps fragment into html block to make it valid'
+
+Filter.create :html_wrapper do |context, content|
+  %{<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>#{escape_html context.page.title}</title>
+  </head>
+  <body><div>#{content}</div></body>
+</html>}
+end

data/plugins/filters/interwiki.rb

@@ -0,0 +1,19 @@
+description 'Handle interwiki links'
+
+class Interwiki < Filter
+  def configure(options)
+    super
+    @map = options[:map]
+    @regexp = /href="\/?(#{@map.keys.join('|')}):([^"]+)"/
+  end
+
+  def filter(context, content)
+    content.gsub!(@regexp) do
+      wiki, page = $1, $2
+      %{href="#{escape_html @map[$1]}#{$2}"}
+    end
+    content
+  end
+end
+
+Filter.register :interwiki, Interwiki

data/plugins/filters/link_classifier.rb

@@ -0,0 +1,26 @@
+description  'Classify links as absent/present/external'
+dependencies 'utils/xml'
+
+Filter.create :link_classifier do |context, content|
+  doc = XML::Fragment(content)
+  doc.css('a[href]').each do |link|
+    href =  link['href']
+    classes = [link['class']].compact
+    if href.starts_with?('http://') || href.starts_with?('https://')
+      classes << 'external'
+    elsif !href.empty? && !href.starts_with?('#')
+      path, query = href.split('?')
+      if path.starts_with? Config['base_path']
+        path = path[Config['base_path'].length..-1]
+      elsif !path.starts_with? '/'
+        path = context.page.path/'..'/path
+      end
+      classes << 'internal'
+      if !Application.reserved_path?(path)
+        classes << (Page.find(path, context.page.tree_version) ? 'present' : 'absent') rescue nil
+      end
+    end
+    link['class'] = classes.join(' ') if !classes.empty?
+  end
+  doc.to_xhtml
+end

data/plugins/filters/locale.yml

@@ -0,0 +1,15 @@
+en:
+  attribute_toc: 'Generate Table of Contents'
+  attribute_no_editsection: 'Disable Section Editing'
+  edit_section: 'Edit section "#{section}"'
+  section_edited: 'Section "#{section}" edited'
+de:
+  attribute_toc: 'Inhaltsverzeichnis erzeugen'
+  attribute_no_editsection: 'Bearbeiten von Bereichen deaktivieren'
+  edit_section: 'Bearbeite Bereich "#{section}"'
+  section_edited: 'Bereich "#{section}" bearbeitet'
+cs_CZ:
+  attribute_toc: 'Vytvořit obsah'
+  attribute_no_editsection: 'Zablokovat editaci sekcí'
+  edit_section: 'Edituj sekci "#{section}"'
+  section_edited: 'Sekce "#{section}" editována'

data/plugins/filters/main.rb

@@ -0,0 +1,202 @@
+description 'Filter pipeline aspect'
+dependencies 'aspects'
+
+class MandatoryFilterNotFound < NameError; end
+
+# Filter base class. Multiple filters can be chained
+# to build a filter aspect.
+# A filter can manipulate the text and the aspect context.
+class Filter
+  include PageHelper
+  include Templates
+  extend Factory
+
+  attr_accessor :previous
+  attr_reader :name, :description, :plugin, :options
+
+  # Initialize filter
+  def initialize(name, options = {})
+    @name        = name.to_s
+    @plugin      = options[:plugin] || Plugin.for(self.class)
+    @description = options[:description] || @plugin.description
+  end
+
+  # Configure the filter. Takes an option hash
+  def configure(options)
+    @options = options
+  end
+
+  # Main entry point of a filter
+  # Calls previous filter, creates a duplicate from itself
+  # and calls filter on it.
+  def call(context, content)
+    content = previous ? previous.call(context, content) : content
+    dup.filter(context, content)
+  end
+
+  # Filter the content. Implement this method!
+  def filter(context, content)
+    raise NotImplementedError
+  end
+
+  # Print filter definition. For debugging purposes.
+  def definition
+    previous ? "#{previous.definition} > #{name}" : name
+  end
+
+  # Register a filter class
+  def self.register(name, klass, options = {})
+    super(name, klass.new(name, options))
+  end
+
+  # Create a filter from a given block.
+  def self.create(name, options = {}, &block)
+    options[:plugin] ||= Plugin.for(block)
+    klass = Class.new(self)
+    klass.class_eval { define_method(:filter, &block) }
+    register(name, klass, options)
+  end
+
+  # Create regexp filter
+  def self.regexp(name, *regexps)
+    create(name, :description => 'Regular expression filter') do |context, content|
+      regexps.each_slice(2) { |regexp, sub| content.gsub!(regexp, sub) }
+      content
+    end
+  end
+
+  # Find filter by name
+  def self.find(name, options = {})
+    filter = self[name].dup
+    filter.configure(options.with_indifferent_access)
+    filter
+  end
+end
+
+# Filter which supports subfilters
+class NestingFilter < Filter
+  attr_accessor :sub
+
+  def subfilter(context, content)
+    sub ? sub.call(context, content) : content
+  end
+
+  def definition
+    sub ? "#{super} (#{sub.definition})" : super
+  end
+end
+
+class FilterAspect < Aspects::Aspect
+  def initialize(name, filter, options)
+    super(name, options)
+    @filter = filter
+  end
+
+  def call(context, page)
+    @filter.call(context, page.content.dup)
+  end
+
+  def definition
+    @filter.definition
+  end
+end
+
+# Filter DSL
+class FilterDSL
+  # Build filter class
+  class FilterBuilder
+    def initialize(name, filter = nil)
+      @name, @filter = name, filter
+    end
+
+    # Add optional filter
+    def filter(name, options = {}, &block)
+      add(name, false, options, &block)
+    end
+
+    # Add mandatory filter
+    def filter!(name, options = {}, &block)
+      add(name, true, options, &block)
+    end
+
+    # Add filter with method name.
+    # Mandatory filters must end with !
+    def method_missing(name, options = {}, &block)
+      name = name.to_s
+      name.ends_with?('!') ? filter!(name[0..-2], options, &block) : filter(name, options, &block)
+    end
+
+    def build(&block)
+      instance_eval(&block)
+      @filter
+    end
+
+    private
+
+    def add(name, mandatory, options, &block)
+      filter = Filter.find(name, options) rescue nil
+      if filter
+        filter.previous = @filter
+        @filter = filter
+        if block
+          raise "Filter '#{name}' does not support subfilters" if !(NestingFilter === @filter)
+          @filter.sub = FilterBuilder.new(@name).build(&block)
+        end
+      else
+        if mandatory
+          raise MandatoryFilterNotFound, "Aspect '#{@name}' not created because mandatory filter '#{name}' is not available"
+        else
+          Olelo.logger.warn "Aspect '#{@name}' - Optional filter '#{name}' not available"
+        end
+        @filter = FilterBuilder.new(@name, @filter).build(&block) if block
+      end
+      self
+    end
+  end
+
+  # Build aspect class
+  class AspectBuilder
+    def initialize(name)
+      @name = name
+      @options = {}
+    end
+
+    def build(&block)
+      instance_eval(&block)
+      raise("No filters defined for aspect '#{name}'") if !@filter
+      FilterAspect.new(@name, @filter, @options)
+    end
+
+    def filter(&block)
+      @filter = FilterBuilder.new(@name).build(&block)
+      self
+    end
+
+    def mime(mime);         @options[:mime] = mime;       self; end
+    def accepts(accepts);   @options[:accepts] = accepts; self; end
+    def needs_layout;       @options[:layout] = true;     self; end
+    def has_priority(prio); @options[:priority] = prio;   self; end
+    def is_cacheable;       @options[:cacheable] = true;  self; end
+    def is_hidden;          @options[:hidden] = true;     self; end
+  end
+
+  # Register regexp filter
+  def regexp(name, *regexps)
+    Filter.regexp(name, *regexps)
+  end
+
+  # Register aspect
+  def aspect(name, &block)
+    Aspects::Aspect.register(AspectBuilder.new(name).build(&block))
+    Olelo.logger.debug "Filter aspect '#{name}' successfully created"
+  rescue MandatoryFilterNotFound => ex
+    Olelo.logger.warn ex.message
+  rescue Exception => ex
+    Olelo.logger.error ex
+  end
+end
+
+setup do
+  file = File.join(Config['config_path'], 'aspects.rb')
+  FilterDSL.new.instance_eval(File.read(file), file)
+end