formol 0.0.4

data/lib/formol/integration/user.rb

@@ -0,0 +1,76 @@
+module Formol
+  module Integration
+    module User
+      extend ActiveSupport::Concern
+
+      included do
+        #Modules
+        include Formol::Permissions::User
+        
+        #Associations
+        has_many :topics,             :class_name   => 'Formol::Topic'
+        has_many :posts,              :class_name   => 'Formol::Post'
+        has_many :subscriptions,      :class_name   => 'Formol::Topic::Subscription',
+                                      :foreign_key  => 'subscriber_id',
+                                      :dependent    => :destroy
+        has_many :subscribed_topics,  :through      => :subscriptions,
+                                      :source       => :topic,
+                                      :class_name   => 'Formol::Topic'
+        has_one :preference,          :class_name   => 'Formol::UserPreference'
+        
+        #Aliasing
+        alias_method_chain :preference, :auto_allocate
+        
+        #Privacy
+        private :subscribed_topic_ids
+        private :unread_forums
+        private :unread_topics
+      end
+      
+      module InstanceMethods
+        # always return a preference object to avoid nil
+        # preference has all values defaulted for fallback behavior
+        def preference_with_auto_allocate
+          p = preference_without_auto_allocate
+
+          if p.nil?
+            p = build_preference 
+            p.save
+          end
+
+          p
+        end
+
+        def has_read_topic?(topic)
+          !unread_topics(topic.forum_id).include?(topic.id)
+        end
+
+        def has_read_forum?(forum)
+          !unread_forums.include?(forum.id)
+        end
+
+        def has_subscribed_to?(topic)
+          subscribed_topic_ids.include?(topic.id)
+        end
+
+        private
+
+        def subscribed_topic_ids
+          # we can load all subscribed topics instead of acting 'by forum'
+          # a user won't have 1 billion of subscriptions and we just collect ids
+          @subscribed_topic_ids ||= subscribed_topics.select('formol_topics.id').collect(&:id)
+        end
+
+        def unread_forums
+          @read_forum_ids ||= Formol::Forum.unread(self).collect(&:id)
+        end
+
+        def unread_topics(forum_id)
+          @unread_topic_ids ||= {}
+
+          @unread_topic_ids[forum_id] ||= Formol::Topic.unread(self, :forum_id => forum_id).collect(&:id)
+        end
+      end
+    end
+  end
+end

data/lib/formol/integration.rb

@@ -0,0 +1 @@
+require 'formol/integration/user'

data/lib/formol/permissions/controllers.rb

@@ -0,0 +1,30 @@
+module Formol
+  module Permissions
+    class NotAuthorizedError < Exception; end
+    
+    module Controllers
+      extend ActiveSupport::Concern
+      
+      included do
+        helper_method :formol_authorized?
+      end
+      
+      module InstanceMethods
+        def formol_authorized?(user, rights, obj = nil)
+          user = Formol.config.user.new(:formol_profile => :default) if user.nil?
+          
+          rights = [rights]
+          rights.flatten!
+          
+          rights.any?{ |r| user.formol_allowed_to?(r, obj) }
+        end
+        
+        def formol_authorize!(user, rights, obj = nil)
+          unless formol_authorized?(user, rights, obj)
+            raise Formol::Permissions::NotAuthorizedError.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/formol/permissions/manager.rb

@@ -0,0 +1,29 @@
+module Formol    
+  module Permissions
+    class Manager
+      attr_accessor :user
+      cattr_accessor :profiles
+      
+      def initialize(user)
+        self.user = user
+        @profile_name = (user && user.persisted? ? user.formol_profile : :default).to_sym
+      end
+      
+      def able_to?(right, obj = nil)
+        return true if has_right?(:administrate)
+        
+        respond_to?(m = :"able_to_#{right}?") ? send(m, obj) : has_right?(right)
+      end
+      
+      protected
+      
+      def profile
+        self.class.profiles[@profile_name]
+      end
+      
+      def has_right?(right)
+        profile.has_right?(right.to_sym)
+      end
+    end
+  end
+end

data/lib/formol/permissions/profile.rb

@@ -0,0 +1,24 @@
+module Formol
+  module Permissions
+    class Profile
+      attr_reader :rights
+      
+      def initialize(name, rights = [])
+        @name   = name.to_sym
+        @rights = rights.collect(&:to_sym)
+      end
+
+      def has_right?(right)
+        @rights.include?(right.to_sym)
+      end
+
+      def <<(right)
+        @rights << right.to_sym
+      end
+
+      def delete(right)
+        @rights.delete(right.to_sym)
+      end
+    end
+  end
+end

data/lib/formol/permissions/profiles.rb

