porthos 3.0.0.beta

data/lib/porthos/page_renderer.rb

@@ -0,0 +1,66 @@
+module Porthos
+  class PageRenderer
+
+    class_attribute :_available_methods
+    self._available_methods = {}
+
+    def self.register_methods(*methods)
+      self._available_methods[self.name] = [] if self.available_methods.empty?
+      self._available_methods[self.name].push *methods
+    end
+
+    def self.available_methods
+      self._available_methods[self.name] || []
+    end
+
+    class_attribute :required_objects
+    self.required_objects = [:page_template]
+
+    attr_reader :controller,
+                :params,
+                :objects
+
+    def initialize(controller, objects = {})
+      @controller = controller
+      @params     = controller.params
+      @objects    = objects.to_options
+      validate_required_objects
+      create_instance_variables_for_objects
+      self.class.available_methods.each { |m| self.send(m) } # pre fetch everything before render time
+      after_initialize
+      self
+    end
+
+    def layout_class
+      @layout_class ||= @page_template.handle
+    end
+
+    def title
+      @title ||= @page_template.title
+    end
+
+    def page_id
+      'pages-index'
+    end
+
+    def create_instance_variables_for_objects
+      objects.each do |key, object|
+        self.class.send(:attr_reader, key)
+        instance_variable_set("@#{key.to_s}".to_sym, object)
+      end
+    end
+
+  protected
+
+    def after_initialize
+    end
+
+    def validate_required_objects
+      object_keys = @objects.keys
+      self.class.required_objects.each do |object_name|
+        raise "Missing required object #{object_name.to_s}" unless object_keys.include?(object_name)
+      end
+    end
+
+  end
+end

data/lib/porthos/public.rb

@@ -0,0 +1,56 @@
+module Porthos
+  module Public
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+
+      def root_node
+        @root_node ||= Node.root
+      end
+
+      def root_nodes
+        @root_nodes ||= [root_node] + root_node.children
+      end
+
+      def node
+        @node ||= params[:node] ? Node.find_by_id(params[:node][:id]) : nil
+      end
+
+      def nodes
+        # fetch the children of the selected top level node (it later recursive renders all nodes belonging to the trail)
+        @nodes ||= unless node == root_node # dont fetch children for the root node (that's all nodes dummy!)
+          node_ancestors.any? ? node_ancestors.first.children : node.children
+        else
+          []
+        end
+      end
+
+      def trail
+        unless defined?(@trail)
+          # fetch an ordered trail (top to bottom) of nodes
+          @trail = if node && node.ancestors.any?
+            node.ancestors.dup.tap do |ancestors|
+              ancestors.shift
+              ancestors << node
+            end
+          else
+            [node]
+          end.compact
+        end
+        @trail
+      end
+
+      def breadcrumbs
+        @breadcrumbs ||= trail.map { |n| ["/#{n.url}", n.name] }
+      end
+
+    end
+
+    included do
+      helper_method :root_node, :root_nodes, :nodes, :node
+      helper_method :trail, :breadcrumbs
+      layout 'public'
+    end
+
+  end
+end

data/lib/porthos/redirects.rb

@@ -0,0 +1,23 @@
+module Porthos
+  class Redirects
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # redirect = Redirect.connection.select_all("SELECT * FROM redirects WHERE path = '#{env['PATH_INFO']}'").first
+      # if redirect and (redirect_path = redirect['target'])
+      #   if not env['QUERY_STRING'].blank?
+      #     if redirect_path.include?('?')
+      #       redirect_path.gsub!('?', "?#{env['QUERY_STRING']}&")
+      #     else
+      #       redirect_path << "?#{env['QUERY_STRING']}"
+      #     end
+      #   end
+      #   [301, {'Content-Type' => 'text/html', 'Location' => redirect_path}, ['You are being redirected.']]
+      # else
+        @app.call(env)
+      # end
+    end
+  end
+end

data/lib/porthos/routing.rb

