browsercms_s3 3.0.3

data/lib/cms/behaviors/flush_cache_on_change.rb

@@ -0,0 +1,33 @@
+module Cms
+  module Behaviors
+    module FlushCacheOnChange
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+        model_class.class_eval do
+          def flush_cache_on_change?
+            false
+          end
+        end
+      end
+      module MacroMethods      
+        def flush_cache_on_change?
+          !!@flush_cache_on_change
+        end
+        def flush_cache_on_change(options={})
+          include InstanceMethods
+          @flush_cache_on_change = true
+          
+          after_save :flush_cache
+          after_destroy :flush_cache
+        end
+      end
+      module InstanceMethods
+        def flush_cache
+          if Cms.caching_enabled?
+            Cms.flush_cache
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/hiding.rb

@@ -0,0 +1,46 @@
+module Cms
+  module Behaviors
+    module Hiding
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods
+        def hideable?
+          !!@is_hideable
+        end
+        def is_hideable(options={})
+          @is_hideable = true
+          extend ClassMethods
+          include InstanceMethods
+        
+          named_scope :hidden, :conditions => {:hidden => true}
+          named_scope :not_hidden, :conditions => {:hidden => false}        
+        end
+      end
+      module ClassMethods
+      end
+      module InstanceMethods
+        def hide
+          self.hidden = true
+          self.version_comment = "Hidden"         
+          self.save
+        end
+        def hide!
+          self.hidden = true
+          self.version_comment = "Hidden"
+          self.save!
+        end
+        def unhide
+          self.hidden = false
+          self.version_comment = "Unhidden"          
+          self.save
+        end
+        def unhide!
+          self.hidden = false
+          self.version_comment = "Unhidden"          
+          self.save!
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/pagination.rb

