olelo 0.9.0

data/lib/rack/olelo_patches.rb

@@ -0,0 +1,33 @@
+require 'rack'
+require 'socket'
+
+class Rack::Request
+  # Remote host name
+  def remote_host
+    @remote_host ||= Socket.gethostbyaddr(ip.split('.').map(&:to_i).pack('C*')).first rescue nil
+  end
+
+  # No caching for this request?
+  def no_cache?
+    env['HTTP_PRAGMA'] == 'no-cache' || env['HTTP_CACHE_CONTROL'].to_s.include?('no-cache')
+  end
+end
+
+# Rack::Lint injector
+class Rack::Builder
+  module UseLint
+    def use(middleware, *args, &block)
+      super Rack::Lint if middleware != Rack::Lint
+      super
+    end
+
+    def run(app)
+      use Rack::Lint
+      super
+    end
+  end
+
+  def use_lint
+    class << self; include UseLint; end
+  end
+end

data/lib/rack/relative_redirect.rb

@@ -0,0 +1,44 @@
+require 'rack'
+
+# Rack::RelativeRedirect is a simple middleware that converts relative paths in
+# redirects in absolute urls, so they conform to RFC2616. It allows the user to
+# specify the absolute path to use (with a sensible default), and handles
+# relative paths (those that don't start with a slash) as well.
+class Rack::RelativeRedirect
+  SCHEME_MAP = {'http'=>'80', 'https'=>'443'}
+  # The default proc used if a block is not provided to .new
+  # Just uses the url scheme of the request and the server name.
+  DEFAULT_ABSOLUTE_PROC = proc do |env, res|
+    port = env['SERVER_PORT']
+    scheme = env['rack.url_scheme']
+    "#{scheme}://#{env['SERVER_NAME']}#{":#{port}" unless SCHEME_MAP[scheme] == port}"
+  end
+
+  # Initialize a new RelativeRedirect object with the given arguments.  Arguments:
+  # * app : The next middleware in the chain.  This is always called.
+  # * &block : If provided, it is called with the environment and the response
+  #   from the next middleware. It should return a string representing the scheme
+  #   and server name (such as 'http://example.org').
+  def initialize(app, &block)
+    @app = app
+    @absolute_proc = block || DEFAULT_ABSOLUTE_PROC
+  end
+
+  # Call the next middleware with the environment.  If the request was a
+  # redirect (response status 301, 302, or 303), and the location header does
+  # not start with an http or https url scheme, call the block provided by new
+  # and use that to make the Location header an absolute url.  If the Location
+  # does not start with a slash, make location relative to the path requested.
+  def call(env)
+    res = @app.call(env)
+    if [301,302,303].include?(res[0]) and loc = res[1]['Location'] and !%r{\Ahttps?://}o.match(loc)
+      absolute = @absolute_proc.call(env, res)
+      res[1]['Location'] = if %r{\A/}.match(loc)
+        "#{absolute}#{loc}"
+      else
+        "#{absolute}#{File.dirname(Rack::Utils.unescape(env['PATH_INFO']))}/#{loc}"
+      end
+    end
+    res
+  end
+end

data/lib/rack/static_cache.rb

@@ -0,0 +1,93 @@
+module Rack
+
+  #
+  # The Rack::StaticCache middleware automatically adds, removes and modifies
+  # stuffs in response headers to facilitiate client and proxy caching for static files
+  # that minimizes http requests and improves overall load times for second time visitors.
+  #
+  # Once a static content is stored in a client/proxy the only way to enforce the browser
+  # to fetch the latest content and ignore the cache is to rename the static file.
+  #
+  # Alternatively, we can add a version number into the URL to the content to bypass
+  # the caches. Rack::StaticCache by default handles version numbers in the filename.
+  # As an example,
+  # http://yoursite.com/images/test-1.0.0.png and http://yoursite.com/images/test-2.0.0.png
+  # both reffers to the same image file http://yoursite.com/images/test.png
+  #
+  # Another way to bypass the cache is adding the version number in a field-value pair in the
+  # URL query string. As an example, http://yoursite.com/images/test.png?v=1.0.0
+  # In that case, set the option :versioning to false to avoid unneccessary regexp calculations.
+  #
+  # It's better to keep the current version number in some config file and use it in every static
+  # content's URL. So each time we modify our static contents, we just have to change the version
+  # number to enforce the browser to fetch the latest content.
+  #
+  # You can use Rack::Deflater along with Rack::StaticCache for further improvements in page loading time.
+  #
+  # Examples:
+  #     use Rack::StaticCache, :urls => ["/images", "/css", "/js", "/documents*"], :root => "statics"
+  #     will serve all requests beginning with /images, /csss or /js from the
+  #     directory "statics/images",  "statics/css",  "statics/js".
+  #     All the files from these directories will have modified headers to enable client/proxy caching,
+  #     except the files from the directory "documents". Append a * (star) at the end of the pattern
+  #     if you want to disable caching for any pattern . In that case, plain static contents will be served with
+  #     default headers.
+  #
+  #     use Rack::StaticCache, :urls => ["/images"], :duration => 2, :versioning => false
+  #     will serve all requests begining with /images under the current directory (default for the option :root
+  #     is current directory). All the contents served will have cache expiration duration set to 2 years in headers
+  #     (default for :duration is 1 year), and StaticCache will not compute any versioning logics (default for
+  #     :versioning is true)
+  #
+
+
+  class StaticCache
+
+    def initialize(app, options={})
+      @app = app
+      @urls = options[:urls]
+      @no_cache = {}
+      @urls.collect! do |url|
+        if url  =~ /\*$/
+          url.sub!(/\*$/, '')
+          @no_cache[url] = 1
+        end
+        url
+      end
+      root = options[:root] || Dir.pwd
+      @file_server = Rack::File.new(root)
+      @cache_duration = options[:duration] || 1
+      @versioning_enabled = true
+      @versioning_enabled = options[:versioning] unless options[:versioning].nil?
+      @duration_in_seconds = self.duration_in_seconds
+      @duration_in_words    = self.duration_in_words
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+      url = @urls.detect{ |u| path.index(u) == 0 }
+      unless url.nil?
+        path.sub!(/-[\d.]+([.][a-zA-Z][\w]+)?$/, '\1') if @versioning_enabled
+        status, headers, body = @file_server.call(env)
+        if @no_cache[url].nil?
+          headers['Cache-Control'] ="max-age=#{@duration_in_seconds}, public"
+          headers['Expires'] = @duration_in_words
+          headers.delete 'Etag'
+          headers.delete 'Pragma'
+          headers.delete 'Last-Modified'
+        end
+        [status, headers, body]
+      else
+        @app.call(env)
+      end
+    end
+
+    def duration_in_words
+      (Time.now + self.duration_in_seconds).strftime '%a, %d %b %Y %H:%M:%S GMT'
+    end
+
+    def duration_in_seconds
+      60 * 60 * 24 * 365 * @cache_duration
+    end
+  end
+end

data/lib/yard/addons.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + '/addons/*.rb'].each {|file| require file }