@@ -0,0 +1,44 @@
+module Formol
+  module Permissions
+    class Profiles
+      def initialize
+        @profiles = {}
+      end
+      
+      def self.from_hash(hash)
+        p = Profiles.new
+        
+        hash.each do |name, opts|
+          p.add_profile(name, opts)
+        end
+        
+        p
+      end
+
+      def add_right_to_profile(name, right)
+        @profiles[name.to_sym] << right.to_sym
+      end
+      
+      def delete_right_from_profile(name, right)
+        @profiles[name.to_sym].delete(right)
+      end
+
+      def profiles
+        @profiles.keys
+      end
+
+      def add_profile(name, opts = {})
+        r = []
+
+        r += self[opts[:extends]].rights if opts[:extends]
+        r += opts[:rights] if opts[:rights]
+
+        @profiles[name.to_sym] = Profile.new(name, r.uniq)
+      end
+
+      def [](name)
+        @profiles[name.to_sym]
+      end
+    end
+  end
+end

data/lib/formol/permissions/user.rb

@@ -0,0 +1,29 @@
+module Formol
+  module Permissions
+    module User
+      extend ActiveSupport::Concern
+      
+      PROFILES = Proc.new{ Formol::Permissions::Manager.profiles.profiles }
+    
+      included do
+        #Security
+        attr_accessible :formol_profile
+        
+        #Default values
+        default_value_for :formol_profile, :registered
+        
+        #Validations
+        validates :formol_profile,  :presence   => true,
+                                    :inclusion  => {  :in           =>  PROFILES,
+                                                      :allow_blank  => true }
+      end
+      
+      module InstanceMethods
+        def formol_allowed_to?(right, obj = nil)
+          @allower ||= Formol::Permissions::Manager.new(self)
+          @allower.able_to?(right, obj)
+        end
+      end
+    end
+  end
+end

data/lib/formol/permissions.rb

@@ -0,0 +1,5 @@
+require "formol/permissions/profile"
+require "formol/permissions/profiles"
+require "formol/permissions/manager"
+require "formol/permissions/controllers"
+require "formol/permissions/user"

data/lib/formol/rails/engine.rb

@@ -0,0 +1,81 @@
+module Magic
+  module Rails
+    module Engine
+      ##
+      # Automatically append all of the current engine's routes to the main
+      # application's route set. This needs to be done for ALL functional tests that
+      # use engine routes, since the mounted routes don't work during tests.
+      #
+      # @param [Symbol] engine_symbol Optional; if provided, uses this symbol to
+      #   locate the engine class by name, otherwise uses the module of the calling
+      #   test case as the presumed name of the engine.
+      #
+      # @author Jason Hamilton (jhamilton@greatherorift.com)
+      # @author Matthew Ratzloff (matt@urbaninfluence.com)
+      def load_engine_routes(engine_symbol = nil)
+        if engine_symbol
+          engine_name = engine_symbol.to_s.camelize
+        #else
+          # No engine provided, so presume the current engine is the one to load
+          #engine_name = self.class.name.split("::").first.split("(").last
+        end
+        engine = ("#{engine_name}::Engine").constantize
+
+        # Append the routes for this module to the existing routes
+        ::Rails.application.routes.disable_clear_and_finalize = true
+        ::Rails.application.routes.clear!
+        ::Rails.application.routes_reloader.paths.each { |path| load(path) }
+        ::Rails.application.routes.draw do
+          resourced_routes = []
+
+          named_routes   = engine.routes.named_routes.routes
+          unnamed_routes = engine.routes.routes - named_routes.values
+
+          engine.routes.routes.each do |route|
+            # Call the method by hand based on the symbol
+            path = "/#{engine_name.underscore}#{route.path}"
+            verb = route.verb.to_s.downcase.to_sym
+            requirements = route.requirements
+            if path_helper = named_routes.key(route)
+              requirements[:as] = path_helper
+            elsif route.requirements[:controller].present?
+              # Presume that all controllers referenced in routes should also be
+              # resources and append that routing on the end so that *_path helpers
+              # will still work
+              resourced_routes << route.requirements[:controller].gsub("#{engine_name.downcase}/", "").to_sym
+            end
+            send(verb, path, requirements) if respond_to?(verb)
+          end
+
+          def namespace!(sp_r, &block)
+            r = sp_r.shift
+            
+            if sp_r.empty?
+              resources r.to_sym
+            else
+              namespace r.to_sym do
+                namespace!(sp_r)
+              end
+            end
+          end
+          
+          # Add each route, once, to the end under a scope to trick path helpers.
+          # This will probably break as soon as there is route name overlap, but
+          # we'll cross that bridge when we get to it.
+          resourced_routes.uniq!
+          scope engine_name.downcase do
+            resourced_routes.each do |resource|
+              namespace!(resource.to_s.split('/'))
+            end
+          end
+        end
+
+        # Finalize the routes
+        ::Rails.application.routes.finalize!
+        ::Rails.application.routes.disable_clear_and_finalize = false
+      end
+    end
+  end
+end
+
+Rails::Engine.send(:include, Magic::Rails::Engine)

