olelo 0.9.0

data/plugins/misc/fancybox/script/init.js

@@ -0,0 +1,18 @@
+(function() {
+    function initFancybox() {
+        $('a.fancybox').each(function() {
+            var href = this.href.replace(/aspect=\w+/g, '');
+            this.href = href + (href.indexOf('?') < 0 ? '?' : '&') + 'aspect=image&geometry=800x800>';
+        });
+        $('a.fancybox').fancybox({
+            'transitionIn'  : 'none',
+            'transitionOut' : 'none',
+            'titlePosition' : 'over',
+            'titleFormat'   : function(title, currentArray, currentIndex, currentOpts) {
+                return '<span id="fancybox-title-over">' + (currentIndex + 1) + ' / ' + currentArray.length + ' ' + (title ? title : '') + '</span>';
+        }});
+    }
+
+    $('#content').bind('pageLoaded', initFancybox);
+    initFancybox();
+})();

data/plugins/misc/system.rb

@@ -0,0 +1,192 @@
+description 'System information'
+
+class ::Olelo::Application
+  get '/system' do
+    GC.start
+    @memory = `ps -o rss= -p #{$$}`.to_i / 1024
+    render :system
+  end
+
+  def check_mark(value)
+    value ? '✓' : ''
+  end
+end
+
+__END__
+@@ system.slim
+- title 'System Information'
+h1 System Information
+ul.tabs
+  li#tabhead-runtime
+    a href="#tab-runtime" Runtime
+  li#tabhead-configuration
+    a href="#tab-configuration" Configuration
+  li#tabhead-plugins
+    a href="#tab-plugins" Plugins
+  - if defined?(Olelo::Plugin::Aspects::Aspect)
+    li#tabhead-aspects
+      a href="#tab-aspects" Aspects
+  - if defined?(Olelo::Plugin::Filters::Filter)
+    li#tabhead-filters
+      a href="#tab-filters" Filters
+  - if defined?(Olelo::Plugin::Tags::Tag)
+    li#tabhead-tags
+      a href="#tab-tags" Tags
+#tab-runtime.tab
+  h2 Runtime
+  table
+    tr
+      td Ōlelo version:
+      td= Olelo::VERSION
+    tr
+      td Ruby version:
+      td= RUBY_VERSION
+    tr
+      td Memory usage:
+      td #{@memory} MiB
+    - if defined?(Olelo::Worker)
+      tr
+        td Worker jobs
+        td= Olelo::Worker.jobs
+#tab-configuration.tab
+  h2 Configuration
+  table
+    tr
+      td Production mode:
+      td= Olelo::Config['production']
+    tr
+      td Repository backend:
+      td= Olelo::Config['repository.type']
+    tr
+      td Authentication backend:
+      td= Olelo::Config['authentication.service']
+    tr
+      td Locale:
+      td= Olelo::Config['locale']
+    tr
+      td Base path:
+      td= Olelo::Config['base_path']
+    tr
+      td Log level:
+      td= Olelo::Config['log.level']
+    tr
+      td Sidebar page:
+      td
+        a href=build_path(Olelo::Config['sidebar_page']) = Olelo::Config['sidebar_page']
+    tr
+      td Mime type detection order:
+      td= Olelo::Config['mime'].join(', ')
+#tab-plugins.tab
+  h2 Plugins
+  p These plugins are currently available on your installation.
+  table.full
+    thead
+      tr
+        th Name
+        th Description
+        th Dependencies
+    tbody
+      - Olelo::Plugin.loaded.sort_by(&:path).each do |plugin|
+        tr
+          td= plugin.path
+          td= plugin.description
+          td= plugin.dependencies.to_a.join(', ')
+      - Olelo::Plugin.disabled.sort.each do |plugin|
+        tr
+          td #{plugin} (disabled)
+          td unknown
+          td unknown
+      - Olelo::Plugin.failed.sort.each do |plugin|
+        tr
+          td #{plugin} (failed)
+          td unknown
+          td unknown
+- if defined?(Olelo::Plugin::Aspects::Aspect)
+  #tab-aspects.tab
+    h2 Aspects
+    p
+      | Every page is rendered by an aspect. The default aspect is selected automatically,
+        where aspects with lower priority are preferred. An alternative aspect
+        can be selected using the view menu or manually using the "aspect" query parameter.
+    .scrollable
+      table.full
+        thead
+          tr
+            th Name
+            th Description
+            th Output Mime Type
+            th Accepted mime types
+            th Hidden
+            th Cacheable
+            th Layout
+            th Priority
+            th Provided by plugin
+        tbody
+          - Olelo::Plugin::Aspects::Aspect.aspects.values.flatten.sort_by(&:name).each do |aspect|
+            tr
+              td= aspect.name
+              td= aspect.description
+              td= aspect.mime
+              td= aspect.accepts ? aspect.accepts.inspect : '*'
+              td== check_mark aspect.hidden?
+              td== check_mark aspect.cacheable?
+              td== check_mark aspect.layout?
+              td= aspect.priority
+              td= aspect.plugin.path
+- if defined?(Olelo::Plugin::Filters::Filter)
+  #tab-filters.tab
+    h2 Filters used by filter aspects
+    p Filters can be chained to build filter aspects.
+    table.full
+      thead
+        tr
+          th Name
+          th Description
+          th Subfilters
+          th Provided by plugin
+      tbody
+        - Olelo::Plugin::Filters::Filter.registry.values.sort_by(&:name).each do |filter|
+          tr
+            td= filter.name
+            td= filter.description
+            td== check_mark filter.respond_to?(:subfilter)
+            td= filter.plugin.path
+    h2 Filter aspect definitions
+    table.full
+      thead
+        tr
+          th Name
+          th Filters
+      tbody
+      - Olelo::Plugin::Aspects::Aspect.aspects.values.flatten.select {|aspect| Olelo::Plugin::Filters::FilterAspect === aspect }.sort_by(&:name).each do |aspect|
+        tr
+          td= aspect.name
+          td= aspect.definition
+- if defined?(Olelo::Plugin::Tags::Tag)
+  #tab-tags.tab
+    h2 Tags
+    p
+      | Tags can be included in the wikitext like normal html tags. These tags are provided by plugins as wikitext extensions.
+        The namespace prefixes are optional and can be used in case of ambiguities.
+    table.full
+      thead
+        tr
+          th Name
+          th Description
+          th Immediate
+          th Dynamic
+          th Autoclose
+          th Provided by plugin
+          th Optional attributes
+          th Required attributes
+      tbody
+        - Olelo::Plugin::Tags::Tag.tags.values.uniq.sort_by(&:full_name).each do |tag|
+          tr
+            td= tag.full_name
+            td= tag.description
+            td== check_mark tag.immediate
+            td== check_mark tag.dynamic
+            td== check_mark tag.autoclose
+            td= tag.plugin.path
+            td= tag.optional.to_a.join(', ')
+            td= tag.requires.to_a.join(', ')