data/lib/yard/addons/hook_handler.rb

@@ -0,0 +1,25 @@
+module YARD
+  module Handlers
+    class HookHandler < Ruby::Base
+      handles method_call(:hook)
+      handles method_call(:before)
+      handles method_call(:after)
+
+      def process
+	hook = statement.parameters.first.source
+	return if hook =~ /^"(BEFORE|AFTER)/
+	name = "#{statement.method_name(true).to_s.upcase} #{hook}"
+        route = register CodeObjects::MethodObject.new(namespace, name, :instance) do |o|
+          o.visibility = "public"
+          o.source = statement.source
+          o.signature = name
+          o.explicit = true
+          o.scope = scope
+          o.docstring = statement.comments
+          o.sanitize_anchor = true
+          o.add_file(parser.file, statement.line)
+        end
+      end
+    end
+  end
+end

data/lib/yard/addons/override_tag.rb

@@ -0,0 +1,14 @@
+module YARD::Tags
+  class OverrideTag < Tag
+    def initialize(tag_name, text)
+      super(tag_name, text)
+    end
+
+    def text
+      "{#{object.namespace.superclass}##{object.name(false)}}"
+    end
+  end
+
+  Library.define_tag "Override", :override, OverrideTag
+  Library.visible_tags.place(:override).before(:return)
+end

data/lib/yard/addons/route_handler.rb

@@ -0,0 +1,33 @@
+module YARD
+  module Handlers
+    class RouteHandler < Ruby::Base
+      handles method_call(:get)
+      handles method_call(:post)
+      handles method_call(:put)
+      handles method_call(:delete)
+      handles method_call(:head)
+
+      def register_route(name, explicit)
+        register CodeObjects::MethodObject.new(namespace, name, :instance) do |o|
+          o.visibility = "public"
+          o.source = statement.source
+          o.signature = name
+          o.explicit = explicit
+          o.scope = scope
+          o.docstring = statement.comments
+          o.sanitize_anchor = true
+          o.add_file(parser.file, statement.line)
+        end
+      end
+
+      def process
+        path = statement.parameters.first.source
+        if path =~ /'(.*)'/
+          verb = statement.method_name(true).to_s.upcase
+          register_route("HEAD #{$1}", false) if verb == 'GET'
+          register_route("#{verb} #{$1}", true)
+        end
+      end
+    end
+  end
+end

