browsercms 3.5.7 → 4.0.0.alpha

data/db/migrate/20100705083859_browsercms_3_3_0.rb

@@ -1,56 +0,0 @@
-class Browsercms330 < ActiveRecord::Migration
-  def self.up
-
-    # patch required for LH345
-    cant_fix = []
-    to_fix = []
-    # find all pages whose path ends in slash and is not root
-    Cms::Page.find(:all, :conditions => "path LIKE '/%/'").each do |pt_page|
-      # make sure no extant page has this path
-      if Page.count(:conditions => ["path = ?", pt_page.path.sub(/(.+)\/+$/, '\1')]) > 0
-          cant_fix << pt_page
-        else
-          to_fix << pt_page
-        end
-    end
-    version_cant_fix = []
-    version_to_fix = []
-    # find all page versions whose path ends in slash and is not root
-    Cms::Page::Version.find(:all, :conditions => "path LIKE '/%/'").each do |pt_page|
-      # make sure no extant page has this path
-      if Cms::Page.count(:conditions => ["path = ?", pt_page.path.sub(/(.+)\/+$/, '\1')]) > 0
-          version_cant_fix << pt_page
-        else
-          version_to_fix << pt_page
-        end
-    end
-
-    # raise an error if there are pages (*not* page versions) that will duplicate an extant path if the ending slash is dropped
-    if cant_fix.length > 0
-      raise "Cannot remove trailing slashes from pages with ID(s) (#{cant_fix.map(&:id).join(', ')}). Other pages already exist with their correct path. The offending path may be in an unpublished page version, newer than the current public version. These needed to be corrected manually in your DBMS before running this migration"
-    end
-
-    to_fix.each do |fix_page|
-      # change the path of all pages with a trailing slash to not have one
-      # using sql updates to prevent unwanted callbacks
-      new_path = fix_page.path.to_s.sub(/(.+)\/+$/, '\1')
-      execute "UPDATE #{prefix('pages')} SET path = '#{new_path}' WHERE id = #{fix_page.id};"
-    end
-    version_to_fix.each do |fix_page|
-      # change the path of all fixable page versions with a trailing slash to not have one
-      # using sql updates to prevent unwanted callbacks
-      new_path = fix_page.path.to_s.sub(/(.+)\/+$/, '\1')
-      execute "UPDATE #{prefix('page_versions')} SET path = '#{new_path}' WHERE id = #{fix_page.id};"
-    end
-    # end patch for LH345
-  end
-
-  def self.down
-
-    # Cannot restore paths with trailing slash - raise error or show message
-    #
-    # raise IrreversibleMigration, "Cannot reverse migration which removes trailing slash from page paths"
-    puts "Page paths which had trailing slashes removed cannot be restored to their original state."
-
-  end
-end

data/db/migrate/20111130221145_browsercms340.rb

@@ -1,56 +0,0 @@
-# Upgrade to Browsercms v3.4.0
-require 'cms/upgrades/v3_4_0'
-class Browsercms340 < ActiveRecord::Migration
-  include Cms::Upgrades::V3_4_0::SchemaStatements
-
-  def change
-    # Namespace class_names where they are not namespaced.
-    %w[HtmlBlock Category CategoryType Portlet FileBlock ImageBlock Tag].each do |content_type|
-      update_content_types(content_type)
-      update_connectors_table(content_type)
-    end
-
-    update_sitemap
-    update_files
-  end
-
-  private
-
-  def namespace_model(name)
-    "Cms::#{name}"
-  end
-
-  def update_files
-    %w[FileBlock ImageBlock].each do |content_type|
-      Cms::AbstractFileBlock.update_all("type = '#{namespace_model(content_type)}'", "type = '#{content_type}'")
-    end
-  end
-
-  def update_sitemap
-    %w[Section Page Link Attachment].each do |addressable|
-      Cms::SectionNode.where(:node_type=>addressable).each do |node|
-        node.node_type = namespace_model(addressable)
-        node.save!
-      end
-    end
-  end
-
-  def update_content_types(name)
-    found = Cms::ContentType.named(name).first
-    if found
-      found.name = namespace_model(name)
-      found.save!
-    end
-  end
-
-  def update_connectors_table(name)
-    namespaced_class = namespace_model(name)
-    puts "Update connectors for #{name} to #{namespaced_class}"
-    Cms::Connector.where(:connectable_type => name).each do |connector|
-      connector.connectable_type = namespaced_class
-      connector.save!
-    end
-  end
-
-
-end

