we5-browsercms 3.0.1.1

data/lib/cms/behaviors/dynamic_attributes.rb

@@ -0,0 +1,367 @@
+module Cms
+  module Behaviors
+    # The DynamicAttributes behavior allows a model to store values for any attributes.
+    # A model that uses DynamicAttributes should have corresponding "_attributes" table
+    # where it stores the values for the dynamic attributes.
+    # This is based on the {Flex Attributes Rails Plugin}[http://rubyforge.org/projects/flex-attributes].
+    #
+    #   class User < ActiveRecord::Base
+    #     has_dynamic_attributes
+    #   end
+    #   eric = User.find_by_login 'eric'
+    #   puts "My AOL instant message name is: #{eric.aim}"
+    #   eric.phone = '555-123-4567'
+    #   eric.save
+    #
+    # The above example should work even though "aim" and "phone" are not
+    # attributes on the User model.
+    #
+    # The following options are available on for has_dynamic_attributes to modify
+    # the behavior. Reasonable defaults are provided:
+    #
+    # class_name::
+    #   The class for the related model. This defaults to the
+    #   model name prepended to "Attribute". So for a "User" model the class
+    #   name would be "UserAttribute". The class can actually exist (in that
+    #   case the model file will be loaded through Rails dependency system) or
+    #   if it does not exist a basic model will be dynamically defined for you.
+    #   This allows you to implement custom methods on the related class by
+    #   simply defining the class manually.
+    # table_name::
+    #   The table for the related model. This defaults to the
+    #   attribute model's table name.
+    # relationship_name::
+    #   This is the name of the actual has_many
+    #   relationship. Most of the type this relationship will only be used
+    #   indirectly but it is there if the user wants more raw access. This
+    #   defaults to the class name underscored then pluralized finally turned
+    #   into a symbol.
+    # foreign_key::
+    #   The key in the attribute table to relate back to the
+    #   model. This defaults to the model name underscored prepended to "_id"
+    # name_field::
+    #   The field which stores the name of the attribute in the related object
+    # value_field::
+    #   The field that stores the value in the related object
+    # fields::
+    #   A list of fields that are valid dynamic attributes. By default
+    #   this is "nil" which means that all field are valid. Use this option if
+    #   you want some fields to go to one dynamic attribute model while other
+    #   fields will go to another. As an alternative you can override the
+    #   #dynamic_attributes method which will return a list of all valid dynamic
+    #   attributes. This is useful if you want to read the list of attributes
+    #   from another source to keep your code DRY. This method is given a
+    #   single argument which is the class for the related model. The following
+    #   provide an example:
+    #
+    #  class User < ActiveRecord::Base
+    #    has_dynamic_attributes :class_name => 'UserContactInfo'
+    #    has_dynamic_attributes :class_name => 'Preferences'
+    #
+    #    def dynamic_attributes(model)
+    #      case model
+    #        when UserContactInfo
+    #          %w(email phone aim yahoo msn)
+    #        when Preference
+    #          %w(project_search project_order user_search user_order)
+    #        else Array.new
+    #      end
+    #    end
+    #  end
+    #
+    #  eric = User.find_by_login 'eric'
+    #  eric.email = 'eric@example.com' # Will save to UserContactInfo model
+    #  eric.project_order = 'name'     # Will save to Preference
+    #  eric.save # Carries out save so now values are in database
+    #
+    # Note the else clause in our case statement. Since an empty array is
+    # returned for all other models (perhaps added later) then we can be
+    # certain that only the above dynamic attributes are allowed.
+    #
+    # If both a :fields option and #dynamic_attributes method is defined the
+    # :fields option take precidence. This allows you to easily define the
+    # field list inline for one model while implementing #dynamic_attributes
+    # for another model and not having #dynamic_attributes need to determine
+    # what model it is answering for. In both cases the list of dynamic
+    # attributes can be a list of string or symbols
+    #
+    # A final alternative to :fields and #dynamic_attributes is the
+    # #is_dynamic_attribute? method. This method is given two arguments. The
+    # first is the attribute being retrieved/saved the second is the Model we
+    # are testing for. If you override this method then the #dynamic_attributes
+    # method or the :fields option will have no affect. Use of this method
+    # is ideal when you want to retrict the attributes but do so in a
+    # algorithmic way. The following is an example:
+    #   class User < ActiveRecord::Base
+    #     has_dynamic_attributes :class_name => 'UserContactInfo'
+    #     has_dynamic_attributes :class_name => 'Preferences'
+    #
+    #     def is_dynamic_attribute?(attr, model)
+    #       case attr.to_s
+    #         when /^contact_/ then true
+    #         when /^preference_/ then true
+    #         else
+    #           false
+    #       end
+    #     end
+    #   end
+    #
+    #   eric = User.find_by_login 'eric'
+    #   eric.contact_phone = '555-123-4567'
+    #   eric.contact_email = 'eric@example.com'
+    #   eric.preference_project_order = 'name'
+    #   eric.some_attribute = 'blah'  # If some_attribute is not defined on
+    #                                 # the model then method not found is thrown
+    module DynamicAttributes
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods
+        def has_dynamic_attributes?
+          !!@has_dynamic_attributes
+        end
+        
+        # Will make the current class have dynamic attributes.
+        def has_dynamic_attributes(options={})
+          @has_dynamic_attributes = true
+          include InstanceMethods
+
+          # Provide default options
+          options[:class_name] ||= self.class_name + 'Attribute'
+          options[:table_name] ||= options[:class_name].tableize
+          options[:relationship_name] ||= options[:class_name].tableize.to_sym
+          options[:foreign_key] ||= self.class_name.foreign_key
+          options[:base_foreign_key] ||= self.name.underscore.foreign_key
+          options[:name_field] ||= 'name'
+          options[:value_field] ||= 'value'
+          options[:fields].collect! {|f| f.to_s} unless options[:fields].nil?
+
+          # Init option storage if necessary
+          cattr_accessor :dynamic_options
+          self.dynamic_options ||= Hash.new
+
+          # Return if already processed.
+          return if self.dynamic_options.keys.include? options[:class_name]
+
+          # Attempt to load related class. If not create it
+          begin
+            options[:class_name].constantize
+          rescue
+            Object.const_set(options[:class_name],
+              Class.new(ActiveRecord::Base)).class_eval do
+              def self.reloadable? #:nodoc:
+                false
+              end
+            end
+          end
+
+          # Store options
+          self.dynamic_options[options[:class_name]] = options
+
+          # Modify attribute class
+          attribute_class = options[:class_name].constantize
+          base_class = self.name.underscore.to_sym
+          attribute_class.class_eval do
+            belongs_to base_class, :foreign_key => options[:base_foreign_key]
+            alias_method :base, base_class # For generic access
+          end
+
+          # Modify main class
+          class_eval do
+            has_many options[:relationship_name],
+              :class_name => options[:class_name],
+              :table_name => options[:table_name],
+              :foreign_key => options[:foreign_key],
+              :dependent => :destroy
+
+            # The following is only setup once
+            unless private_method_defined? :method_missing_without_dynamic_attributes
+
+              # Carry out delayed actions before save
+              after_validation_on_update :save_modified_dynamic_attributes
+
+              # Make attributes seem real
+              alias_method :method_missing_without_dynamic_attributes, :method_missing
+              alias_method :method_missing, :method_missing_with_dynamic_attributes
+
+              private
+
+              alias_method :read_attribute_without_dynamic_attributes, :read_attribute
+              alias_method :read_attribute, :read_attribute_with_dynamic_attributes
+              alias_method :write_attribute_without_dynamic_attributes, :write_attribute
+              alias_method :write_attribute, :write_attribute_with_dynamic_attributes
+
+            end
+          end
+        end
+      end
+      module InstanceMethods
+        # Will determine if the given attribute is a dynamic attribute on the
+        # given model. Override this in your class to provide custom logic if
+        # the #dynamic_attributes method or the :fields option are not flexible
+        # enough. If you override this method :fields and #dynamic_attributes will
+        # not apply at all unless you implement them yourself.
+        def is_dynamic_attribute?(attr, model)
+          attr = attr.to_s
+          return dynamic_options[model.name][:fields].include?(attr) unless
+            dynamic_options[model.name][:fields].nil?
+          return dynamic_attributes(model).collect {|f| f.to_s}.include?(attr) unless
+            dynamic_attributes(model).nil?
+          true
+        end
+
+        # Return a list of valid dynamic attributes for the given model. Return
+        # nil if any field is allowed. If you want to say no field is allowed
+        # then return an empty array. If you just have a static list the :fields
+        # option is most likely easier.
+        def dynamic_attributes(model); nil end
+
+        private
+
+        # Called after validation on update so that dynamic attributes behave
+        # like normal attributes in the fact that the database is not touched
+        # until save is called.
+        def save_modified_dynamic_attributes
+          return if @save_dynamic_attr.nil?
+          @save_dynamic_attr.each do |s|
+            model, attr_name = s
+            related_attr = dynamic_related_attr model, attr_name
+            unless related_attr.nil?
+              if related_attr.value.nil?
+                dynamic_related(model).delete related_attr
+              else
+                related_attr.save
+              end
+            end
+          end
+          @save_dynamic_attr = []
+        end
+
+        # Overrides ActiveRecord::Base#read_attribute
+        def read_attribute_with_dynamic_attributes(attr_name)
+          attr_name = attr_name.to_s
+          exec_if_related attr_name do |model|
+            return nil if !@remove_dynamic_attr.nil? && @remove_dynamic_attr.any? do |r|
+              r[0] == model && r[1] == attr_name
+            end
+            value_field = dynamic_options[model.name][:value_field]
+            related_attr = dynamic_related_attr model, attr_name
+            return nil if related_attr.nil?
+            return related_attr.send(value_field)
+          end
+          read_attribute_without_dynamic_attributes(attr_name)
+        end
+
+        # Overrides ActiveRecord::Base#write_attribute
+        def write_attribute_with_dynamic_attributes(attr_name, value)
+          attr_name = attr_name.to_s
+          exec_if_related attr_name do |model|
+            value_field = dynamic_options[model.name][:value_field]
+            @save_dynamic_attr ||= []
+            @save_dynamic_attr << [model, attr_name]
+            related_attr = dynamic_related_attr(model, attr_name)
+            if related_attr.nil?
+              # Used to check for nil? but this caused validation
+              # problems that are harder to solve. blank? is probably
+              # not correct but it works well for now.
+              unless value.blank?
+                name_field = dynamic_options[model.name][:name_field]
+                foreign_key = dynamic_options[model.name][:foreign_key]
+                dynamic_related(model).build name_field => attr_name,
+                  value_field => value, foreign_key => self.id
+              end
+              return value
+            else
+              value_field = (value_field.to_s + '=').to_sym
+              return related_attr.send(value_field, value)
+            end
+          end
+          write_attribute_without_dynamic_attributes(attr_name, value)
+        end
+
+        # Implements dynamic-attributes as if real getter/setter methods
+        # were defined.
+        def method_missing_with_dynamic_attributes(method_id, *args, &block)
+          begin
+            method_missing_without_dynamic_attributes method_id, *args, &block
+          rescue NoMethodError => e
+            attr_name = method_id.to_s.sub(/\=$/, '')
+            exec_if_related attr_name do |model|
+              if method_id.to_s =~ /\=$/
+                return write_attribute_with_dynamic_attributes(attr_name, args[0])
+              else
+                return read_attribute_with_dynamic_attributes(attr_name)
+              end
+            end
+            raise e
+          end
+        end
+
+        # Retrieve the related dynamic attribute object
+        def dynamic_related_attr(model, attr)
+            name_field = dynamic_options[model.name][:name_field]
+            dynamic_related(model).to_a.find {|r| r.send(name_field) == attr}
+        end
+
+        # Retrieve the collection of related dynamic attributes
+        def dynamic_related(model)
+          relationship = dynamic_options[model.name][:relationship_name]
+          send relationship
+        end
+
+        # Yield only if attr_name is a dynamic_attribute
+        def exec_if_related(attr_name)
+          return false if self.class.column_names.include? attr_name
+          each_dynamic_relation do |model|
+            if is_dynamic_attribute?(attr_name, model)
+              yield model
+            end
+          end
+        end
+
+        # Yields for each dynamic relation.
+        def each_dynamic_relation
+          dynamic_options.keys.each {|kls| yield kls.constantize}
+        end
+
+        # Returns the options for the dynamic attributes
+        def dynamic_options
+          nonversioned_class(self.class).dynamic_options
+        end
+
+        # Will return the parent model if kls is a versioned class
+        def nonversioned_class(kls)
+          if kls.name =~ /\:\:Version$/
+            base_class = kls.name
+            base_class.sub!(/\:\:Version$/, '')
+            return base_class.constantize
+          end
+          kls
+        end
+        
+        # This overrides the attributes= defined in ActiveRecord::Base
+        # The only difference is that this doesn't check to see if the
+        # model responds_to the method before sending it
+        # This is needed for Rails 2.2
+        def attributes=(new_attributes, guard_protected_attributes = true)
+          return if new_attributes.nil?
+          attributes = new_attributes.dup
+          attributes.stringify_keys!
+
+          multi_parameter_attributes = []
+          attributes = remove_attributes_protected_from_mass_assignment(attributes) if guard_protected_attributes
+
+          attributes.each do |k, v|
+            if k.include?("(")
+              multi_parameter_attributes << [ k, v ]
+            else
+              send(:"#{k}=", v)
+            end
+          end
+
+          assign_multiparameter_attributes(multi_parameter_attributes)
+        end                         
+      end
+    end
+  end
+end

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