imagine_cms 3.0.0.beta6 → 3.0.0.beta7

data/{vendor/gems → lib}/acts_as_versioned/lib/acts_as_versioned.rb

@@ -249,12 +249,12 @@ module ActiveRecord #:nodoc:
 
         versioned_class.cattr_accessor :original_class
         versioned_class.original_class = self
-        versioned_class.set_table_name versioned_table_name
+        versioned_class.table_name = versioned_table_name
         versioned_class.belongs_to self.to_s.demodulize.underscore.to_sym,
                                    :class_name  => "::#{self.to_s}",
                                    :foreign_key => versioned_foreign_key
         versioned_class.send :include, options[:extend] if options[:extend].is_a?(Module)
-        versioned_class.set_sequence_name version_sequence_name if version_sequence_name
+        versioned_class.sequence_name = version_sequence_name if version_sequence_name
       end
 
       module Behaviors
@@ -268,134 +268,136 @@ module ActiveRecord #:nodoc:
           after_save :clear_old_versions
         end
 
-        module InstanceMethods
-          # Saves a version of the model in the versioned table.  This is called in the after_save callback by default
-          def save_version
-            if @saving_version
-              @saving_version = nil
-              rev = self.class.versioned_class.new
-              clone_versioned_model(self, rev)
-              rev.send("#{self.class.version_column}=", send(self.class.version_column))
-              rev.send("#{self.class.versioned_foreign_key}=", id)
-              rev.save
-            end
+        # Saves a version of the model in the versioned table.  This is called in the after_save callback by default
+        def save_version
+          if @saving_version
+            @saving_version = nil
+            rev = self.class.versioned_class.new
+            clone_versioned_model(self, rev)
+            rev.send("#{self.class.version_column}=", send(self.class.version_column))
+            rev.send("#{self.class.versioned_foreign_key}=", id)
+            rev.save
           end
+        end
 
-          # Clears old revisions if a limit is set with the :limit option in <tt>acts_as_versioned</tt>.
-          # Override this method to set your own criteria for clearing old versions.
-          def clear_old_versions
-            return if self.class.max_version_limit == 0
-            excess_baggage = send(self.class.version_column).to_i - self.class.max_version_limit
-            if excess_baggage > 0
-              self.class.versioned_class.delete_all ["#{self.class.version_column} <= ? and #{self.class.versioned_foreign_key} = ?", excess_baggage, id]
-            end
+        # Clears old revisions if a limit is set with the :limit option in <tt>acts_as_versioned</tt>.
+        # Override this method to set your own criteria for clearing old versions.
+        def clear_old_versions
+          return if self.class.max_version_limit == 0
+          excess_baggage = send(self.class.version_column).to_i - self.class.max_version_limit
+          if excess_baggage > 0
+            self.class.versioned_class.delete_all ["#{self.class.version_column} <= ? and #{self.class.versioned_foreign_key} = ?", excess_baggage, id]
           end
+        end
 
-          # Reverts a model to a given version.  Takes either a version number or an instance of the versioned model
-          def revert_to(version)
-            if version.is_a?(self.class.versioned_class)
-              return false unless version.send(self.class.versioned_foreign_key) == id and !version.new_record?
-            else
-              return false unless version = versions.where(self.class.version_column => version).first
-            end
-            self.clone_versioned_model(version, self)
-            send("#{self.class.version_column}=", version.send(self.class.version_column))
-            true
+        # Reverts a model to a given version.  Takes either a version number or an instance of the versioned model
+        def revert_to(version)
+          if version.is_a?(self.class.versioned_class)
+            return false unless version.send(self.class.versioned_foreign_key) == id and !version.new_record?
+          else
+            return false unless version = versions.where(self.class.version_column => version).first
           end
+          self.clone_versioned_model(version, self)
+          send("#{self.class.version_column}=", version.send(self.class.version_column))
+          true
+        end
 
-          # Reverts a model to a given version and saves the model.
-          # Takes either a version number or an instance of the versioned model
-          def revert_to!(version)
-            revert_to(version) ? save_without_revision : false
-          end
+        # Reverts a model to a given version and saves the model.
+        # Takes either a version number or an instance of the versioned model
+        def revert_to!(version)
+          revert_to(version) ? save_without_revision : false
+        end
 