data/lib/formol/rails.rb

@@ -0,0 +1 @@
+require 'formol/rails/engine'

data/lib/formol/version.rb

@@ -0,0 +1,10 @@
+module Formol
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 4
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+end

data/lib/formol/view_helpers/assets_helper.rb

@@ -0,0 +1,11 @@
+module Formol
+  module ViewHelpers
+    module AssetsHelper
+      def include_formol_javascripts
+        path = controller.controller_path
+        
+        javascript_include_tag path if path.start_with?('formol')
+      end
+    end
+  end
+end

data/lib/formol/view_helpers/format_helper.rb

@@ -0,0 +1,12 @@
+module Formol
+  module ViewHelpers
+    module FormatHelper
+      def formol_format(text)
+        formatter = Formol.config.formatter.new
+
+        # no need to sanitize or strip_tags, formatter has to handle it!
+        formatter.to_html(text)
+      end
+    end
+  end
+end

data/lib/formol/view_helpers.rb

@@ -0,0 +1,2 @@
+require 'formol/view_helpers/assets_helper'
+require 'formol/view_helpers/format_helper'

data/lib/formol/will_paginate/list_link_renderer.rb

@@ -0,0 +1,29 @@
+require 'will_paginate/view_helpers/action_view'
+
+module Formol
+  module WillPaginate
+    class ListLinkRenderer < ::WillPaginate::ActionView::LinkRenderer
+      protected
+
+      def page_number(page)
+        unless page == current_page
+          tag(:li, link(page, page, :rel => rel_value(page)))
+        else
+          tag(:li, page, :class => "current")
+        end
+      end
+
+      def previous_or_next_page(page, text, classname)
+        if page
+          tag(:li, link(text, page), :class => classname)
+        else
+          tag(:li, text, :class => classname + ' disabled')
+        end
+      end
+
+      def html_container(html)
+        tag(:ul, html, container_attributes)
+      end
+    end
+  end
+end

data/lib/formol/will_paginate.rb

@@ -0,0 +1 @@
+require 'formol/will_paginate/list_link_renderer'

data/lib/formol.rb

@@ -0,0 +1,61 @@
+#gems
+require 'formol_'
+
+module Formol
+  mattr_reader    :config
+  
+  class << self
+    def configure(&block)
+      @@config = Config.new
+
+      class_eval &block
+
+      load_config_from_file
+      set_formatter
+      
+      load_formol_libs
+    end
+
+    private
+    
+    # load formol libs located inside main app
+    def load_formol_libs
+      Dir[Rails.root.join('lib', 'formol', '**', '*.rb')].each do |f|
+        require f
+      end
+      
+      Formol::Permissions::Manager.send(:include, Formol::Permissions::SpecialRights)
+    end
+    
+    # set formatter
+    def set_formatter
+      config.formatter = Formol::Formatters::Redcarpet::Formatter
+    end
+
+    # load config.yml located inside main app
+    def load_config_from_file
+      file_path = Rails.root.join('config/formol.yml')
+
+      return unless File.exists?(file_path)
+
+      h = HashWithIndifferentAccess.new(YAML::load(File.open(file_path)))
+
+      return unless h[:formol]
+
+      h = h[:formol]
+
+      if h[:profiles]
+        profiles = Formol::Permissions::Profiles.from_hash(h[:profiles])
+        Formol::Permissions::Manager.profiles = profiles
+      end
+    end
+  end
+end
+
+require 'formol/engine'
+
+ActionController::Base.send(:include, Formol::Controllers::Auth)
+ActionController::Base.send(:include, Formol::Permissions::Controllers)
+
+ActionView::Base.send(:include, Formol::ViewHelpers::FormatHelper)
+ActionView::Base.send(:include, Formol::ViewHelpers::AssetsHelper)

data/lib/formol_.rb

@@ -0,0 +1,13 @@
+#gems (needed when packaged as a gem)
+require 'formtastic'
+require 'attribute_normalizer'
+require 'will_paginate'
+require 'ranked-model'
+require 'default_value_for'
+require 'pygments.rb'
+require 'redcarpet'
+
+#libs
+%w(config controllers formatters generators integration permissions rails view_helpers will_paginate).each do |lib|
+  require "formol/#{lib}"
+end