porthos 3.0.0.beta

data/lib/porthos/engine.rb

@@ -0,0 +1,56 @@
+module Porthos
+  class Engine < Rails::Engine
+    config.autoload_paths += Dir[config.root.join('app', 'models', '{**}')]
+    config.i18n.default_locale = "sv-SE"
+    config.i18n.fallbacks = true
+    config.use_fulltext_search = false
+
+    config.active_record.identity_map = true
+
+    config.porthos = ::Porthos::Config
+
+    rake_tasks do
+      load Porthos.root.join("lib/tasks/porthos_tasks.rake")
+    end
+
+    initializer "porthos.redirects" do |app|
+      app.middleware.use Porthos::Redirects
+    end
+
+    initializer 'porthos.helpers' do |app|
+      ActiveSupport.on_load :action_view do
+        include Porthos::ApplicationHelper
+      end
+    end
+
+    initializer 'porthos.active_record' do |app|
+      ActiveSupport.on_load :active_record do
+        include Porthos::ActiveRecord::Restrictions
+        include Porthos::ActiveRecord::Settingable
+      end
+    end
+
+    initializer 'porthos.mongo_mapper' do |app|
+      ActiveSupport.on_load :mongo_mapper do
+        ::MongoMapper::Document.plugin ActiveModel::Observing
+        ::MongoMapper::Document.plugin Porthos::MongoMapper::Plugins::ActsAsUri
+      end
+      config.after_initialize do
+        ::Porthos.config.instantiate_observers
+        ActionDispatch::Callbacks.to_prepare do
+          ::Porthos.config.instantiate_observers
+        end
+      end
+    end
+
+    initializer 'porthos.authentication' do |app|
+      app.middleware.use ::Warden::Manager do |manager|
+        manager.default_strategies :password
+        manager.failure_app = Porthos::Authentication::UnauthorizedRequest
+      end
+      ActiveSupport.on_load :action_controller do
+        include Porthos::Authentication::Helpers
+      end
+    end
+  end
+end

data/lib/porthos/helpers/application_helper.rb