-          # Temporarily turns off Optimistic Locking while saving.  Used when reverting so that a new version is not created.
-          def save_without_revision
-            save_without_revision!
-            true
-          rescue
-            false
-          end
+        # Temporarily turns off Optimistic Locking while saving.  Used when reverting so that a new version is not created.
+        def save_without_revision
+          save_without_revision!
+          true
+        rescue
+          false
+        end
 
-          def save_without_revision!
-            without_locking do
-              without_revision do
-                save!
-              end
+        def save_without_revision!
+          without_locking do
+            without_revision do
+              save!
             end
           end
+        end
 
-          def altered?
-            track_altered_attributes ? (version_if_changed - changed).length < version_if_changed.length : changed?
-          end
-
-          # Clones a model.  Used when saving a new version or reverting a model's version.
-          def clone_versioned_model(orig_model, new_model)
-            self.class.versioned_columns.each do |col|
-              new_model[col.name] = orig_model.send(col.name) if orig_model.has_attribute?(col.name)
-            end
+        def altered?
+          track_altered_attributes ? (version_if_changed - changed).length < version_if_changed.length : changed?
+        end
 
-            if orig_model.is_a?(self.class.versioned_class)
-              new_model[new_model.class.inheritance_column] = orig_model[self.class.versioned_inheritance_column]
-            elsif new_model.is_a?(self.class.versioned_class)
-              new_model[self.class.versioned_inheritance_column] = orig_model[orig_model.class.inheritance_column]
-            end
+        # Clones a model.  Used when saving a new version or reverting a model's version.
+        def clone_versioned_model(orig_model, new_model)
+          self.class.versioned_columns.each do |col|
+            new_model[col.name] = orig_model.send(col.name) if orig_model.has_attribute?(col.name)
           end
 
-          # Checks whether a new version shall be saved or not.  Calls <tt>version_condition_met?</tt> and <tt>changed?</tt>.
-          def save_version?
-            version_condition_met? && altered?
+          clone_inheritance_column(orig_model, new_model)
+        end
+        
+        def clone_inheritance_column(orig_model, new_model)
+          if orig_model.is_a?(self.class.versioned_class) && new_model.class.column_names.include?(new_model.class.inheritance_column.to_s)
+            new_model[new_model.class.inheritance_column] = orig_model[self.class.versioned_inheritance_column]
+          elsif new_model.is_a?(self.class.versioned_class) && new_model.class.column_names.include?(self.class.versioned_inheritance_column.to_s)
+            new_model[self.class.versioned_inheritance_column] = orig_model[orig_model.class.inheritance_column]
           end
+        end
 
-          # Checks condition set in the :if option to check whether a revision should be created or not.  Override this for
-          # custom version condition checking.
-          def version_condition_met?
-            case
-              when version_condition.is_a?(Symbol)
-                send(version_condition)
-              when version_condition.respond_to?(:call) && (version_condition.arity == 1 || version_condition.arity == -1)
-                version_condition.call(self)
-              else
-                version_condition
-            end
-          end
+        # Checks whether a new version shall be saved or not.  Calls <tt>version_condition_met?</tt> and <tt>changed?</tt>.
+        def save_version?
+          version_condition_met? && altered?
+        end
 
-          # Executes the block with the versioning callbacks disabled.
-          #
-          #   @foo.without_revision do
-          #     @foo.save
-          #   end
-          #
-          def without_revision(&block)
-            self.class.without_revision(&block)
+        # Checks condition set in the :if option to check whether a revision should be created or not.  Override this for
+        # custom version condition checking.
+        def version_condition_met?
+          case
+            when version_condition.is_a?(Symbol)
+              send(version_condition)
+            when version_condition.respond_to?(:call) && (version_condition.arity == 1 || version_condition.arity == -1)
+              version_condition.call(self)
+            else
+              version_condition
           end
+        end
 
-          # Turns off optimistic locking for the duration of the block
-          #
-          #   @foo.without_locking do
-          #     @foo.save
-          #   end
-          #
-          def without_locking(&block)
-            self.class.without_locking(&block)
-          end
+        # Executes the block with the versioning callbacks disabled.
+        #
+        #   @foo.without_revision do
+        #     @foo.save
+        #   end
+        #
+        def without_revision(&block)
+          self.class.without_revision(&block)
+        end
 