data/db/migrate/20120329144406_browsercms350.rb

@@ -1,32 +0,0 @@
-require 'cms/upgrades/v3_5_0'
-
-class Browsercms350 < ActiveRecord::Migration
-  def change
-    migrate_attachments_table
-    migrate_attachment_for(Cms::ImageBlock)
-    migrate_attachment_for(Cms::FileBlock)
-    migrate_attachment_files_to_new_location
-
-  end
-
-
-  private
-
-  def migrate_attachments_table
-    rename_table :attachments, :cms_attachments if table_exists?(:attachments)
-    rename_table :attachment_versions, :cms_attachment_versions if table_exists?(:attachment_versions)
-
-    rename_content_column :cms_attachments, :file_path, :data_file_path
-    rename_content_column :cms_attachments, :file_size, :data_file_size
-    rename_content_column :cms_attachments, :file_type, :data_content_type
-    rename_content_column :cms_attachments, :name, :data_file_name
-    remove_content_column :cms_attachments, :file_extension
-
-    add_content_column :cms_attachments, :data_fingerprint, :string
-    add_content_column :cms_attachments, :attachable_type, :string
-    add_content_column :cms_attachments, :attachment_name, :string
-    add_content_column :cms_attachments, :attachable_id, :integer
-    add_content_column :cms_attachments, :attachable_version, :integer
-    add_content_column :cms_attachments, :cardinality, :string
-  end
-end

data/db/migrate/20120717182827_browsercms353.rb

@@ -1,19 +0,0 @@
-require 'cms/upgrades/v3_5_0'
-
-class Browsercms353 < ActiveRecord::Migration
-  def change
-    namespace_templates
-    
-    # Some older projects may have AbstractFileBlock rather than File/ImageBlock connectors
-    v3_5_0_update_connector_namespaces("Cms", "AbstractFileBlock")
-    
-  end
-  
-  private
-  
-  def namespace_templates
-    ["PageTemplate", "PagePartial"].each do |view|
-      Cms::DynamicView.update_all("type = 'Cms::#{view}'", "type = '#{view}'" )
-    end
-  end
-end

data/db/migrate/20120813180110_browsercms354.rb

@@ -1,9 +0,0 @@
-class Browsercms354 < ActiveRecord::Migration
-  def up
-    # Attachments should not be overly specific, since it prevents joins from working.
-    ["Cms::ImageBlock", "Cms::FileBlock"].each do |old_type|
-      Cms::Attachment.unscoped.update_all({:attachable_type => "Cms::AbstractFileBlock"}, {:attachable_type => old_type})
-    end
-  end
-end
-

data/lib/cms/addressable.rb

@@ -1,93 +0,0 @@
-# Represents any object which exists in a Sitemap.
-#
-# Can have parents (using SectionNodes) and children.
-module Cms
-  module Addressable
-
-    def self.included(model_class)
-      model_class.attr_accessible :parent
-    end
-
-    # Returns a list of all Addressable objects that are ancestors to this record.
-    # @param [Hash] options
-    # @option [Symbol] :include_self If this object should be included in the Array
-    # @return [Array<Addressable]
-    #
-    def ancestors(options={})
-      ancestor_nodes = node.ancestors
-      ancestors = ancestor_nodes.collect { |node| node.node }
-      ancestors << self if options[:include_self]
-      ancestors
-    end
-
-    def parent
-      @parent if @parent
-      node ? node.section : nil
-    end
-
-    def cache_parent(section)
-      @parent = section
-    end
-
-    def parent=(sec)
-      if node
-        node.move_to_end(sec)
-      else
-        build_section_node(:node => self, :section => sec)
-      end
-    end
-
-    # Computes the name of the partial used to render this object in the sitemap.
-    def partial_for
-      self.class.name.demodulize.underscore
-    end
-
-    # Pages/Links/Attachments use their parent to determine access
-    module LeafNode
-      def access_status
-        parent.status
-      end
-    end
-
-    module NodeAccessors
-      def node
-        section_node
-      end
-
-      def node=(n)
-        self.section_node = n
-      end
-    end
-    # These exist for backwards compatibility to avoid having to change tests.
-    # I want to get rid of these in favor of parent and parent_id
-    module DeprecatedPageAccessors
-
-      def self.included(model_class)
-        model_class.attr_accessible :section_id, :section
-      end
-      include LeafNode
-      include NodeAccessors
-
-      def build_node(opts)
-        build_section_node(opts)
-      end
-
-      def section_id
-        section ? section.id : nil
-      end
-
-      def section_id=(sec_id)
-        self.section = Section.find(sec_id)
-      end
-
-      def section
-        parent
-      end
-
-      def section=(sec)
-        self.parent = sec
-
-      end
-    end
-  end
-end

