olelo 0.9.0

data/lib/olelo/middleware/blacklist.rb

@@ -0,0 +1,25 @@
+# coding: binary
+# Coding is required for StringIO
+module Olelo
+  module Middleware
+    class Blacklist
+      NULL_IO = StringIO.new('')
+
+      def initialize(app, options)
+        @app = app
+        @list = options[:blacklist]
+      end
+
+      def call(env)
+        if %w(POST PUT DELETE).include?(env['REQUEST_METHOD']) && @list.include?(Rack::Request.new(env).ip)
+          env.delete('rack.request.form_vars')
+          env.delete('rack.request.form_hash')
+          env.delete('rack.request.form_input')
+          env['rack.input'] = NULL_IO
+          env['REQUEST_METHOD'] = 'GET'
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/olelo/middleware/degrade_mime_type.rb

@@ -0,0 +1,19 @@
+module Olelo
+  module Middleware
+    class DegradeMimeType
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        status, header, body = @app.call(env)
+        if env['HTTP_ACCEPT'].to_s !~ %r{application/xhtml\+xml}
+          if header['Content-Type'] =~ %r{\Aapplication/xhtml\+xml(;?.*)\Z}
+            header['Content-Type'] = "text/html#{$1}"
+          end
+        end
+        [status, header, body]
+      end
+    end
+  end
+end

data/lib/olelo/middleware/flash.rb

@@ -0,0 +1,97 @@
+module Olelo
+  module Middleware
+    class Flash
+      # Implements bracket accessors for storing and retrieving flash entries.
+      class FlashHash
+        def initialize(session)
+          @session = session
+          raise 'No session available' if !session
+        end
+
+        # Remove an entry from the session and return its value. Cache result in
+        # the instance cache.
+        def [](key)
+          key = key.to_sym
+          cache[key] ||= values.delete(key)
+        end
+
+        # Store the entry in the session, updating the instance cache as well.
+        def []=(key,val)
+          key = key.to_sym
+          cache[key] = values[key] = val
+        end
+
+        # Store a flash entry for only the current request, swept regardless of
+        # whether or not it was actually accessed
+        def now
+          cache
+        end
+
+        # Checks for the presence of a flash entry without retrieving or removing
+        # it from the cache or store.
+        def include?(key)
+          key = key.to_sym
+          cache.keys.include?(key) || values.keys.include?(key)
+        end
+
+        # Clear the hash
+        def clear
+          cache.clear
+          @session.delete(:olelo_flash)
+        end
+
+        # Hide the underlying olelo.flash session key and only expose values stored
+        # in the flash.
+        def inspect
+          "#<FlashHash @values=#{values.inspect} @cache=#{cache.inspect}>"
+        end
+
+        # Human readable for logging.
+        def to_s
+          values.inspect
+        end
+
+        private
+
+        # Maintain an instance-level cache of retrieved flash entries. These
+        # entries will have been removed from the session, but are still available
+        # through the cache.
+        def cache
+          @cache ||= {}
+        end
+
+        # Helper to access flash entries from olelo.flash session value. This key
+        # is used to prevent collisions with other user-defined session values.
+        def values
+          @session[:olelo_flash] ||= {}
+        end
+      end
+
+      def initialize(app, options = {})
+        @app = app
+        @hash = Class.new(FlashHash)
+        [*options[:accessors]].compact.each do |key|
+          key = key.to_sym
+          @hash.class_eval do
+            define_method(key) {|*a| a.size > 0 ? (self[key] = a[0]) : self[key] }
+            define_method("#{key}=") {|val| self[key] = val }
+            define_method("#{key}!") {|val| cache[key] = val }
+          end
+        end
+        [*options[:set_accessors]].compact.each do |key|
+          key = key.to_sym
+          @hash.class_eval do
+            define_method(key) {|*val| val.size > 0 ? (self[key] ||= Set.new).merge(val) : self[key] }
+            define_method("#{key}!") {|*val| val.size > 0 ? (cache[key] ||= Set.new).merge(val) : cache[key] }
+          end
+        end
+      end
+
+      def call(env)
+        session = env['rack.session']
+        env['olelo.flash'] ||= @hash.new(session)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/olelo/middleware/force_encoding.rb