data/lib/yard/addons/sanitize_anchor.rb

@@ -0,0 +1,16 @@
+module YARD
+  class CodeObjects::Base
+    attr_accessor :sanitize_anchor
+  end
+
+  module Templates::Helpers::HtmlHelper
+    alias anchor_for_without_sanitize anchor_for
+    def anchor_for(object)
+      if CodeObjects::Base === object && object.sanitize_anchor
+        anchor_for_without_sanitize(object).gsub(/[^\w_\-]/, '_')
+      else
+        anchor_for_without_sanitize(object)
+      end
+    end
+  end
+end

data/olelo.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/lib/olelo/version'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name              = 'olelo'
+  s.version           = Olelo::VERSION
+  s.date              = Date.today.to_s
+  s.authors           = ['Daniel Mendler']
+  s.email             = ['mail@daniel-mendler.de']
+  s.summary           = 'Olelo is a git-based wiki.'
+  s.summary           = 'Olelo is a git-based wiki which supports many markup languages, tags, embedded TeX and much more. It can be extended through plugins.'
+  s.homepage          = 'http://gitwiki.org/'
+  s.rubyforge_project = s.name
+
+  s.files         = `git ls-files | grep -P -v '^tools/'`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w(lib)
+
+  s.add_runtime_dependency('tilt', ['~> 1.3.3'])
+  s.add_runtime_dependency('slim', ['~> 1.3.3'])
+  s.add_runtime_dependency('creole', ['~> 0.4.2'])
+  s.add_runtime_dependency('nokogiri', ['~> 1.5.5'])
+  s.add_runtime_dependency('mimemagic', ['~> 0.1.9'])
+  s.add_runtime_dependency('rack', ['~> 1.4.1'])
+  s.add_runtime_dependency('redcarpet', ['~> 2.1.1'])
+  s.add_runtime_dependency('rugged', ['~> 0.17.0b6'])
+
+  s.add_development_dependency('rake', ['>= 0.8.7'])
+  s.add_development_dependency('sass', ['>= 3.1.0'])
+end

data/plugins/aspects/changelog.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+description 'Changelog Aspect'
+require 'rss/maker'
+
+Aspect.create(:changelog, :cacheable => true, :hidden => true) do
+  def call(context, page)
+    format = context.params[:format]
+
+    url = context.request.base_url
+    context.header['Content-Type'] = "application/#{format == 'rss' ? 'rss' : 'atom'}+xml; charset=utf-8"
+
+    content = RSS::Maker.make(format == 'rss' ? '2.0' : 'atom') do |feed|
+      feed.channel.generator = 'Ōlelo'
+      feed.channel.title = Config['title']
+      feed.channel.link = url + '/' + page.path
+      feed.channel.description = Config['title'] + ' Changelog'
+      feed.channel.id = url + page.path
+      feed.channel.updated = Time.now
+      feed.channel.author = Config['title']
+      feed.items.do_sort = true
+      page.history.each do |version|
+        i = feed.items.new_item
+        i.title = version.comment
+        i.link = url + '/changes'/version
+        i.date = version.date
+        i.dc_creator = version.author.name
+      end
+    end
+    content.to_s
+  end
+end
+
+Application.hook :head do
+  %{<link rel="alternate" type="application/atom+xml" title="Sitewide Atom Changelog"
+href="#{escape_html build_path('/', :aspect => 'changelog', :format => 'atom')}"/>
+<link rel="alternate" type="application/rss+xml" title="Sitewide RSS Changelog"
+href="#{escape_html build_path('/', :aspect => 'changelog', :format => 'rss')}"/>}
+end
+
+Application.hook :head do
+  %{<link rel="alternate" type="application/atom+xml" title="#{escape_html page.path} Atom Changelog"
+href="#{escape_html(build_path(page.path, :aspect => 'changelog', :format => 'atom'))}"/>
+<link rel="alternate" type="application/rss+xml" title="#{escape_html page.path} RSS Changelog"
+href="#{escape_html(build_path(page.path, :aspect => 'changelog', :format => 'rss'))}"/>} if page && !page.new? && !page.root?
+end

data/plugins/aspects/documentbrowser.rb

