webficient-browsercms 3.0.1

data/lib/cms/behaviors/categorizing.rb

@@ -0,0 +1,31 @@
+module Cms
+  module Behaviors
+    module Categorizing
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods      
+        def belongs_to_category?
+          !!@belongs_to_category
+        end
+        def belongs_to_category
+          @belongs_to_category = true
+          extend ClassMethods
+          include InstanceMethods
+          
+          belongs_to :category
+          
+          named_scope :in_category, lambda{|cat| {:conditions => ["category_id = ?", cat.id]}}
+          
+        end
+      end
+      module ClassMethods
+      end
+      module InstanceMethods
+        def category_name
+          category && category.name
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/connecting.rb

@@ -0,0 +1,99 @@
+module Cms
+  module Behaviors
+    module Connecting
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods
+        def connectable?
+          !!@is_connectable
+        end
+        def is_connectable(options={})
+          @is_connectable = true
+          extend ClassMethods
+          include InstanceMethods
+
+          attr_accessor :connect_to_page_id
+          attr_accessor :connect_to_container
+          attr_accessor :connected_page
+        
+          has_many :connectors, :as => :connectable    
+
+          attr_accessor :updated_by_page
+
+          after_create :connect_to_page
+          after_save :update_connected_pages
+        end
+      end
+      module ClassMethods
+        def content_block_type
+          to_s.underscore
+        end
+        def display_name
+          to_s.titleize
+        end
+        def display_name_plural
+          display_name.pluralize
+        end                
+      end
+      module InstanceMethods
+
+        def connected_pages
+          Page.connected_to(self)
+        end
+
+        def connected_page_count
+          Page.connected_to(self).count
+        end
+
+        def content_block_type
+          self.class.content_block_type
+        end
+
+        def display_name
+          self.class.display_name
+        end
+
+        def display_name_plural
+          self.class.display_name_plural
+        end
+      
+        def connect_to_page
+          unless connect_to_page_id.blank? || connect_to_container.blank?
+            #Note that we are setting connected_page so that page can look at that 
+            #to determine if the page should be published            
+            self.connected_page = Page.find(connect_to_page_id)
+            connected_page.create_connector(self, connect_to_container)
+          end
+          true
+        end        
+      
+        def update_connected_pages
+          # If this is versioned, then we need make new versions of all the pages this is connected to
+          if self.class.versioned? 
+            #logger.info "..... Updating connected pages for #{self.class} #{id} v#{version}"
+
+            #Get all the pages the previous version of this connectable was connected to
+            draft_version = draft.version            
+            Page.connected_to(:connectable => self, :version => (draft_version - 1)).all.each do |p|
+              # This is needed in the case of updating page,
+              # which updates this object, so as not to create a loop
+              if p != updated_by_page              
+                #This just creates a new version of the page
+                action = deleted? ? "Deleted" : "Edited"
+                p.update_attributes(:version_comment => "#{self.class.name} ##{id} was #{action}")
+
+                #The previous step will copy over a connector pointing to the previous version of this connectable
+                #We need to change that to point at the new version of this connectable
+                p.connectors.for_page_version(p.draft.version).for_connectable(self).each do |con|
+                  con.update_attribute(:connectable_version, draft_version)
+                end
+              end
+            end
+          end
+          true
+        end        
+      end
+    end
+  end
+end

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