-          def empty_callback()
-          end
+        # Turns off optimistic locking for the duration of the block
+        #
+        #   @foo.without_locking do
+        #     @foo.save
+        #   end
+        #
+        def without_locking(&block)
+          self.class.without_locking(&block)
+        end
 
-          #:nodoc:
+        def empty_callback()
+        end
 
-          protected
-          # sets the new version before saving, unless you're using optimistic locking.  In that case, let it take care of the version.
-          def set_new_version
-            @saving_version = new_record? || save_version?
-            self.send("#{self.class.version_column}=", next_version) if new_record? || (!locking_enabled? && save_version?)
-          end
+        #:nodoc:
 
-          # Gets the next available version for the current record, or 1 for a new record
-          def next_version
-            (new_record? ? 0 : versions.calculate(:maximum, version_column).to_i) + 1
-          end
+        protected
+        # sets the new version before saving, unless you're using optimistic locking.  In that case, let it take care of the version.
+        def set_new_version
+          @saving_version = new_record? || save_version?
+          self.send("#{self.class.version_column}=", next_version) if new_record? || (!locking_enabled? && save_version?)
+        end
+
+        # Gets the next available version for the current record, or 1 for a new record
+        def next_version
+          (new_record? ? 0 : versions.calculate(:maximum, version_column).to_i) + 1
         end
 
         module ClassMethods

data/{vendor/gems → lib}/acts_as_versioned/test/migration_test.rb

@@ -19,7 +19,6 @@ if ActiveRecord::Base.connection.supports_migrations?
       
       Thing.connection.drop_table "things" rescue nil
       Thing.connection.drop_table "thing_versions" rescue nil
-      Thing.reset_column_information
     end
         
     def test_versioned_migration

data/lib/extensions/action_controller.rb

@@ -1,172 +1,183 @@
 module ActionControllerExtensions
+  
   module ClassMethods
   end
   
   module InstanceMethods
-    
-    # Saves the current request to the session so that it can be replayed later
-    # (for example, after authentication). Only params of type String, Hash and
-    # Array will be saved. save_request is called in a before_filter in
-    # application.rb.
-    #
-    # Two levels of saved params are required so that params can be unsaved in
-    # the event of a 404 or other event that would make the current param set an
-    # unlikely or undesirable candidate for replaying.
-    def save_user_request
-      return if params[:action] == 'login'
-      
-      session[:old_saved_user_uri] = session[:saved_user_uri];
-      session[:old_saved_user_params] = session[:saved_user_params] || {};
-      saved_params = params.reject { |k, v| !(v.kind_of?(String) || v.kind_of?(Hash) || v.kind_of?(Array)) }
-      saved_params.each { |key, val| saved_params[key] = val.reject { |k, v| !(v.kind_of?(String) || v.kind_of?(Hash) || v.kind_of?(Array)) } if val.kind_of?(Hash) }
-      session[:saved_user_uri] = request.url
-      session[:saved_user_params] = saved_params
-    end
-    
-    # Returns a User object corresponding to the currently logged in user, or returns false
-    # and redirects to the login page if not logged in.
-    def authenticate_user
-      # if user is not logged in, record the current request and redirect
-      if !session[:user_authenticated]
-        if User.find(:all).size == 0
-          flash[:notice] = 'No users exist in the system. Please create one now.'
-          redirect_to :controller => '/management/user', :action => 'create_first'
-        else
-          flash[:notice] = 'This is an admin-only function. To continue, please log in.'
-          save_user_request
-          redirect_to :controller => '/management/user', :action => 'login'
-        end
+    def expire_session_data # :nodoc:
+      # make sure this is not the first run (session being initialized)
+      if session[:last_active]
+        idle_time = Time.now - session[:last_active]
         
-        return false
+        # expire session data as necessary
+        # session_data = session.instance_variable_get("@data")
+        # session_data.select { |k,v| k.to_s !~ /_expiration$/ && v }.each do |k,v|
+        #   idx = k.to_s + '_expiration'
+        #   if (exp = (session[idx] || session[idx.to_sym]).to_i) > 0
+        #     if idle_time > exp
+        #       logger.debug "Expiring #{k} = #{v} (expiration #{exp} > idle time #{idle_time})"
+        #       session[k] = nil
+        #     else
+        #       logger.debug "Retaining #{k} = #{v} (expiration #{exp} < idle time #{idle_time})"
+        #     end
+        #   else
+        #     #logger.debug "Retaining #{k} = #{v} (does not expire)"
+        #   end
+        # end
       end
       