@@ -0,0 +1,256 @@
+module Porthos
+  module Routing
+    # A rule is a hash with three keys
+    # :test => Regexp to match the path
+    # :matches => Array of names (param keys) for each match for the path regexp.
+    # The first match should always be "url" (anything) before the params
+    # :controller => The controller name for which this rule applies to
+    # Example:
+    #   {
+    #     :test => /(^.*)\/(\d{4})\-(\d{2})\-(\d{2})/,
+    #     :matches => ['url', 'year', 'month', 'day'],
+    #     :controller => 'test_posts'
+    #   }
+    mattr_accessor :rules
+    class Rule
+      include Comparable
+      attr_accessor :path,
+                    :constraints,
+                    :controller,
+                    :action,
+                    :namespace,
+                    :prefix
+
+      def <=>(other_rule)
+        self.compare_string <=> other_rule.compare_string
+      end
+
+      def initialize(attrs = {})
+        attrs.symbolize_keys.reverse_merge(:constraints => {}).each do |key, value|
+          instance_variable_set("@#{key.to_s}".to_sym, value)
+        end
+      end
+
+      def match?(attrs)
+        attrs.each do |key, value|
+          "@#{key.to_s}".to_sym.tap do |variable_name|
+            return false if !instance_variables.include?(variable_name) or
+              instance_variable_get(variable_name) != value
+          end
+        end
+        true
+      end
+
+      def param_keys
+        @param_keys ||= path.scan(/:(\w+)/).flatten.map(&:to_sym)
+      end
+
+      def computed_path(node, params)
+        [node.url, translated_path].join('/').tap do |computed_path|
+          template = computed_path
+          constraints.each do |key, value|
+            if params[key]
+              value_for_key = if params[key].respond_to?(:to_param)
+                params[key].to_param
+              else
+                params[key].to_s
+              end
+              template.gsub!(":#{key.to_s}", value_for_key)
+            end
+          end
+          template = "/#{template}" unless template[0...1] == '/'
+          computed_path.replace(template)
+        end
+      end
+
+      def regexp_template
+        @regexp_template ||= "^(#{regexp_prefix})/#{translated_path}(\/|)$".tap do |regexp_template|
+          template = regexp_template
+          constraints.each do |key, value|
+            template.gsub!(":#{key.to_s}", value)
+          end
+          regexp_template.replace(template)
+        end.mb_chars
+      end
+
+      def regexp_prefix
+        @regexp_prefix ||= prefix ? "/#{translate(prefix)}" : '.*|'
+      end
+
+      def translated_path
+        @translated_path ||= translate(path)
+      end
+
+    private
+
+      def compare_string
+        @compare_string ||= "#{path}-#{controller}-#{action}"
+      end
+
+      def translate(i18n_string)
+        i18n_string.dup.tap do |translated_string|
+          template = translated_string
+          i18n_string.scan(/\%{([\w\.]+)}/).flatten.each do |string|
+            template.gsub!("%{#{string}}", I18n.t("routes.#{string}"))
+          end
+          translated_string.replace(template)
+        end
+      end
+
+      class << self
+        def from_hash(attrs)
+          attrs.kind_of?(Hash) ? new(attrs) : attrs
+        end
+      end
+
+    end
+
+    class Rules
+      include Enumerable
+
+      def initialize(rules = [])
+        @default_options = {}
+        @rules = rules.map { |r| Rule.from_hash(r) }
+      end
+
+      def reset!
+        @rules = []
+      end
+
+      def size
+        @rules.size
+      end
+
+      def last
+        @rules[size-1]
+      end
+
+      def each
+        @rules.each { |r| yield r }
+      end
+
+      def <<(rule)
+        @rules << Rule.from_hash(rule)
+      end
+
+      def push(args)
+        if args.respond_to?(:map)
+          @rules += args.map { |r| Rule.from_hash(r) }
+        else
+          self.push [args]
+        end
+      end
+
+      def with(options = {}, &block)
+        @default_options = options
+        instance_exec(&block)
+        @default_options = {}
+      end
+
+      def match(path, options)
+        self << { :path => path }.tap do |new_rule|
+          new_rule.merge!(@default_options)
+          new_rule.merge!(options.delete(:to))
+          new_rule.merge!(options)
+        end
+      end
+
+      def draw(&block)
+        instance_exec(&block)
+      end
+
+      def sorted
+       sort_by { |r| (r.constraints ? r.constraints.keys.size : 0)+r.path.size }.reverse
+      end
+
+      def find_matching_params(params)
+        param_keys = params.keys
+        sorted.detect do |rule|
+          (rule.action.blank? || rule.action == params[:action]) and
+          (rule.controller.blank? || rule.controller == params[:controller]) and
+          rule.constraints.keys.all? { |key| param_keys.include?(key) }
+        end
+      end
+
+    end
+
+    self.rules = Rules.new([
+
+      {
+        :path => ":id",
+        :constraints => {
+          :id => '([a-z0-9\-\_]+)'
+        },
+        :controller => 'pages',
+        :action => 'show'
+      },
+      {
+        :path => ":year/:month/:day/:id",
+        :constraints => {
+          :year => '(\d{4})',
+          :month => '(\d{2})',
+          :day => '(\d{2})',
+          :id => '([a-z0-9\-\_]+)'
+        },
+        :controller => 'pages',
+        :action => 'show'
+      },
+      {
+        :path => ":year/:month/:day",
+        :constraints => {
+          :year => '(\d{4})',
+          :month => '(\d{2})',
+          :day => '(\d{2})'
+        },
+        :controller => 'pages'
+      },
+      {
+        :path => ":year/:month",
+        :constraints => {
+          :year => '(\d{4})',
+          :month => '(\d{2})'
+        },
+        :controller => 'pages'
+      },
+      {
+        :path => ":year",
+        :constraints => {
+          :year => '(\d{4})'
+        },
+        :controller => 'pages'
+      },
+      {
+        :path => '%{categories}',
+        :controller => 'pages',
+        :action => 'categories'
+      },
+      {
+        :path => "%{categories}/:id",
+        :constraints => {
+          :id => '([a-z0-9\-\_\s\p{Word}]+)'
+        },
+        :controller => 'pages',
+        :action => 'category'
+      }
+    ])
+
+    # Find a rule definition that matches the path
+    # Returns a hash of params
+    def self.recognize(path, restrictions = {})
+      path = path.to_s.mb_chars.downcase
+      return self.rules.sorted.collect do |rule|
+        matches = path.scan(Regexp.new(rule.regexp_template)).flatten
+        next unless (matches.any? and rule.match?(restrictions))
+        {}.tap do |params|
+          params[:url] = matches.shift.gsub(/^\//,'')
+          rule.param_keys.each_with_index do |key, i|
+            params[key] = matches[i]
+          end
+          params[:action] = rule.action if rule.action.present?
+          params[:controller] = rule.controller if rule.controller.present?
+          params[:namespace] = rule.namespace if rule.namespace.present?
+        end
+      end.compact
+    end
+  end
+end

data/lib/porthos/s3_storage.rb

@@ -0,0 +1,61 @@
+module Porthos
+
+  mattr_accessor :s3_storage
+
+  class S3Storage
+
+    attr_accessor :bucket_name,
+                  :access_key_id,
+                  :secret_access_key
+
+    def initialize(options)
+      options.to_options.each do |key, value|
+        send("#{key.to_s}=", value) if respond_to?("#{key.to_s}=")
+      end
+    end
+
+    def store(source, target)
+      file = bucket.objects.build(target)
+      file.content = source
+      file.save
+    end
+
+    def details(key)
+      bucket.objects.find(key)
+    end
+
+    def url(key)
+      "http://#{bucket_name}.s3.amazonaws.com/#{key}"
+    end
+
+    def exists?(key)
+      begin
+        bucket.objects.find(key)
+        true
+      rescue ::S3::Error::NoSuchKey
+        false
+      end
+    end
+
+    def destroy(key)
+      file = bucket.objects.find(key)
+      file ? file.destroy : false
+    end
+
+  protected
+
+    def bucket
+      @bucket ||= service.buckets.find(bucket_name).tap do |bucket|
+        bucket.save(:location => 'eu') unless bucket.exists?
+      end
+    end
+
+    def service
+      @service ||= S3::Service.new({
+        :access_key_id => access_key_id,
+        :secret_access_key => secret_access_key
+      })
+    end
+
+  end
+end