olelo 0.9.0

data/lib/olelo/repository.rb

@@ -0,0 +1,225 @@
+module Olelo
+  # Version object
+  class Version
+    attr_reader :id, :author, :date, :comment, :parents
+    attr_reader? :head
+
+    def initialize(id, author, date, comment, parents, head)
+      @id, @author, @date, @comment, @parents, @head = id, author, date, comment, parents, head
+    end
+
+    # Returns shortened unique version id
+    #
+    # @return [String] shortened version id
+    # @api public
+    def short
+      Version.short(id)
+    end
+
+    # Shortens given version id
+    #
+    # @param [String] long version id
+    # @return [String] shortened version id
+    # @api public
+    def self.short(id)
+      Repository.instance.short_version(id)
+    end
+
+    # Return version id
+    #
+    # @return [String]
+    # @api public
+    def to_s
+      id
+    end
+
+    # Check equality of versions
+    #
+    # @param [Version, String] other version
+    # @return [Boolean]
+    # @api public
+    def ==(other)
+      other.to_s == id
+    end
+
+    def cache_id
+      "#{@id}-#{@head}"
+    end
+  end
+
+  # Difference between versions
+  Diff = Struct.new(:from, :to, :patch)
+
+  # Abstract repository base
+  #
+  # This class should not be used directly. Use the {Page} class
+  # which is implemented on top of it.
+  #
+  # @abstract
+  class Repository
+    include Util
+    extend Factory
+
+    def self.instance
+      Thread.current[:olelo_repository] ||= self[Config['repository.type']].new(Config['repository'][Config['repository.type']])
+    end
+
+    # Wrap block in transaction
+    #
+    # Every write operation has to be wrapped in a transaction.
+    #
+    # @yield Transaction block
+    # @return [void]
+    # @api public
+    def transaction
+      raise NotImplementedError
+    end
+
+    # Set content of path
+    #
+    # This method can only be used within a {#transaction} block.
+    #
+    # @param [String] path
+    # @param [String, #read] content
+    # @return [void]
+    # @api public
+    def set_content(path, content)
+      raise NotImplementedError
+    end
+
+    # Set attributes of path
+    #
+    # This method can only be used within a {#transaction} block.
+    #
+    # @param [String] path
+    # @param [Hash] attributes
+    # @return [void]
+    # @api public
+    def set_attributes(path, attributes)
+      raise NotImplementedError
+    end
+
+    # Move path
+    #
+    # This method can only be used within a {#transaction} block.
+    #
+    # @param [String] path
+    # @param [String] destination
+    # @return [void]
+    def move(path, destination)
+      raise NotImplementedError
+    end
+
+    # Delete path
+    #
+    # This method can only be used within a {#transaction} block.
+    #
+    # @param [String] path
+    # @return [void]
+    def delete(path)
+      raise NotImplementedError
+    end
+
+    # Commit changes with a comment
+    #
+    # This method can only be used within a {#transaction} block.
+    #
+    # @param [String] comment
+    # @return [Version] New head version
+    # @api public
+    def commit(comment)
+      raise NotImplementedError
+    end
+
+    # Check if path exists
+    #
+    # @param [String] path
+    # @param [String, Version] version
+    # @return [Boolean]
+    # @api public
+    def path_exists?(path, version)
+      raise NotImplementedError
+    end
+
+    # Find version by version id
+    #
+    # Returns head version if no version is given
+    #
+    # @param [String] version
+    # @return [Version]
+    # @api public
+    def get_version(version = nil)
+      raise NotImplementedError
+    end
+
+    # Get history of path beginning with newest version
+    #
+    # @param [String] path
+    # @param [Integer] Number of versions to skip
+    # @param [Integer] Maximum number of versions to load
+    # @return [Array<Version>]
+    # @api public
+    def get_history(path, skip = nil, limit = nil)
+      raise NotImplementedError
+    end
+
+    # Get versions of path
+    #
+    # @param [String] path
+    # @param [String, Version] version
+    # @return [Array<Version>] Tuple: previous version, current version, next version
+    # @api public
+    def get_path_version(path, version)
+      raise NotImplementedError
+    end
+
+    # Get children of path
+    #
+    # @param [String] path
+    # @param [String, Version] version
+    # @return [Array<String>] Names of children
+    # @api public
+    def get_children(path, version)
+      raise NotImplementedError
+    end
+
+    # Get content
+    #
+    # @param [String] path
+    # @param [String, Version] version
+    # @return [String] content
+    # @api public
+    def get_content(path, version)
+      raise NotImplementedError
+    end
+
+    # Get attributes
+    #
+    # @param [String] path
+    # @param [String, Version] version
+    # @return [Hash] attribute hash
+    # @api public
+    def get_attributes(path, version)
+      raise NotImplementedError
+    end
+
+    # Difference between versions for path
+    #
+    # @param [String] path
+    # @param [Version, String] from
+    # @param [Version, String] to
+    # @api public
+    def diff(path, from, to)
+      raise NotImplementedError
+    end
+
+    # Shortens given version id
+    #
+    # @param [String] long version id
+    # @return [String] shortened version id
+    # @api public
+    def short_version(version)
+      version
+    end
+  end
+end