@@ -0,0 +1,140 @@
+module Porthos
+  module ApplicationHelper
+
+    def previous_view_path(default_path = '/')
+      params[:return_to] || default_path
+    end
+
+    def admin_assets_path_with_session_key(arguments = {})
+      session_key = Rails.application.config.session_options[:key]
+      admin_assets_path({session_key => cookies[session_key], request_forgery_protection_token => form_authenticity_token}.merge(arguments))
+    end
+
+    def nested_list_of(collection, options = {}, html_options = {}, &block)
+      options = {
+        :expand_all     => false,
+        :allow_inactive => false,
+        :first_level    => true,
+        :node_class     => collection.first.class.to_s.underscore,
+        :end_points     => [],
+        :trail          => [],
+        :except         => [],
+        :trailed_class  => 'trailed'
+      }.merge(options)
+
+      html_options = {
+        :id => collection.first.class.to_s.underscore.pluralize
+      }.merge(html_options)
+
+      first_level = options.delete(:first_level)
+      if first_level
+        if options[:end_points]
+          options[:end_points] = [options[:end_points]] unless options[:end_points].is_a?(Array)
+          options[:end_points].collect { |item| options[:trail] += (item.ancestors << item) }
+        end
+      end
+      html_options.delete(:id) unless first_level
+
+      ret = collection.collect do |item|
+        next if (item.respond_to?(:access_status) and item.access_status == 'inactive') and not options[:allow_inactive] == true
+        next if item == options[:except] || (options[:except].respond_to?(:include?) && options[:except].include?(item))
+        in_trail = options[:trail].include?(item)
+        rendered_item = capture(item, &block)
+        if (options[:expand_all] and item.children.any?) or ( in_trail and item.children.any? )
+          rendered_item += nested_list_of(item.children, options.merge({ :first_level => false }), &block)
+        end
+        if item.respond_to?(:access_status)
+          status_class = unless in_trail
+            item.access_status
+          else
+            "#{item.access_status} #{options[:trailed_class]}"
+          end
+        end
+        node_container_options = {
+          :class => [
+            options[:node_class],
+            status_class
+          ].join(" ")
+        }
+        if options[:node_id].nil?
+          node_container_options[:id] = "#{item.class.to_s.underscore}_#{item.id}"
+        elsif not options[:node_id].blank?
+          node_container_options[:id] = "#{options[:node_id]}_#{item.id}"
+        end
+
+        content_tag('li', rendered_item, node_container_options)
+      end.join("\n").html_safe
+
+      #list = content_tag('ul', ret, html_options)
+      #first_level ? concat(list) : list
+      content_tag('ul', ret, html_options)
+    end
+
+    def page_id
+      @page_id ||= controller.class.to_s.underscore.gsub(/_controller$/, '').gsub(/admin\//, '')
+      ' id="'+@page_id+'_view"'.html_safe
+    end
+
+    def page_class(css_class = false)
+      body_class = []
+      body_class << css_class   if css_class
+      body_class << @page_class if @page_class
+      body_class << controller.action_name.underscore
+      if Rails.env.development?
+        body_class << 'debug' if params[:debug]
+        body_class << 'grid' if params[:grid]
+      end
+      ' class="'+body_class.join(" ")+'"'.html_safe if body_class.size > 0
+    end
+
+    def body_attributes
+      "#{page_id}#{page_class}".html_safe
+    end
+
+    def flash_messages(type = "")
+      if type.blank?
+        flash.collect do |type, message|
+          content_tag('p', message, :class => "flash #{type}", :id => 'flash')
+        end.join("\n").html_safe
+      elsif flash[type.to_sym]
+        content_tag('p', flash[type.to_sym], :class => "flash #{type}", :id => 'flash').html_safe
+      end
+    end
+
+    def installation_specific_stylesheet_link_tag
+      path = File.join(Rails.root, 'public/stylesheets/porthos_extensions.css')
+      stylesheet_link_tag(js_file) if File.exists?(path)
+    end
+
+    # RIPPED FROM rails_admin (https://github.com/sferik/rails_admin)
+    # A Helper to load from a CDN but with fallbacks in case the primary source is unavailable
+    # The best of both worlds - fast clevery cached service from google when available and the
+    # ability to work offline too.
+    #
+    # @example Loading jquery from google
+    #   javascript_fallback "http://ajax.googleapis.com/ajax/libs/jquery/1.4.3/jquery.min.js",
+    #     "/javascripts/jquery-1.4.3.min.js",
+    #     "typeof jQuery == 'undefined'"
+    # @param [String] primary a string to be passed to javascript_include_tag that represents the primary source e.g. A script on googles CDN.
+    # @param [String] fallback a path to the secondary javascript file that is (hopefully) more resilliant than the primary.
+    # @param [String] test a test written in javascript that evaluates to true if it is necessary to load the fallback javascript.
+    # @reurns [String] the resulting html to be inserted into your page.
+    def javascript_fallback(primary, fallback, test)
+      html = javascript_include_tag( primary )
+      html << "\n" << content_tag(:script, :type => "text/javascript") do
+        %Q{
+            if (#{test}) {
+              document.write(unescape("%3Cscript src='#{fallback}' type='text/javascript'%3E%3C/script%3E"));
+            }
+        }.gsub(/^ {8}/, '').html_safe
+      end
+      html+"\n"
+    end
+
+    def page_url_parent(page)
+      pages_url(:handle => page.handle).tap do |url|
+        url << '/' unless url.end_with?('/')
+      end
+    end
+  end
+end

data/lib/porthos/mongo_mapper/acts_as_uri.rb

@@ -0,0 +1,59 @@
+require 'stringex'
+module Porthos
+  module MongoMapper
+    module Plugins
+      module ActsAsUri
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def acts_as_uri(attribute, options = {})
+            class_attribute :attribute_to_uriify
+            class_attribute :acts_as_uri_options
+
+            self.acts_as_uri_options = options.to_options.reverse_merge({
+              :source => attribute,
+              :target => 'uri',
+              :duplicate_count_separator => '-',
+              :only_when_blank => false
+            })
+
+            if self.acts_as_uri_options[:sync_uri]
+              before_validation :generate_uri
+            else
+              before_validation :generate_uri, :on => :create
+            end
+
+            if embeddable?
+              validate :uniqueness_of_uri_among_siblings
+            else
+              validation_options = {
+                :case_sensitive => false,
+                :allow_nil => true
+              }
+              validation_options[:scope] = acts_as_uri_options[:scope] if acts_as_uri_options[:scope]
+              validates_uniqueness_of acts_as_uri_options[:target], validation_options
+            end
+          end
+        end
+
+        module InstanceMethods
+        private
+          def generate_uri
+            options = self.class.acts_as_uri_options
+            base_url = self.send options[:target]
+            base_url = self.send(options[:source]).to_s.to_url if base_url.blank? || !options[:only_when_blank]
+            write_attribute(options[:target], base_url)
+          end
+
+          def uniqueness_of_uri_among_siblings
+            options = self.class.acts_as_uri_options
+            current_uri = self.send options[:target]
+            if _parent_document && _parent_document.send(self.model_name.tableize).one? { |s| s.id != self.id && s.send(options[:target]) == current_uri }
+              errors.add(options[:target], :taken)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/porthos/mongo_mapper/callbacks.rb

@@ -0,0 +1,13 @@
+module Porthos
+  module MongoMapper
+    module Callbacks
+      CALLBACKS = [
+        :before_validation, :after_validation,
+        :before_create, :after_create,
+        :before_destroy, :after_destroy,
+        :before_save, :after_save,
+        :before_update, :after_update
+      ]
+    end
+  end
+end

data/lib/porthos/mongo_mapper/extensions.rb

@@ -0,0 +1,58 @@
+module Porthos
+  module MongoMapper
+    module Extensions
+
+      module SymbolOperator
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def to_mongo(value)
+            if value.is_a?(SymbolOperator)
+              value.to_mongo
+            else
+              typecasted = if value.acts_like?(:string)
+                field, operator = value.to_s.split('.')
+                field.present? ? self.new(field.to_sym, operator) : nil
+              elsif value.is_a?(Hash)
+                value.to_options!
+                if value[:field] && value[:operator]
+                  self.new(value[:field].to_sym, value[:operator].to_s)
+                else
+                  nil
+                end
+              end
+              typecasted.is_a?(self) ? typecasted.to_mongo : nil
+            end
+          end
+
+          def from_mongo(value)
+            if value.is_a?(self)
+              value
+            elsif value.nil? || value.to_s == ''
+              nil
+            else
+              field, operator = value.split('.')
+              field && operator ? self.new(field.to_sym, operator) : nil
+            end
+          end
+        end
+
+        module InstanceMethods
+          def to_mongo
+            "#{field.to_s}.#{operator}"
+          end
+        end
+      end
+
+    end
+  end
+end
+
+class SymbolOperator
+  include Porthos::MongoMapper::Extensions::SymbolOperator
+
+  def ==(other)
+    other.class == SymbolOperator && field == other.field && operator == other.operator
+  end
+
+end

data/lib/porthos/mongo_mapper/instructable.rb

@@ -0,0 +1,36 @@
+module Porthos
+  module MongoMapper
+
+    class Instruction
+      include ::MongoMapper::Document
+      key :body, String
+    end
+
+    module Plugins
+      module Instructable
+        extend ActiveSupport::Concern
+
+        module InstanceMethods
+
+          def instruction_body
+            @instruction_body ||= instruction.body if instruction
+          end
+
+          def instruction_body=(body)
+            if instruction
+              instruction.update_attributes(:body => body)
+            else
+              self.instruction = Porthos::MongoMapper::Instruction.create(:body => body)
+            end
+          end
+        end
+
+        included do
+          key :instruction_id, ObjectId
+          belongs_to :instruction, :class_name => 'Porthos::MongoMapper::Instruction'
+        end
+      end
+    end
+
+  end
+end

data/lib/porthos/mongo_mapper/observer.rb

@@ -0,0 +1,34 @@
+module Porthos
+  module MongoMapper
+    class Observer < ActiveModel::Observer
+
+    protected
+
+      def observed_classes
+        super.tap do |klasses|
+          klasses += klasses.map { |klass| klass.descendants }.flatten
+        end
+      end
+
+      def add_observer!(klass)
+        super and define_callbacks klass
+      end
+
+      def define_callbacks(klass)
+        observer = self
+        observer_name = observer.class.name.underscore.gsub('/', '__')
+        Porthos::MongoMapper::Callbacks::CALLBACKS.each do |callback|
+          next unless respond_to?(callback)
+          callback_meth = :"_notify_#{observer_name}_for_#{callback}"
+          unless klass.respond_to?(callback_meth)
+            klass.send(:define_method, callback_meth) do |&block|
+              observer.send(callback, self, &block)
+            end
+            klass.send(callback, callback_meth)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/porthos/mongo_mapper/taggable.rb

@@ -0,0 +1,136 @@
+require 'ostruct'
+
+module Porthos
+  module MongoMapper
+    class Tag
+      include ::MongoMapper::EmbeddedDocument
+      key :name, String
+      key :namespace, String
+    end
+
+    module Taggable
+      mattr_accessor :delimiter
+      self.delimiter = ' '
+
+      module Plugin
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          def taggable(_options = {})
+            has_many :_tags, :class_name => 'Porthos::MongoMapper::Tag'
+            after_save :cache_tags_if_changed
+
+            class_eval <<-EOV
+              def assign_with_read_write_tag_names(attrs={})
+                attrs.each do |key, value|
+                  if _match = match_tag_names_methods(key)
+                    self.send(_match[2]+'=', value, _match[1])
+                    attrs.delete(key)
+                  end
+                end if attrs
+                assign_without_read_write_tag_names(attrs)
+              end
+              alias_method_chain :assign, :read_write_tag_names
+            EOV
+          end
+
+          def tagged_with(tags_list, options = {})
+            namespace = options.delete(:namespace)
+            self.where(:'_tags.name'.all => tags_list, :'_tags.namespace' => namespace)
+          end
+
+          def all_tags_collection_name
+            "#{self.name}_tags".downcase
+          end
+
+          def cache_tags!
+            options = { :raw => true, :out => { :merge => all_tags_collection_name } }
+            collection.map_reduce(self.tags_with_count_map, self.tags_with_count_reduce, options)
+          end
+
+          def all_tags(selector = {}, options = {})
+            database[all_tags_collection_name].find(selector, options).collect do |tag|
+              OpenStruct.new(:name => tag['value']['name'], :count => tag['value']['count'].to_i, :namespace => tag['value']['namespace'])
+            end
+          end
+
+          def tags_by_count(options = {})
+            all_tags({:'value.namespace' => options.delete(:namespace)}.merge(options), {:sort => ['value.count', :desc]})
+          end
+
+          def tags_with_count_map
+            "function() {
+               if (!this._tags) { return; }
+               for (index in this._tags) {
+                 emit(this._tags[index].name+this._tags[index].namespace, {count: 1, name: this._tags[index].name, namespace: this._tags[index].namespace});
+               }
+             }"
+          end
+
+          def tags_with_count_reduce
+            "function(previous, current) {
+               var result = {count: 0, name: '', namespace: ''};
+               for (index in current) {
+                 result.count += current[index].count;
+                 result.name = current[index].name;
+                 result.namespace = current[index].namespace;
+               }
+               return result;
+             }"
+          end
+        end
+
+        module InstanceMethods
+          def method_missing_with_read_write_tag_names(method, *args)
+            if _match = match_tag_names_methods(method)
+              self.send(_match[2].to_sym, *(args << _match[1]))
+            else
+              method_missing_without_read_write_tag_names(method, *args)
+            end
+          end
+          alias_method_chain :method_missing, :read_write_tag_names
+
+          def tags(namespace = nil)
+            _tags.find_all { |t| t.namespace == namespace }
+          end
+
+          def tag_names(namespace = nil)
+            tags(namespace).collect { |tag| tag.name.include?(Porthos::MongoMapper::Taggable.delimiter) ? "\"#{tag.name}\"" : tag.name }.join(Porthos::MongoMapper::Taggable.delimiter)
+          end
+
+          def tag_names=(in_tags, namespace = nil)
+            tags_array = in_tags.is_a?(String) ? split_tags(in_tags) : in_tags
+            self._tags.delete_if{|t| t.namespace == namespace}
+            self._tags += tags_array.collect { |tag_name| Porthos::MongoMapper::Tag.new(:name => tag_name, :namespace => namespace)}
+            @tags_changed = true
+          end
+
+          def tags_changed?
+            @tags_changed
+          end
+
+        protected
+          def split_tags(value)
+            tag_list = []
+            [/\s*#{Porthos::MongoMapper::Taggable.delimiter}\s*(['"])(.*?)\1\s*/, /^\s*(['"])(.*?)\1\s*#{Porthos::MongoMapper::Taggable.delimiter}?/].each do |exp|
+              value.gsub!(exp) { tag_list << $2; "" }
+            end
+            tag_list + value.strip.split(Porthos::MongoMapper::Taggable.delimiter).collect(&:strip).uniq.compact
+          end
+
+          def match_tag_names_methods(possible_method_name)
+            possible_method_name.to_s.match(/(.*)_(tag_names=|tag_names)$/)
+          end
+
+          def cache_tags_if_changed
+            if tags_changed?
+              Rails.env.production? ? self.class.delay.cache_tags! : self.class.cache_tags!
+            end
+          end
+        end
+      end
+    end
+  end
+end
+MongoMapper::Document.plugin(Porthos::MongoMapper::Taggable::Plugin)