@@ -0,0 +1,209 @@
+# This is just a repackaged version of Will Paginate 2.2.2
+module Cms
+  module Behaviors
+    module Pagination
+      def self.included(model_class)
+        model_class.extend(ClassMethods)
+        class << model_class
+          define_method(:default_per_page) { 15 }
+        end
+      end
+      class InvalidPage < ArgumentError
+        def initialize(page, page_num)
+          super "#{page.inspect} given as value, which translates to '#{page_num}' as page number"
+        end
+      end      
+      class Collection < Array
+        attr_reader :current_page, :per_page, :total_entries, :total_pages
+
+        # Arguments to the constructor are the current page number, per-page limit
+        # and the total number of entries. The last argument is optional because it
+        # is best to do lazy counting; in other words, count *conditionally* after
+        # populating the collection using the +replace+ method.
+        def initialize(page, per_page, total = nil)
+          @current_page = page.to_i
+          raise InvalidPage.new(page, @current_page) if @current_page < 1
+          @per_page = per_page.to_i
+          raise ArgumentError, "`per_page` setting cannot be less than 1 (#{@per_page} given)" if @per_page < 1
+
+          self.total_entries = total if total
+        end
+
+        # Just like +new+, but yields the object after instantiation and returns it
+        # afterwards. This is very useful for manual pagination:
+        #
+        #   @entries = WillPaginate::Collection.create(1, 10) do |pager|
+        #     result = Post.find(:all, :limit => pager.per_page, :offset => pager.offset)
+        #     # inject the result array into the paginated collection:
+        #     pager.replace(result)
+        #
+        #     unless pager.total_entries
+        #       # the pager didn't manage to guess the total count, do it manually
+        #       pager.total_entries = Post.count
+        #     end
+        #   end
+        #
+        # The possibilities with this are endless. For another example, here is how
+        # WillPaginate used to define pagination for Array instances:
+        #
+        #   Array.class_eval do
+        #     def paginate(page = 1, per_page = 15)
+        #       WillPaginate::Collection.create(page, per_page, size) do |pager|
+        #         pager.replace self[pager.offset, pager.per_page].to_a
+        #       end
+        #     end
+        #   end
+        #
+        # The Array#paginate API has since then changed, but this still serves as a
+        # fine example of WillPaginate::Collection usage.
+        def self.create(page, per_page, total = nil, &block)
+          pager = new(page, per_page, total)
+          yield pager
+          pager
+        end
+
+        # Helper method that is true when someone tries to fetch a page with a
+        # larger number than the last page. Can be used in combination with flashes
+        # and redirecting.
+        def out_of_bounds?
+          current_page > total_pages
+        end
+
+        # Current offset of the paginated collection. If we're on the first page,
+        # it is always 0. If we're on the 2nd page and there are 30 entries per page,
+        # the offset is 30. This property is useful if you want to render ordinals
+        # besides your records: simply start with offset + 1.
+        def offset
+          (current_page - 1) * per_page
+        end
+
+        # current_page - 1 or nil if there is no previous page
+        def previous_page
+          current_page > 1 ? (current_page - 1) : nil
+        end
+
+        # current_page + 1 or nil if there is no next page
+        def next_page
+          current_page < total_pages ? (current_page + 1) : nil
+        end
+
+        def total_entries=(number)
+          @total_entries = number.to_i
+          @total_pages   = (@total_entries / per_page.to_f).ceil
+        end
+
+        # This is a magic wrapper for the original Array#replace method. It serves
+        # for populating the paginated collection after initialization.
+        #
+        # Why magic? Because it tries to guess the total number of entries judging
+        # by the size of given array. If it is shorter than +per_page+ limit, then we
+        # know we're on the last page. This trick is very useful for avoiding
+        # unnecessary hits to the database to do the counting after we fetched the
+        # data for the current page.
+        #
+        # However, after using +replace+ you should always test the value of
+        # +total_entries+ and set it to a proper value if it's +nil+. See the example
+        # in +create+.
+        def replace(array)
+          result = super
+
+          # The collection is shorter then page limit? Rejoice, because
+          # then we know that we are on the last page!
+          if total_entries.nil? and length < per_page and (current_page == 1 or length > 0)
+            self.total_entries = offset + length
+          end
+
+          result
+        end        
+      end
+      module ClassMethods
+        # This is the main paginating finder.
+        #
+        # == Special parameters for paginating finders
+        # * <tt>:page</tt> -- REQUIRED, but defaults to 1 if false or nil
+        # * <tt>:per_page</tt> -- defaults to <tt>CurrentModel.per_page</tt> (which is 30 if not overridden)
+        # * <tt>:total_entries</tt> -- use only if you manually count total entries
+        # * <tt>:count</tt> -- additional options that are passed on to +count+
+        # * <tt>:finder</tt> -- name of the ActiveRecord finder used (default: "find")
+        #
+        # All other options (+conditions+, +order+, ...) are forwarded to +find+
+        # and +count+ calls.
+        def paginate(*args, &block)
+          options = args.pop
+          page, per_page, total_entries = parse_pagination_options(options)
+
+          finder = (options[:finder] || 'find').to_s
+          if finder == 'find'
+            # an array of IDs may have been given:
+            total_entries ||= (Array === args.first and args.first.size)
+            # :all is implicit
+            args.unshift(:all) if args.empty?
+          end
+
+          Collection.create(page, per_page, total_entries) do |pager|
+            count_options = options.except :page, :per_page, :total_entries, :finder
+            find_options = count_options.except(:count).update(:offset => pager.offset, :limit => pager.per_page) 
+
+            args << find_options
+            # @options_from_last_find = nil
+            pager.replace send(finder, *args, &block)
+
+            # magic counting for user convenience:
+            pager.total_entries = count_for_pagination(count_options, args, finder) unless pager.total_entries
+          end
+        end 
+        protected       
+          # Does the not-so-trivial job of finding out the total number of entries
+          # in the database. It relies on the ActiveRecord +count+ method.
+          def count_for_pagination(options, args, finder)
+            excludees = [:count, :order, :limit, :offset, :readonly]
+            unless options[:select] and options[:select] =~ /^\s*DISTINCT\b/i
+              excludees << :select # only exclude the select param if it doesn't begin with DISTINCT
+            end
+            # count expects (almost) the same options as find
+            count_options = options.except *excludees
+
+            # merge the hash found in :count
+            # this allows you to specify :select, :order, or anything else just for the count query
+            count_options.update options[:count] if options[:count]
+
+            # we may have to scope ...
+            counter = Proc.new { count(count_options) }
+
+            # we may be in a model or an association proxy!
+            klass = (@owner and @reflection) ? @reflection.klass : self
+
+            count = if finder.index('find_') == 0 and klass.respond_to?(scoper = finder.sub('find', 'with'))
+                      # scope_out adds a 'with_finder' method which acts like with_scope, if it's present
+                      # then execute the count with the scoping provided by the with_finder
+                      send(scoper, &counter)
+                    elsif match = /^find_(all_by|by)_([_a-zA-Z]\w*)$/.match(finder)
+                      # extract conditions from calls like "paginate_by_foo_and_bar"
+                      attribute_names = extract_attribute_names_from_match(match)
+                      conditions = construct_attributes_from_arguments(attribute_names, args)
+                      with_scope(:find => { :conditions => conditions }, &counter)
+                    else
+                      counter.call
+                    end
+
+            count.respond_to?(:length) ? count.length : count
+          end
+
+          def parse_pagination_options(options) #:nodoc:
+            raise ArgumentError, 'parameter hash expected' unless options.respond_to? :symbolize_keys
+            options = options.symbolize_keys
+            raise ArgumentError, ':page parameter required' unless options.key? :page
+
+            if options[:count] and options[:total_entries]
+              raise ArgumentError, ':count and :total_entries are mutually exclusive'
+            end
+
+            page     = options[:page] || 1
+            per_page = options[:per_page] || self.default_per_page
+            total    = options[:total_entries]
+            [page, per_page, total]
+          end        
+      end
+    end
+  end
+end