-      @user = User.find(session[:user_id]) rescue nil
-      session[:user_is_superuser] = @user.is_superuser rescue nil
-      
-      @user
+      # bump/set last active time
+      session[:last_active] = Time.now
+      if is_logged_in_user?
+        cookies[:user_auth_status] = { :value => 'authenticated', :expires => 5.minutes.from_now }
+      end
     end
     
-    # Takes a symbol/string or array of symbols/strings and returns true if user has all
-    # of the named permissions.
-    #
-    # Result is stored in the session to speed up future checks.
-    def user_has_permissions?(*permission_set)
-      return false if !(@user ||= authenticate_user)
+    
+    # valid options:
+    # * :include_tags => 'tags, to, include'
+    # * :exclude_tags => 'tags, to, exclude'
+    def insert_object(name, type = :text, options = {}, html_options = {})
+      extend ActionView::Helpers::TagHelper
+      extend ActionView::Helpers::TextHelper
       
-      if !permission_set.is_a? Array
-        permission_set = [ permission_set ]
-      end
+      @page_objects ||= {}
       
-      if session[:user_is_superuser]
-        for perm in permission_set
-          perm = perm.to_s
-          session[('user_can_' + perm).to_sym] ||= true
+      key = "obj-#{type.to_s}-#{name.gsub(/[^\w]/, '_')}"
+      case type.to_sym
+      when :string
+        content = substitute_placeholders(@page_objects[key] || '', @pg)
+        content = erb_render(content)
+        content = auto_link(content, :all, :target => '_blank') unless options[:disable_auto_link]
+        content_tag :span, content, html_options
+      when :text
+        content = substitute_placeholders(@page_objects[key] || '', @pg)
+        content = erb_render(content)
+        # content = auto_link(content, :all, :target => '_blank') unless options[:disable_auto_link]
+        content_tag :div, content, html_options
+      when :page_list
+        @rss_feeds ||= []
+        @rss_feeds << name
+        
+        case @page_objects["#{key}-style-display-as"]
+        when 'calendar'
+          pages = page_list_items(@pg, key, options).compact.uniq.
+                    sort { |a,b| (a.position || 0) <=> (b.position || 0) }.
+                    sort { |a,b| (b.article_date || b.published_date || Time.now) <=>
+                                 (a.article_date || a.published_date || Time.now) }
+          render :partial => 'page_list_calendar', :locals => { :key => key, :pages => pages }
+        else  # display as 'list'
+          today = Time.utc(Time.now.year, Time.now.month, Time.now.day)
+          case @page_objects["#{key}-date-range"]
+            when 'all'
+            when 'past'
+              options[:end_date] ||= today
+            when 'future'
+              options[:start_date] ||= today
+            when 'custom'
+              options[:start_date] ||= @page_objects["#{key}-date-range-custom-start"]
+              options[:end_date] ||= @page_objects["#{key}-date-range-custom-end"]
+          end
+          
+          pages = page_list_items(@pg, key, options).compact.uniq
+          
+          options[:wrapper_div] = true
+          
+          # make options specified in snippets and templates accessible to
+          # page list segments and rss feeds
+          @page_objects["#{key}-template"] = options[:template] if @page_objects["#{key}-template"].empty?
+          
+          render_page_list_segment(name, pages, options, html_options)
         end