@@ -0,0 +1,57 @@
+description 'Document browser aspect'
+dependencies 'utils/shell'
+
+Aspect.create(:documentbrowser, :priority => 1, :layout => true, :cacheable => true, :accepts => %r{^application/pdf$|postscript$}) do
+  def count_pages
+    content = @page.content
+    page_count = 0
+    if @page.mime == 'application/pdf'
+      page_count = $1.to_i if Shell.pdfinfo('-').run(content) =~ /Pages:\s+(\d+)/
+    else
+      content = Shell.cmd($1 == 'gz' ? 'gunzip' : 'bunzip2').run(content) if @page.mime.to_s =~ /(gz|bz)/
+      page_count = $1.to_i if content =~ /^%%Pages:\s+(\d+)$/
+    end
+    page_count
+  end
+
+  def call(context, page)
+    @page = page
+    @page_nr = [context.params[:page].to_i, 1].max
+    @page_count = count_pages
+    render :browser
+  end
+end
+
+__END__
+
+@@ browser.slim
+= pagination(@page, @page_count, @page_nr, :aspect => 'documentbrowser')
+p
+  img src=build_path(@page, :aspect => 'image', :geometry => '480x>', :trim => 1, :page => @page_nr)
+= pagination(@page, @page_count, @page_nr, :aspect => 'documentbrowser')
+h3= :information.t
+table
+  tbody
+    tr
+      td= :name.t
+      td= @page.name
+    tr
+      td= :title.t
+      td= @page.title
+    tr
+      td= :description.t
+      td= @page.attributes['description']
+    - if @page.version
+      tr
+        td= :last_modified.t
+        td= date @page.version.date
+      tr
+        td= :version.t
+        td.version= @page.version
+    tr
+      td= :type.t
+      td= @page.mime.comment.blank? ? @page.mime : "#{@page.mime.comment} (#{@page.mime})"
+    tr
+      td= :download.t
+      td
+        a href=build_path(@page, :aspect => 'download') = :download.t

data/plugins/aspects/download.rb

@@ -0,0 +1,11 @@
+description 'Download aspect'
+
+Aspect.create(:download) do
+  def accepts?(page); !page.content.empty?; end
+  def call(context, page)
+    name = page.root? ? :root.t : page.name.gsub(/[^\w.\-_]/, '_')
+    context.header['Content-Disposition'] = %{attachment; filename="#{name}"}
+    context.header['Content-Length'] = page.content.bytesize.to_s
+    page.content
+  end
+end

data/plugins/aspects/highlight.rb

@@ -0,0 +1,8 @@
+description  'Source code highlighting aspect'
+dependencies 'utils/pygments'
+
+Aspect.create(:highlight, :priority => 2, :layout => true, :cacheable => true) do
+  def accepts?(page); !page.content.empty? && Pygments.file_format(page.name); end
+  def call(context, page); Pygments.pygmentize(page.content, Pygments.file_format(page.name)); end
+end
+

data/plugins/aspects/image.rb

@@ -0,0 +1,41 @@
+description 'Image aspect'
+dependencies 'utils/image_magick'
+
+Aspect.create(:image, :priority => 5, :accepts => %r{^application/pdf$|postscript$|^image/}, :cacheable => true) do
+  def call(context, page)
+    geometry = context.params[:geometry]
+    trim = context.params[:trim]
+    ps = page.mime.to_s =~ /postscript/
+    if ps || page.mime == 'application/pdf'
+      page_nr = [context.params[:page].to_i, 1].max
+      cmd = ImageMagick.new
+      if ps
+        cmd.cmd($1 == 'gz' ? 'gunzip' : 'bunzip2') if page.mime.to_s =~ /(bz|gz)/
+        cmd.psselect "-p#{page_nr}"
+        cmd.gs('-sDEVICE=jpeg', '-sOutputFile=-', '-r144', '-dBATCH', '-dNOPAUSE', '-q', '-')
+      end
+      cmd.convert('-depth', 8, '-quality', 50) do |args|
+        args << '-trim' if trim
+        args << '-thumbnail' << geometry if geometry =~ /^(\d+)?x?(\d+)?[%!<>]*$/
+        if ps
+          args << '-'
+        else
+          args << '-density' << 144 << "-[#{page_nr - 1}]"
+        end
+        args << 'JPEG:-'
+      end
+      context.header['Content-Type'] = 'image/jpeg'
+      cmd.run(page.content)
+    elsif page.mime.to_s =~ /svg/ || geometry || trim
+      cmd = ImageMagick.convert do |args|
+        args << '-trim' if trim
+        args << '-thumbnail' << geometry if geometry =~ /^(\d+)?x?(\d+)?[%!<>]*$/
+        args << '-' << (page.mime.to_s == 'image/jpeg' ? 'JPEG:-' : 'PNG:-')
+      end
+      context.header['Content-Type'] = 'image/png'
+      cmd.run(page.content)
+    else
+      page.content
+    end
+  end
+end