data/lib/cms/authentication/model.rb

@@ -1,116 +0,0 @@
-module Cms
-  module Authentication
-    module Model
-      def self.included(model_class)
-        model_class.extend ClassMethods
-        model_class.class_eval do
-          include InstanceMethods
-        
-          # Virtual attribute for the unencrypted password
-          attr_accessor :password
-          validates_presence_of     :password,                   :if => :password_required?
-          validates_presence_of     :password_confirmation,      :if => :password_required?
-          validates_confirmation_of :password,                   :if => :password_required?
-          #validates_length_of       :password, :within => 6..40, :if => :password_required?
-          before_save :encrypt_password
-        end      
-      end
-
-      module ClassMethods
-        def authenticate(login, password)
-          u = find_by_login(login) # need to get the salt
-          u && u.authenticated?(password) && !u.expired? ? u : nil
-        end
-
-        #Method to make it easy to change a user's password from the console, not used in the app
-        def change_password(login, new_password)
-          find_by_login(login).change_password(new_password)
-        end
-
-        def make_token
-          secure_digest(Time.now, (1..10).map{ rand.to_s })
-        end
-
-        def password_digest(password, salt)
-          key = '8771d0d9bef6f1091b723d2e701a17c811d69b26'
-          digest = key
-          10.times do
-            digest = secure_digest(digest, salt, password, key)
-          end
-          digest
-        end      
-      
-        def secure_digest(*args)
-          Digest::SHA1.hexdigest(args.flatten.join('--'))
-        end      
-      
-      end
-    
-      module InstanceMethods
-        #Method to make it easy to change a user's password from the console, not used in the app
-        def change_password(new_password)
-          update_attributes(:password => new_password, :password_confirmation => new_password)
-        end      
-      
-        # Encrypts the password with the user salt
-        def encrypt(password)
-          self.class.password_digest(password, salt)
-        end
-      
-        def authenticated?(password)
-          crypted_password == encrypt(password)
-        end
-      
-        # before filter 
-        def encrypt_password
-          return if password.blank?
-          self.salt = self.class.make_token if new_record?
-          self.crypted_password = encrypt(password)
-        end
-      
-        def password_required?
-          crypted_password.blank? || !password.blank?
-        end      
-      
-        def remember_token?
-          (!remember_token.blank?) && 
-            remember_token_expires_at && (Time.now.utc < remember_token_expires_at.utc)
-        end
-
-        # These create and unset the fields required for remembering users between browser closes
-        def remember_me
-          remember_me_for 2.weeks
-        end
-
-        def remember_me_for(time)
-          remember_me_until time.from_now.utc
-        end
-
-        def remember_me_until(time)
-          self.remember_token_expires_at = time
-          self.remember_token            = self.class.make_token
-          save
-        end
-
-        # refresh token (keeping same expires_at) if it exists
-        def refresh_token
-          if remember_token?
-            self.remember_token = self.class.make_token 
-            save      
-          end
-        end
-
-        # 
-        # Deletes the server-side record of the authentication token.  The
-        # client-side (browser cookie) and server-side (this remember_token) must
-        # always be deleted together.
-        #
-        def forget_me
-          self.remember_token_expires_at = nil
-          self.remember_token            = nil
-          save
-        end      
-      end
-    end
-  end
-end

data/lib/cms/behaviors/pagination.rb

@@ -1,212 +0,0 @@
-# This is just a repackaged version of Will Paginate 2.2.2
-module Cms
-  module Behaviors
-    module Pagination
-
-      DEFAULT_PER_PAGE =  15
-
-      def self.included(model_class)
-        model_class.extend(ClassMethods)
-        class << model_class
-          define_method(:default_per_page) { DEFAULT_PER_PAGE }
-        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