@@ -0,0 +1,41 @@
+module Olelo
+  module Middleware
+    class ForceEncoding
+      def initialize(app, encoding = Encoding.default_external)
+        @app, @encoding = app, encoding
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+        encode(env)
+        encode(request.params)
+        @app.call(env)
+      end
+
+      private
+
+      def encode(x)
+        case x
+        when Hash
+          y = x.frozen? ? {} : x
+          x.each { |k,v| y[k] = encode(v) }
+          y
+        when Array
+          y = x.frozen? ? [] : x
+          x.each_with_index {|v,i| y[i] = encode(v) }
+          y
+        when String
+          # Try to force encoding and revert to old encoding if this doesn't work
+          if x.encoding != @encoding
+            x = x.dup if x.frozen?
+            x.try_encoding(@encoding)
+          else
+          x
+          end
+        else
+          x
+        end
+      end
+    end
+  end
+end

data/lib/olelo/page.rb

@@ -0,0 +1,266 @@
+module Olelo
+  # Wiki page object
+  class Page
+    include Util
+    include Hooks
+    include Attributes
+
+    has_around_hooks :move, :delete, :save
+
+    attributes do
+      string  :title
+      boolean :no_title
+      string  :description
+      string :mime do
+        Config['mime_suggestions'].inject({}) do |hash, mime|
+          comment = MimeMagic.new(mime).comment
+          hash[mime] = comment.blank? ? mime : "#{comment} (#{mime})"
+          hash
+        end
+      end
+    end
+
+    # Pattern for valid paths
+    # @api public
+    PATH_PATTERN = '[^\s](?:.*[^\s]+)?'.freeze
+    PATH_REGEXP = /^#{PATH_PATTERN}$/
+
+    # Mime type for empty page
+    # @api public
+    EMPTY_MIME = MimeMagic.new('inode/x-empty')
+
+    # Mime type for directory
+    # @api public
+    DIRECTORY_MIME = MimeMagic.new('inode/directory')
+
+    attr_reader :path, :tree_version
+
+    def initialize(path, tree_version = nil, parent = nil)
+      @path, @tree_version, @parent = path.to_s.cleanpath.freeze, tree_version, parent
+      Page.check_path(@path)
+    end
+
+    def self.transaction(&block)
+      raise 'Transaction already running' if Thread.current[:olelo_tx]
+      Thread.current[:olelo_tx] = []
+      repository.transaction(&block)
+    ensure
+      Thread.current[:olelo_tx] = nil
+    end
+
+    def self.current_transaction
+      Thread.current[:olelo_tx] || raise('No transaction running')
+    end
+
+    def self.commit(comment)
+      tree_version = repository.commit(comment)
+      current_transaction.each {|proc| proc.call(tree_version) }
+      current_transaction.clear
+    end
+
+    # Throws exceptions if access denied, returns nil if not found
+    def self.find(path, tree_version = nil)
+      path = path.to_s.cleanpath
+      check_path(path)
+      tree_version = repository.get_version(tree_version) unless Version === tree_version
+      Page.new(path, tree_version) if tree_version && repository.path_exists?(path, tree_version)
+    end
+
+    # Throws if not found
+    def self.find!(path, tree_version = nil)
+      find(path, tree_version) || raise(NotFound, path)
+    end
+
+    # Head version
+    def head?
+      new? || tree_version.head?
+    end
+
+    def root?
+      path.empty?
+    end
+
+    def next_version
+      init_versions
+      @next_version
+    end
+
+    def previous_version
+      init_versions
+      @previous_version
+    end
+
+    def version
+      init_versions
+      @version
+    end
+
+    def history(skip = nil, limit = nil)
+      raise 'Page is new' if new?
+      repository.get_history(path, skip, limit)
+    end
+
+    def parent
+      @parent ||= Page.find(path/'..', tree_version) || Page.new(path/'..', tree_version) if !root?
+    end
+
+    def move(destination)
+      raise 'Page is not head' unless head?
+      raise 'Page is new' if new?
+      destination = destination.to_s.cleanpath
+      Page.check_path(destination)
+      raise :already_exists.t(:page => destination) if Page.find(destination)
+      with_hooks(:move, destination) { repository.move(path, destination) }
+      after_commit {|tree_version| update(destination, tree_version) }
+    end
+
+    def delete
+      raise 'Page is not head' unless head?
+      raise 'Page is new' if new?
+      with_hooks(:delete) { repository.delete(path) }
+      after_commit {|tree_version| update(path, nil) }
+    end
+
+    def diff(from, to)
+      raise 'Page is new' if new?
+      repository.diff(path, from, to)
+    end
+
+    def new?
+      !tree_version
+    end
+
+    def name
+      i = path.rindex('/')
+      name = i ? path[i+1..-1] : path
+    end
+
+    def title
+      attributes['title'] || (root? ? :root.t : name)
+    end
+
+    def extension
+      i = path.index('.')
+      i ? path[i+1..-1] : ''
+    end
+
+    def attributes
+      @attributes ||= deep_copy(saved_attributes)
+    end
+
+    def saved_attributes
+      @saved_attributes ||= new? ? {} : repository.get_attributes(path, tree_version)
+    end
+
+    def attributes=(a)
+      a ||= {}
+      if attributes != a
+        @attributes = a
+        @mime = nil
+      end
+    end
+
+    def saved_content
+      @saved_content ||= new? ? '' : repository.get_content(path, tree_version)
+    end
+
+    def content
+      @content ||= saved_content
+    end
+
+    def content=(c)
+      if content != c
+        @mime = nil
+        @content = c
+      end
+    end
+
+    def modified?
+      content != saved_content || attributes != saved_attributes
+    end
+
+    def save
+      raise 'Page is not head' unless head?
+      raise :already_exists.t(:page => path) if new? && Page.find(path)
+      with_hooks(:save) do
+        repository.set_content(path, content)
+        repository.set_attributes(path, attributes)
+      end
+      after_commit {|tree_version| update(path, tree_version) }
+    end
+
+    def mime
+      @mime ||= detect_mime
+    end
+
+    def children
+      @children ||=
+        if new?
+          []
+        else
+          repository.get_children(path, tree_version).sort.map do |name|
+            Page.new(path/name, tree_version, self)
+          end
+        end
+    end
+
+    def self.default_mime
+      mime = Config['mime'].find {|m| m.include? '/'}
+      mime ? MimeMagic.new(mime) : nil
+    end
+
+    private
+
+    def update(path, tree_version)
+      @path = path.freeze
+      @tree_version = tree_version
+      @version = @next_version = @previous_version =
+        @parent = @children = @mime =
+        @attributes = @saved_attributes =
+        @content = @saved_content = nil
+    end
+
+    def after_commit(&block)
+      Page.current_transaction << block
+    end
+
+    def self.check_path(path)
+      raise :invalid_path.t if !(path.blank? || path =~ PATH_REGEXP) || !valid_xml_chars?(path)
+    end
+
+    def detect_mime
+      return MimeMagic.new(attributes['mime']) if attributes['mime']
+      Config['mime'].each do |mime|
+        mime = if mime == 'extension'
+                 MimeMagic.by_extension(extension)
+               elsif %w(content magic).include?(mime)
+                 if !new?
+                   if content.blank?
+                     children.empty? ? EMPTY_MIME : DIRECTORY_MIME
+                   else
+                     MimeMagic.by_magic(content)
+                   end
+                 end
+               else
+                 MimeMagic.new(mime)
+               end
+        return mime if mime
+      end
+    end
+
+    def init_versions
+      if !@version && @tree_version
+        raise 'Page is new' if new?
+        @previous_version, @version, @next_version = repository.get_path_version(path, tree_version)
+      end
+    end
+
+    def repository
+      Repository.instance
+    end
+
+    def self.repository
+      Repository.instance
+    end
+  end
+end