data/plugins/misc/variables.rb

@@ -0,0 +1,29 @@
+description  'Export variables to context and javascript'
+dependencies 'aspects'
+
+def self.exported_variables(page)
+  vars = {
+    'page_name'             => page.name,
+    'page_new'              => page.new?,
+    'page_modified'         => page.modified?,
+    'page_path'             => page.path,
+    'page_title'            => page.title,
+    'page_version'          => page.version.to_s,
+    'page_next_version'     => page.next_version.to_s,
+    'page_previous_version' => page.previous_version.to_s,
+    'page_mime'             => page.mime.to_s,
+    'default_mime'          => Page.default_mime
+  }
+end
+
+# Export variables to aspect context
+Aspects::Context.hook(:initialized) do
+  params.merge!(PLUGIN.exported_variables(page))
+end
+
+# Export variables to javascript for client extensions
+Application.hook :head do
+  vars = page ? params.merge(PLUGIN.exported_variables(page)) : params
+  vars = vars.merge('user_logged_in' => !User.logged_in?, 'user_name' => User.current.name)
+  %{<script type="text/javascript">Olelo = #{escape_javascript(vars.to_json)};</script>}
+end

data/plugins/misc/webdav.rb

@@ -0,0 +1,45 @@
+description 'Simple webdav interface to the wiki files'
+
+class ::Olelo::Application
+  def webdav_post
+    Page.transaction do
+      page = request.put? ? Page.find!(params[:path]) : Page.new(params[:path])
+      raise :reserved_path.t if self.class.reserved_path?(page.path)
+      page.content = request.body
+      page.save
+      Page.commit(:page_uploaded.t(:page => page.title))
+      :created
+    end
+  rescue NotFound => ex
+    Olelo.logger.error ex
+    :not_found
+  rescue Exception => ex
+    Olelo.logger.error ex
+    :bad_request
+  end
+
+  put '/(:path)', :tail => true do
+    if request.form_data?
+      :not_implemented
+    else
+      webdav_post
+    end
+  end
+
+  post '/(:path)', :tail => true do
+    if request.form_data?
+      super()
+    else
+      webdav_post
+    end
+  end
+
+  # TODO: Implement more methods if needed
+  add_route('PROPFIND', '/(:path)', :tail => true)  { :not_found }
+  add_route('PROPPATCH', '/(:path)', :tail => true) { :not_implemented }
+  add_route('MKCOL', '/(:path)', :tail => true)     { :not_implemented }
+  add_route('COPY', '/(:path)', :tail => true)      { :not_implemented }
+  add_route('MOVE', '/(:path)', :tail => true)      { :not_implemented }
+  add_route('LOCK', '/(:path)', :tail => true)      { :not_implemented }
+  add_route('UNLOCK', '/(:path)', :tail => true)    { :not_implemented }
+end

data/plugins/repositories/git_grep.rb

@@ -0,0 +1,69 @@
+description 'Searching via git-grep'
+
+class ::Olelo::Application
+  get '/search' do
+    @matches = {}
+
+    if params[:pattern].to_s.length > 2
+      Repository.instance.git_grep('-z', '-i', '-I', '-3', '-e', params[:pattern], 'master') do |io|
+        while !io.eof?
+          begin
+            line = io.readline.force_encoding(Encoding.default_external)
+            line = unescape_backslash(line)
+            if line =~ /(.*?)\:([^\0]+)\0(.*)/
+              path, match = $2, $3
+              path = path.split('/')
+              path.pop if Repository.instance.reserved_name?(path.last)
+              path = path.join('/')
+              (@matches[path] ||= []) << match
+            end
+          rescue => ex
+            Olelo.logger.error ex
+          end
+        end
+      end rescue nil # git-grep returns 1 if nothing is found
+
+      Repository.instance.git_ls_tree('-r', '--name-only', 'HEAD') do |io|
+        while !io.eof?
+          begin
+            line = io.readline.force_encoding(Encoding.default_external)
+            line = unescape_backslash(line).strip
+            if line =~ /#{params[:pattern]}/i && !@matches[line]
+              path = line.split('/')
+              path.pop if Repository.instance.reserved_name?(path.last)
+              path = path.join('/')
+              page = Page.find!(path)
+              @matches[path] = [truncate(page.content, 500)] if page.mime.text?
+            end
+          rescue => ex
+            Olelo.logger.error ex
+          end
+        end
+      end
+    end
+
+    @matches = @matches.to_a.sort do |a,b|
+      a[1].length == b[1].length ? a[0] <=> b[0] : b[1].length <=> a[1].length
+    end.map {|path, content| [path, content.join] }
+
+    render :grep
+  end
+
+  private
+
+  def emphasize(s)
+    escape_html(truncate(s, 500)).gsub(/(#{params[:pattern]})/i, '<b>\1</b>').html_safe
+  end
+end
+
+__END__
+@@ grep.slim
+- title :search_results.t(:pattern => params[:pattern])
+h1= title
+p= :match.t(:count => @matches.length)
+.search
+  - @matches.each do |path, content|
+    .match
+      h2
+        a.name href=build_path(path) = emphasize(path)
+      .content= emphasize(content)

data/plugins/repositories/gitrb_repository.rb

@@ -0,0 +1,204 @@
+description 'Git repository backend (Using gitrb library)'
+require 'gitrb'
+
+class GitrbRepository < Repository
+  CONTENT_EXT   = '.content'
+  ATTRIBUTE_EXT = '.attributes'
+
+  def initialize(config)
+    Olelo.logger.info "Opening git repository: #{config[:path]}"
+    @git = Gitrb::Repository.new(:path => config[:path], :create => true,
+                                 :bare => config[:bare], :logger => Olelo.logger)
+  end
+
+  # @override
+  def transaction(&block)
+    @git.transaction(&block)
+  end
+
+  # @override
+  def commit(comment)
+    user = User.current
+    @git.commit(comment, user && Gitrb::User.new(user.name, user.email))
+    commit_to_version(@git.head)
+  end
+
+  # @override
+  def path_exists?(path, version)
+    check_path(path)
+    !get_object(path, version).nil? rescue false
+  end
+
+  # @override
+  def get_version(version)
+    commit_to_version(version ? (get_commit(version) rescue nil) : @git.head)
+  end
+
+  # @override
+  def get_history(path, skip, limit)
+    @git.log(:max_count => limit, :skip => skip,
+            :path => [path, path + ATTRIBUTE_EXT, path + CONTENT_EXT]).map do |c|
+      commit_to_version(c)
+    end
+  end
+
+  # @override
+  def get_path_version(path, version)
+    commits = @git.log(:max_count => 2, :start => version, :path => [path, path + ATTRIBUTE_EXT, path + CONTENT_EXT])
+
+    succ = nil
+    @git.git_rev_list('--reverse', '--remove-empty', "#{commits[0]}..", '--', path, path + ATTRIBUTE_EXT, path + CONTENT_EXT) do |io|
+      succ = io.eof? ? nil : get_commit(@git.set_encoding(io.readline).strip)
+    end rescue nil # no error because pipe is closed intentionally
+
+    # Deleted pages have next version (Issue #11)
+    succ = nil if succ && !path_exists?(path, succ.id)
+
+    [commit_to_version(commits[1]), # previous version
+     commit_to_version(commits[0]), # current version
+     commit_to_version(succ)]      # next version
+  end
+
+  # @override
+  def get_children(path, version)
+    object = get_object(path, version)
+    object && object.type != :tree ? [] : object.names.reject {|name| reserved_name?(name) }
+  end
+
+  # @override
+  def get_content(path, version)
+    tree = get_commit(version).tree
+    object = tree[path]
+    object = tree[path + CONTENT_EXT] if object && object.type == :tree
+    if object
+      content = object.data
+      # Try to force utf-8 encoding and revert to old encoding if this doesn't work
+      content.try_encoding(Encoding.default_encoding)
+    else
+      ''
+    end
+  end
+
+  # @override
+  def get_attributes(path, version)
+    object = get_object(path + ATTRIBUTE_EXT, version)
+    object && object.type == :blob ? YAML.load(object.data) : {}
+  end
+
+  # @override
+  def set_content(path, content)
+    check_path(path)
+    content = content.read if content.respond_to? :read
+    expand_tree(path)
+    object = @git.root[path]
+    if object && object.type == :tree
+      if content.blank?
+        @git.root.delete(path + CONTENT_EXT)
+      else
+        @git.root[path + CONTENT_EXT] = Gitrb::Blob.new(:data => content)
+      end
+      collapse_empty_tree(path)
+    else
+      @git.root[path] = Gitrb::Blob.new(:data => content)
+    end
+  end
+
+  # @override
+  def set_attributes(path, attributes)
+    check_path(path)
+    attributes = attributes.blank? ? nil : YAML.dump(attributes).sub(/\A\-\-\-\s*\n/s, '')
+    expand_tree(path)
+    if attributes
+      @git.root[path + ATTRIBUTE_EXT] = Gitrb::Blob.new(:data => attributes)
+    else
+      @git.root.delete(path + ATTRIBUTE_EXT)
+    end
+  end
+
+  # @override
+  def move(path, destination)
+    check_path(destination)
+    @git.root.move(path, destination)
+    @git.root.move(path + CONTENT_EXT, destination + CONTENT_EXT) if @git.root[path + CONTENT_EXT]
+    @git.root.move(path + ATTRIBUTE_EXT, destination + ATTRIBUTE_EXT) if @git.root[path + ATTRIBUTE_EXT]
+    collapse_empty_tree(path/'..')
+  end
+
+  # @override
+  def delete(path)
+    @git.root.delete(path)
+    @git.root.delete(path + CONTENT_EXT)
+    @git.root.delete(path + ATTRIBUTE_EXT)
+    collapse_empty_tree(path/'..')
+  end
+
+  # @override
+  def diff(path, from, to)
+    diff = @git.diff(:from => from && from.to_s, :to => to.to_s,
+                    :path => [path, path + CONTENT_EXT, path + ATTRIBUTE_EXT], :detect_renames => true)
+    Diff.new(commit_to_version(diff.from), commit_to_version(diff.to), diff.patch)
+  end
+
+  # @override
+  def short_version(version)
+    version[0..4]
+  end
+
+  def reserved_name?(name)
+    name.ends_with?(ATTRIBUTE_EXT) || name.ends_with?(CONTENT_EXT)
+  end
+
+  def method_missing(name, *args)
+    if cmd =~ /\Agit_/
+      @git.method_missing(name, *args)
+    else
+      super
+    end
+  end
+
+  private
+
+  def get_commit(version)
+    @git.get_commit(version.to_s)
+  end
+
+  def get_object(path, version)
+    @git.get_commit(version.to_s).tree[path]
+  end
+
+  def check_path(path)
+    raise :reserved_path.t if path.split('/').any? {|name| reserved_name?(name) }
+  end
+
+  def commit_to_version(commit)
+    commit && Version.new(commit.id, User.new(commit.author.name, commit.author.email),
+                          commit.date, commit.message, commit.parents.map(&:id), commit == @git.head)
+  end
+
+  # Convert blob parents to trees
+  # to allow children
+  def expand_tree(path)
+    names = path.split('/')
+    names.pop
+    parent = @git.root
+    names.each do |name|
+      object = parent[name]
+      break if !object
+      if object.type == :blob
+        parent.move(name, name + CONTENT_EXT)
+        break
+      end
+      parent = object
+    end
+  end
+
+  # If a tree consists only of tree/, tree.content and tree.attributes without
+  # children, tree.content can be moved to tree ("collapsing").
+  def collapse_empty_tree(path)
+    if !path.blank? && @git.root[path].empty? && @git.root[path + CONTENT_EXT]
+      @git.root.move(path + CONTENT_EXT, path)
+    end
+  end
+end
+
+Repository.register :gitrb, GitrbRepository