data/lib/olelo/routing.rb

@@ -0,0 +1,223 @@
+module Olelo
+  module Routing
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    attr_reader :params, :original_params, :response, :request, :env
+
+    # Process rack request
+    #
+    # This method duplicates the object and calls {#call!} on it.
+    #
+    # @api public
+    # @param [Hash] env Rack environment
+    # @return [Array] Rack return value
+    # @see http://rack.rubyforge.org/doc/SPEC.html
+    def call(env)
+      dup.call!(env)
+    end
+
+    # Process rack request
+    #
+    # @api public
+    # @param [Hash] env Rack environment
+    # @return [Array] Rack return value
+    def call!(env)
+      @env      = env
+      @request  = Rack::Request.new(env)
+      @response = Rack::Response.new
+      @params = @original_params = @request.params.with_indifferent_access
+      @original_params.freeze
+
+      catch(:forward) do
+        with_hooks(:request) { perform! }
+        status, header, body = response.finish
+        return [status, header, request.head? ? [] : body]
+      end
+
+      @app ? @app.call(env) : error!(NotFound.new(@request.path_info))
+    end
+
+    # Halt routing with response
+    #
+    # Possible responses:
+    #   * String or Object with #each
+    #   * Symbol
+    #   * [Symbol, String or Object with #each]
+    #
+    # @param [Symbol, String, #each] *response
+    # @return [void]
+    # @api public
+    def halt(*response)
+      throw :halt, response.length == 1 ? response.first : response
+    end
+
+    # Redirect to uri
+    #
+    # @param uri Target uri
+    # @return [void]
+    # @api public
+    def redirect(uri)
+      throw :redirect, uri
+    end
+
+    # Pass to next matching route
+    #
+    # @return [void]
+    # @api public
+    def pass
+      throw :pass
+    end
+
+    # Forward to next application on the rack stack
+    #
+    # @return [void]
+    # @api public
+    def forward
+      throw :forward
+    end
+
+    private
+
+    def error!(error)
+      response.status = Rack::Utils.status_code(error.try(:status) || :internal_server_error)
+      handle_error(error)
+    end
+
+    def perform!
+      result = catch(:halt) do
+        uri = catch(:redirect) do
+          with_hooks(:routing) { route! }
+        end
+        response.redirect uri
+        nil
+      end
+
+      return if !result
+      if result.respond_to?(:to_str)
+        response.body = [result]
+      elsif result.respond_to?(:to_ary)
+        result = result.to_ary
+        if result.length == 2 && Symbol === result.first
+          response.status = Rack::Utils.status_code(result.first)
+          response.body = result.last
+        else
+          response.body = result
+        end
+      elsif result.respond_to?(:each)
+        response.body = result
+      elsif Symbol === result
+        response.status = Rack::Utils.status_code(result)
+      else
+        raise TypeError, "#{result.inspect} not supported"
+      end
+    end
+
+    def route!
+      path = unescape(request.path_info)
+      method = request.request_method
+      self.class.router[method].find(path) do |name, params, function|
+        @params = @original_params.merge(params)
+        catch(:pass) do
+          with_hooks(:action, method.downcase.to_sym, name) do
+            halt function.bind(self).call
+          end
+        end
+      end if self.class.router[method]
+      raise NotFound, path
+    rescue ::Exception => error
+      halt error!(error)
+    end
+
+    class Router
+      SYNTAX = {
+        '\(' => '(?:', '\)' => ')?',
+        '\{' => '(?:', '\}' => ')',
+        '\|' => '|'
+      }.freeze
+
+      include Enumerable
+      attr_reader :head, :tail
+
+      def initialize
+        @head, @tail = [], []
+      end
+
+      def find(path)
+        each do |name, pattern, keys, function|
+          if match = pattern.match(path)
+            params = {}
+            keys.zip(match.captures.to_a).each {|k, v| params[k] = v if !v.blank? }
+            yield(name, params, function)
+          end
+        end
+      end
+
+      def each(&block)
+        @head.each(&block)
+        @tail.each(&block)
+      end
+
+      def add(function, path, patterns = {})
+        tail = patterns.delete(:tail)
+        pattern = Regexp.escape(path)
+        SYNTAX.each_pair {|k,v| pattern.gsub!(k, v) }
+        keys = []
+        pattern.gsub!(/:(\w+)/) do
+          keys << $1
+          patterns.key?($1) ? "(#{patterns[$1]})" : "([^/?&#\.]+)"
+        end
+        pattern = /^#{pattern}$/
+
+        if i = @head.index {|x| x.first == path }
+          @head[i] = [path, pattern, keys, function]
+        elsif i = @tail.index {|x| x.first == path }
+          @tail[i] = [path, pattern, keys, function]
+        else
+          (tail ? @tail : @head) << [path, pattern, keys, function]
+        end
+      end
+    end
+
+    module ClassMethods
+      def router
+        @router ||= {}
+      end
+
+      def patterns(patterns = nil)
+        @patterns ||= Hash.with_indifferent_access
+        patterns ? @patterns.merge!(patterns) : @patterns
+      end
+
+      def get(path, patterns = {}, &block)
+        add_route('GET',  path, patterns, &block)
+        add_route('HEAD', path, patterns, &block)
+      end
+
+      def put(path, patterns = {}, &block)
+        add_route('PUT', path, patterns, &block)
+      end
+
+      def post(path, patterns = {}, &block)
+        add_route('POST', path, patterns, &block)
+      end
+
+      def delete(path, patterns = {}, &block)
+        add_route('DELETE', path, patterns, &block)
+      end
+
+      private
+
+      def add_route(method, path, patterns = {}, &block)
+        name = "#{method} #{path}"
+        if method_defined?(name)
+          redefine_method(name, &block)
+        else
+          define_method(name, &block)
+        end
+        (router[method] ||= Router.new).add(instance_method(name), path, self.patterns.merge(patterns))
+      end
+    end
+  end
+end

data/lib/olelo/templates.rb

@@ -0,0 +1,30 @@
+module Olelo
+  module Templates
+    class << self
+      attr_reader :cache
+      attr_accessor :loader
+
+      def enable_caching
+        @cache = {}
+      end
+
+      def with_caching(id)
+        return cache[id] if cache && cache[id]
+        template = yield
+        cache[id] = template if cache
+        template
+      end
+    end
+
+    def render(name, options = {}, &block)
+      locals = options.delete(:locals) || {}
+      name = "#{name}.slim"
+      path = Templates.loader.context.to_s/name
+      id = [path, options.to_a].flatten.join('-')
+      template = Templates.with_caching(id) do
+        Slim::Template.new(path, options) { Templates.loader.load(name) }
+      end
+      template.render(self, locals, &block).html_safe
+    end
+  end
+end