-        return true
-      end
-      
-      for perm in permission_set
-        perm = perm.to_s
-        session[('user_can_' + perm).to_sym] = @user.send('can_' + perm)
-        # logger.debug "user_can_#{perm} = #{@user.send('can_' + perm)}"
-        return session[('user_can_' + perm).to_sym]
+      when :snippet
+        @snippet = CmsSnippet.find_by_name(name)
+        if @snippet
+          erb_render(substitute_placeholders(@snippet.content, @pg))
+        else
+          'Could not find snippet "' + name + '" in the database.'
+        end
+      when :photo_gallery
+        gallery_dir = File.join('images', 'content', @pg.path, File.basename(name))
+        Dir.chdir(File.join(Rails.root, 'public'))
+        all_images = Dir.glob("#{gallery_dir}/*.{jpg,jpeg,png,gif}")
+        Dir.chdir(Rails.root)
+        all_images.sort! { |a,b| File.basename(a).to_i <=> File.basename(b).to_i }
+        images = all_images.reject { |img| img =~ /-thumb/ }
+        thumbs = all_images.reject { |img| img !~ /-thumb/ }
+        render_to_string(:partial => 'photo_gallery', :locals => { :name => name, :images => images, :thumbs => thumbs }).html_safe
       end
     end
-    alias :user_has_permission? :user_has_permissions?
     
-    # Determines whether the input string is a valid email address per RFC specification
-    def valid_email_address?(addr, perform_mx_lookup = false)
-      valid = true
+    def render_page_list_segment(name, pages, options = {}, html_options = {})
+      extend ActionView::Helpers::TagHelper
+      extend ActionView::Helpers::TextHelper
+      extend ActionView::Helpers::JavaScriptHelper
+      extend ActionView::Helpers::PrototypeHelper
       