data/lib/cms/behaviors/publishing.rb

@@ -0,0 +1,123 @@
+module Cms
+  module Behaviors
+    module Publishing
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+        model_class.class_eval do
+          def publishable?
+            false
+          end
+        end
+      end
+      module MacroMethods
+        def publishable?
+          !!@is_publishable
+        end
+        def is_publishable(options={})
+          @is_publishable = true
+          extend ClassMethods
+          include InstanceMethods
+        
+          attr_accessor :publish_on_save
+        
+          after_save :publish_for_non_versioned
+        
+          named_scope :published, :conditions => {:published => true}
+          named_scope :unpublished, lambda {
+            if versioned?
+              { :joins => :versions,
+                :conditions =>
+                  "#{connection.quote_table_name(version_table_name)}.#{connection.quote_column_name('version')} > " +
+                  "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name('version')}",
+                :select => "distinct #{connection.quote_table_name(table_name)}.*" }
+            else
+              { :conditions => { :published => false } }
+            end
+          }
+
+        end
+      end
+      module ClassMethods
+      end
+      module InstanceMethods
+        def publishable?
+          if self.class.connectable?
+            new_record? ? connect_to_page_id.blank? : connected_page_count < 1
+          else
+            true
+          end
+        end
+        
+        def publish_for_non_versioned
+          unless self.class.versioned?
+            if @publish_on_save
+              publish
+              @publish_on_save = nil
+            end
+          end
+        end
+        
+        def publish
+          publish!
+          true
+        rescue Exception => e
+          logger.warn("Could not publish, #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
+          false
+        end
+        
+        def publish!
+          if new_record?
+            self.publish_on_save = true
+            save!
+          else
+            transaction do
+              if self.class.versioned?
+                d = draft
+
+                # We only need to publish if this isn't already published
+                # or the draft version is greater than the live version
+                if !self.published? || d.version > self.version
+                  
+                  d.update_attributes(:published => true)
+
+                  # copy values from the draft to the main record
+                  quoted_attributes = d.send(:attributes_with_quotes, false, false, self.class.versioned_columns)
+
+                  # Doing the SQL ourselves to avoid callbacks
+                  connection.update(
+                    "UPDATE #{self.class.quoted_table_name} " +
+                    "SET #{quoted_comma_pair_list(connection, quoted_attributes)} " +
+                    "WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quote_value(id)}",
+                    "#{self.class.name} Publish"
+                  )
+                end
+              else
+                connection.update(
+                  "UPDATE #{self.class.quoted_table_name} " +
+                  "SET published = #{connection.quote(true, self.class.columns_hash["published"])} " +
+                  "WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quote_value(id)}",
+                  "#{self.class.name} Publish"
+                )
+              end
+              after_publish if respond_to?(:after_publish)
+            end
+            self.published = true
+          end
+        end    
+            
+        def status
+          live? ? :published : :draft
+        end        
+
+        def status_name
+          status.to_s.titleize
+        end
+
+        def live?
+          self.class.versioned? ? live_version.version == draft.version && published? : true
+        end
+        
+      end
+    end
+  end
+end

data/lib/cms/behaviors/rendering.rb

@@ -0,0 +1,157 @@
+module Cms
+  module Behaviors
+    # The Rendering Behavior allows a model to be rendered within a view.
+    # The key methods are the instance methods perform_render, render and 
+    # inline_options.  From within a view or a helper, you can render a
+    # renderable object by calling the perform_render and passing the controller
+    # object to it.
+    #
+    # When perform_render is called, it will first call the render instance method
+    # of the renderable object.  This is very similar to a controller action.
+    # The purpose of this method is to setup instance varaibles to be used by the
+    # renderable's view.
+    #
+    # After the render method is called, it checks to see if there is a inline_options
+    # instance method on the renderable object.  If so, it calls this and it expects
+    # this to return a Hash that will be passed to render.  This expects there to be
+    # an inline option, so this is the way to do inline rendering.
+    #
+    # Assuming there is no inline_options method, it will look for a template in the 
+    # view path at cms/pluralized_class_name/render.  So if the Renderable class is
+    # Article, the template should be at cms/articles/render.  It uses the same
+    # format and template engine options as regular views, to the file name should
+    # be render.html.erb.
+    #
+    # One gotcha to be aware of with this behavior
+    module Rendering
+      def self.included(model)
+        model.extend(MacroMethods)
+      end
+      module MacroMethods
+        def renderable?
+          false
+        end
+        def is_renderable(options={})
+      
+          @instance_variable_name_for_view = options[:instance_variable_name_for_view]
+      
+          extend ClassMethods
+          include InstanceMethods
+      
+          include ActionController::Helpers
+          include ActionController::RequestForgeryProtection
+
+          helper ApplicationHelper      
+      
+          attr_accessor :controller
+          delegate :params, :session, :request, :flash, :to => :controller
+      
+        end
+      end
+    end
+    module ClassMethods
+      def renderable?
+        true
+      end
+  
+      # This will be the used as the name of instance variable 
+      # that will be available in the view.  The default value is "@renderable"
+      def instance_variable_name_for_view
+        @instance_variable_name_for_view ||= "@renderable"
+      end
+  
+      def helper_path
+        "app/helpers/cms/#{name.underscore}_helper.rb"
+      end
+  
+      def helper_class
+        "Cms::#{name}Helper".constantize
+      end
+  
+      # This is where the path to the template. The default is based on the class
+      # of the renderable, so if you have an Article that is renderable, 
+      # the template will be "articles/render"
+      def template_path
+        "cms/#{name.underscore.pluralize}/render"
+      end
+  
+      # Instance variables that will not be copied from the renderable to the view
+      def ivars_to_ignore
+        ['@controller', '@_already_rendered']
+      end    
+  
+    end
+    module InstanceMethods
+      def prepare_to_render(controller)
+        # Give this renderable a reference to the controller
+        @controller = controller
+
+        copy_instance_variables_from_controller!
+
+        # This gives the view a reference to this object
+        instance_variable_set(self.class.instance_variable_name_for_view, self)
+    
+        # This is like a controller action
+        # We will call it if you have defined a render method
+        # but if you haven't we won't
+        render if respond_to?(:render)
+      end
+    
+      def perform_render(controller)
+        return "Exception: #{@render_exception}" if @render_exception
+        unless @controller
+          # We haven't prepared to render. This should only happen when logged in, as we don't want
+          # errors to bubble up and prevent the page being edited in that case.
+          prepare_to_render(controller)
+        end
+        
+        # Create, Instantiate and Initialize the view
+        view_class  = Class.new(ActionView::Base)      
+        action_view = view_class.new(@controller.view_paths, {}, @controller)
+    
+        # Make helpers and instance vars available
+        view_class.send(:include, @controller.class.master_helper_module)
+        if $:.detect{|d| File.exists?(File.join(d, self.class.helper_path))}
+          view_class.send(:include, self.class.helper_class)
+        end
+        
+        # We want content_for to be called on the controller's view, not this inner view
+        def action_view.content_for(name, content=nil, &block)
+          @controller.instance_variable_get("@template").content_for(name, content, &block)
+        end
+        
+        # Copy instance variables from this renderable object to it's view
+        action_view.assigns = assigns_for_view
+          
+        if respond_to?(:inline_options) && self.inline_options && self.inline_options.has_key?(:inline)
+          options = {:locals => {}}.merge(self.inline_options)
+          ActionView::InlineTemplate.new(options[:inline], options[:type]).render(action_view, options[:locals])
+        else
+          action_view.render(:file => self.class.template_path)
+        end
+      end
+  
+      def render_exception=(exception)
+        @render_exception = exception
+      end
+
+      protected
+        def copy_instance_variables_from_controller!
+          if @controller.respond_to?(:instance_variables_for_rendering)
+            @controller.instance_variables_for_rendering.each do |iv|
+              #logger.info "Copying #{iv} => #{@controller.instance_variable_get(iv).inspect}"
+              instance_variable_set(iv, @controller.instance_variable_get(iv))
+            end
+          end
+        end
+      
+        def assigns_for_view
+          (instance_variables - self.class.ivars_to_ignore).inject({}) do |h,k|
+            h[k[1..-1]] = instance_variable_get(k)
+            h
+          end
+        end
+      
+    end
+  end
+end

data/lib/cms/behaviors/searching.rb

@@ -0,0 +1,49 @@
+module Cms
+  module Behaviors
+    module Searching
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods
+        def searchable?
+          !!@is_searchable
+        end
+        def is_searchable(options={})
+          @is_searchable = true
+          @searchable_columns = options[:searchable_columns] ? options[:searchable_columns].map(&:to_sym) : [:name]
+          extend ClassMethods
+        
+          #This is in a method to allow classes to override it
+          named_scope :search, lambda{|search_params| 
+            term = search_params.is_a?(Hash) ? search_params[:term] : search_params  
+            order = search_params.is_a?(Hash) && search_params[:order] ? search_params[:order] : default_order_for_search
+            conditions = []
+            unless term.blank?
+              searchable_columns.each do |c|
+                if conditions.empty?
+                  conditions = ["#{table_name}.#{c} like ?"]
+                else
+                  conditions.first << "or #{table_name}.#{c} like ?"
+                end
+                conditions << "%#{term}%"
+              end
+              conditions[0] = "(#{conditions[0]})"
+            end
+            scope = {}
+            scope[:conditions] = conditions if conditions
+            scope[:order] = order if order
+            scope                      
+          }
+        end
+      end
+      module ClassMethods
+        def searchable_columns
+          @searchable_columns
+        end
+        def default_order_for_search
+          "#{table_name}.#{searchable_columns.first}"
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/soft_deleting.rb

@@ -0,0 +1,77 @@
+module Cms
+  module Behaviors
+    module SoftDeleting
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods      
+        def uses_soft_delete?
+          !!@uses_soft_delete
+        end
+        def uses_soft_delete(options={})
+          @uses_soft_delete = true
+        
+          named_scope :not_deleted, :conditions => ["#{table_name}.deleted = ?", false]
+          class << self
+            alias_method :find_with_deleted, :find
+            alias_method :count_with_deleted, :count
+            alias_method :delete_all!, :delete_all
+          end
+          alias_method :destroy_without_callbacks!, :destroy_without_callbacks
+        
+          extend ClassMethods
+          include InstanceMethods
+        end
+      end
+      module ClassMethods
+        def find(*args)
+          not_deleted.find_with_deleted(*args)
+        end
+        def count(*args)
+          not_deleted.count_with_deleted(*args)
+        end
+        def delete_all(conditions=nil)
+          update_all(["deleted = ?", true], conditions)
+        end
+        def exists?(id_or_conditions)
+          if id_or_conditions.is_a?(Hash) || id_or_conditions.is_a?(Array)
+            conditions = {:conditions => id_or_conditions}
+          else
+            conditions = {:conditions => {:id => id_or_conditions}}
+          end
+          count(conditions) > 0
+        end      
+      end
+      module InstanceMethods
+        #Overrides original destroy method
+        def destroy_without_callbacks
+          if self.class.publishable?
+            update_attributes(:deleted => true, :publish_on_save => true)
+          else
+            update_attributes(:deleted => true)
+          end
+        end
+
+        def mark_as_deleted!
+          destroy_without_callbacks
+        end
+
+        def destroy_with_callbacks!
+          return false if callback(:before_destroy) == false
+          result = destroy_without_callbacks!
+          @destroyed = true
+          callback(:after_destroy)
+          result
+        end
+
+        def destroy!
+          transaction { destroy_with_callbacks! }
+        end
+
+        def destroyed?
+          @destroyed
+        end        
+      end
+    end
+  end
+end