-      # simplified regex for speed... the original can basically lock up the system on longish addresses
-      # valid = valid && addr.to_s =~ /\A([\w\d]+(?:[\w\d\!\#\$\%\&\*\+\-\/\=\?\^\`\{\|\}\~\.]*[\w\d]+)*)@((?:[\w\d]+(?:[-]*[\w\d]+)*\.)+[\w]{2,})\z/
-      valid = valid && addr.to_s =~ /\A([\w\d\!\#\$\%\&\*\+\-\/\=\?\^\`\{\|\}\~\.]+)@((?:[\w\d]+(?:[-]*[\w\d]+)*\.)+[\w]{2,})\z/
-      user, host = $1, $2
+      key = "obj-page_list-#{name.gsub(/[^\w]/, '_')}"
       
-      # blacklist
-      # return false if ContactEmailBlacklist.include?(addr.to_s.strip)
+      offset = first_non_empty(params[:offset], 0).to_i
+      limit = first_non_empty(@page_objects["#{key}-max-item-count"], options[:item_count], pages.size).to_i
+      limit = 1 if limit < 1
+      page_subset = pages[offset, limit] || []
       
-      if perform_mx_lookup
-        begin
-          # require 'net/dns'
-          res = Net::DNS::Resolver.new
-          valid = valid && res.mx(host).size > 0
-        rescue Exception => e
-          logger.error(e)
+      content = ''
+      content << substitute_placeholders(first_non_empty(@page_objects["#{key}-header"], options[:header]), @pg,
+                                         :count => page_subset.size, :total => pages.size,
+                                         :rss_feed_url => (@pg && @pg.id ? url_for(:action => 'rss_feed', :page_id => @pg.id,
+                                                                         :page_list_name => name) : nil))
+      if page_subset.empty?
+        content << substitute_placeholders(first_non_empty(@page_objects["#{key}-empty_message"],
+                                                           options[:empty_message],
+                                                           'No pages found.'), @pg)
+      else
+        page_subset.each_with_index do |page, index|
+          content << substitute_placeholders(first_non_empty(@page_objects["#{key}-template"], options[:template], ''), page,
+                                             :index => index+1, :count => page_subset.size, :total => pages.size)
         end
       end
       
-      valid
-    end
-    
-    ### COMPAT: convert_content_path
-    def convert_content_path
-      logger.debug "DEPRECATION WARNING: convert_content_path called"
-      params[:content_path] = params[:content_path].to_s.split('/') rescue []
-    end
-    
-    ### COMPAT - template_exists?
-    def template_exists?(template, extension = nil)
-      # ignore extension
-      logger.debug("DEPRECATION WARNING: template_exists? called")
-      partial = File.join(File.dirname(template), '_' + File.basename(template))
-      lookup_context.find_all(template).any? || lookup_context.find_all(partial).any?
-    end
-    
-    ### COMPAT - template_exists?
-    def url_for_current
-      logger.debug("DEPRECATION WARNING: url_for_current called")
-      request.fullpath
-    end
-    
-    ### COMPAT - log_error
-    def log_error(e)
-      # noop
-      logger.debug("DEPRECATION WARNING: log_error called")
-      logger.error(e)
-    end
-    
-    # Convert from GMT/UTC to local time (based on time zone setting in session[:time_zone])
-    def gm_to_local(time)
-      ActiveSupport::TimeZone.new(session[:time_zone] || 'UTC').utc_to_local(time)
-    end
-    
-    # Convert from local time to GMT/UTC (based on time zone setting in session[:time_zone])
-    def local_to_gm(time)
-      ActiveSupport::TimeZone.new(session[:time_zone] || 'UTC').local_to_utc(time)
-    end
-    
-    # Convert a time object into a formatted date/time string
-    def ts_to_str(ts)
-      return '' if ts == nil
-      gm_to_local(ts).strftime('%a %b %d, %Y') + ' at ' +
-        gm_to_local(ts).strftime('%I:%M%p').downcase + ' ' + (session[:time_zone_abbr] || '')
-    end
-    
-    # Convert a time object into a formatted time string (no date)
-    def ts_to_time_str(ts)
-      return '' if ts == nil
-      gm_to_local(ts).strftime('%I:%M:%S%p').downcase
-    end
-    
-    # Convert times to a standard format (e.g. 1:35pm)
-    def time_to_str(t, convert = true)
-      return '' if t == nil
-      if convert
-        gm_to_local(t).strftime("%I").to_i.to_s + gm_to_local(t).strftime(":%M%p").downcase
+      content << substitute_placeholders(first_non_empty(@page_objects["#{key}-footer"], options[:footer]), @pg,
+                                         :count => page_subset.size, :total => pages.size,
+                                         :rss_feed_url => (@pg && @pg.id ? url_for(:action => 'rss_feed', :page_id => @pg.id,
+                                                                         :page_list_name => name) : nil))
+      
+      num_segments = (pages.size.to_f / limit).ceil
+      if @page_objects["#{key}-use-pagination"].to_i == 1 && num_segments > 1
+        content << '<table style="margin-top: 4px;" align="right" cellpadding="0" cellspacing="0" border="0"><tr valign="bottom">'
+        content << '<td>Page:&nbsp;</td>'
+        num_segments.times do |seg|
+          start = seg * limit
+          content << "<td><div"
+          if offset >= start && offset < (start + limit)
+            content << " class=\"page_list_segment page_list_segment_selected\""
+          else
+            content << " class=\"page_list_segment\""
+            content << " onmouseover=\"this.className = 'page_list_segment page_list_segment_selected'\""
+            content << " onmouseout=\"this.className = 'page_list_segment'\""
+            content << " onclick=\"this.style.cursor = 'wait';"
+            content << remote_function(:update => key, :url => { :content_path => @pg.path.split('/').concat([ 'segment', start.to_s, name ]) })
+            content << "; return false;\""
+          end
+          content << ">#{seg+1}</div></td>"
+        end
+        content << '</tr></table>'
+      end
+      
+      if options[:wrapper_div]
+        content_tag :div, erb_render(content), html_options.update(:id => key)
       else
-        t.strftime("%I").to_i.to_s + t.strftime(":%M%p").downcase
+        erb_render(content)
       end
     end
     
-    # Convert times to a standard format (e.g. 1:35pm)
-    def date_to_str(t, convert = true)
-      return '' if t == nil
-      if convert
-        gm_to_local(t).strftime("%m").to_i.to_s + '/' + gm_to_local(t).strftime("%d").to_i.to_s + gm_to_local(t).strftime("/%Y")
-      else
-        t.strftime("%m").to_i.to_s + '/' + t.strftime("%d").to_i.to_s + t.strftime("/%Y")
-      end
+    def erb_render(content, safe_level = 3, rethrow_exceptions = false)
+      # sanitize possibly dangerous content before rendering
+      content.gsub!(/<(%.*?(exec|system)\s?\(.*?\s*%)>/, '&lt;\1&gt;')
+      content.gsub!(/<(%.*?\%x\s?\[.*?\s*%)>/, '&lt;\1&gt;')
+      content.gsub!(/<(%.*?\`.*?\s*%)>/, '&lt;\1&gt;')
+      
+      render_to_string(:inline => content.to_s).html_safe
     end
     
   end