skylinecms 3.2.0 → 3.3.0

data/app/models/skyline/article_version.rb

@@ -1,6 +1,6 @@
 # @private
 class Skyline::ArticleVersion < ActiveRecord::Base
-  set_table_name :skyline_article_versions
+  self.table_name = "skyline_article_versions"
   
   belongs_to :article, :class_name => "Skyline::Article", :foreign_key => "article_id"
   belongs_to :data, :polymorphic => true, :dependent => :destroy
@@ -15,41 +15,41 @@ class Skyline::ArticleVersion < ActiveRecord::Base
   
   accepts_nested_attributes_for :data
   
-  def build_data(data_attributes)
-    params = data_attributes.dup
-    raise ArgumentError, "Missing class parameter when building data" unless params["class"]
-    klass = params.delete("class")
-    self.data = klass.constantize.new(params)
+  def build_data(*params, &block)
+    attrs = params.first.dup
+    raise ArgumentError, "Missing class parameter when building data" unless attrs["class"]
+    klass = attrs.delete("class")
+    self.data = klass.constantize.new(attrs)
   end
 
   def to_text  
     self.sections.collect{|s| s.to_text}.join(" ").squeeze(" ")
   end
   
-  def clone
-    super.tap do |clone|
-      clone.created_at = nil
-      clone.updated_at = nil
-      clone.sections = self.sections.collect{|section| section.clone}
-      clone.data = self.data.clone
+  def dup
+    super.tap do |dup|
+      dup.created_at = nil
+      dup.updated_at = nil
+      dup.sections = self.sections.collect{|section| section.dup}
+      dup.data = self.data.dup
     end
   end  
   
   # Clones this object and makes it have another class
-  def clone_to_class(klass_or_proxy)
-    clone = klass_or_proxy.build
+  def dup_to_class(klass_or_proxy)
+    dup = klass_or_proxy.build
 
     attrs = clone_attributes(:read_attribute_before_type_cast)
     attrs.delete(self.class.primary_key)
     attrs.delete("created_at")
     attrs.delete("updated_at")
-    attrs["type"] = clone.type
-    clone.send :instance_variable_set, '@attributes', attrs
+    attrs["type"] = dup.type
+    dup.send :instance_variable_set, '@attributes', attrs
     
-    clone.variant = self if clone.respond_to?(:variant)  # only call clone.variant= for publications
-    clone.sections = self.sections.collect{|section| section.clone}
-    clone.data = self.data.clone
-    clone
+    dup.variant = self if dup.respond_to?(:variant)  # only call clone.variant= for publications
+    dup.sections = self.sections.collect{|section| section.dup}
+    dup.data = self.data.dup
+    dup
   end
   
   # Custom data method that ensures that you always have 

data/app/models/skyline/associated_tag.rb

@@ -1,6 +1,6 @@
 # @private
 class Skyline::AssociatedTag < ActiveRecord::Base
-  set_table_name :skyline_associated_tags
+  self.table_name = "skyline_associated_tags"
   
   belongs_to :taggable, :polymorphic => true
   belongs_to :tag

data/app/models/skyline/grant.rb

@@ -1,6 +1,6 @@
 # @private
 class Skyline::Grant < ActiveRecord::Base
-  set_table_name :skyline_grants
+  self.table_name = "skyline_grants"
   
   belongs_to :user, :class_name => "Skyline::User"
   belongs_to :role, :class_name => "Skyline::Role"

data/app/models/skyline/link_section_link.rb

@@ -3,7 +3,7 @@ class Skyline::LinkSectionLink < ActiveRecord::Base
   include Skyline::BelongsToReferable
   include Skyline::Positionable
   
-  set_table_name :skyline_link_section_links
+  self.table_name = "skyline_link_section_links"
   
   self.positionable_scope = :link_section_id
   

data/app/models/skyline/media_cache.rb

@@ -1,6 +1,6 @@
 # @private
 class Skyline::MediaCache < ActiveRecord::Base    
-  set_table_name :skyline_media_cache  
+  self.table_name = "skyline_media_cache"
   
   # Cache path must be a Pathname object
   cattr_accessor :cache_path

data/app/models/skyline/media_dir.rb

@@ -1,6 +1,5 @@
 # @private
 class Skyline::MediaDir < Skyline::MediaNode
-  extend ActiveSupport::Memoizable
   include UniqueIdentifiers
   
   has_many :files, :foreign_key => "parent_id", :class_name => "Skyline::MediaFile"
@@ -14,7 +13,6 @@ class Skyline::MediaDir < Skyline::MediaNode
   validate :only_one_root
     
   class << self
-    extend ActiveSupport::Memoizable
     # returns an Array of hashes
     #
     # ==== Returns

data/app/models/skyline/media_node.rb

@@ -1,6 +1,6 @@
 # @private
 class Skyline::MediaNode < ActiveRecord::Base
-  set_table_name :skyline_media_nodes
+  self.table_name = "skyline_media_nodes"
 
   belongs_to :directory, :foreign_key => "parent_id", :class_name => "Skyline::MediaDir"
   

data/app/models/skyline/object_ref.rb

@@ -35,9 +35,9 @@ class Skyline::ObjectRef < Skyline::RefObject
     self.referable_type == "Skyline::MediaFile"
   end
   
-  def clone
-    super.tap do |clone|
-      clone.referable = self.referable.clone if self.referable.kind_of?(Skyline::ReferableUri)
+  def dup
+    super.tap do |dup|
+      dup.referable = self.referable.dup if self.referable.kind_of?(Skyline::ReferableUri)
     end
   end
   

data/app/models/skyline/page.rb

@@ -54,7 +54,6 @@ class Skyline::Page < Skyline::Article
   default_scope :order => "position"
  
   class << self
-    extend ActiveSupport::Memoizable
     
     def right_prefix
       "page"
@@ -158,9 +157,8 @@ class Skyline::Page < Skyline::Article
   end
   
   def nesting
-    self.root? ? [self] : self.parent.nesting + [self]
+    @nesting ||= self.root? ? [self] : self.parent.nesting + [self]
   end
-  memoize :nesting
   
   def parents
     self.nesting.dup[0..-2]

data/app/models/skyline/publication.rb

@@ -16,9 +16,11 @@ class Skyline::Publication < Skyline::ArticleVersion
     raise ArgumentError, "variant_attributes must be an Hash" unless variant_attributes.kind_of?(Hash)
     raise ArgumentError, "variant_attributes['name'] expected" unless variant_attributes.include?('name')
     
-    variant = self.clone_to_class(self.article.variants)
+    variant = self.dup_to_class(self.article.variants)
     variant.attributes = variant_attributes      
     variant.variant_id = nil
+    variant.created_at = Time.now
+    variant.updated_at = Time.now
     variant.save
     variant
   end

data/app/models/skyline/ref_object.rb

@@ -2,7 +2,7 @@
 class Skyline::RefObject < ActiveRecord::Base
   belongs_to :referable, :polymorphic => true, :autosave => true
 
-  set_table_name :skyline_ref_objects
+  self.table_name = "skyline_ref_objects"
   
   serialize :options  
   

data/app/models/skyline/referable_uri.rb

@@ -1,6 +1,6 @@
 # @private
 class Skyline::ReferableUri < ActiveRecord::Base
-  set_table_name :skyline_referable_uris
+  self.table_name = "skyline_referable_uris"
   
   def url
     self.uri

data/app/models/skyline/right.rb

@@ -1,6 +1,6 @@
 # @private
 class Skyline::Right < ActiveRecord::Base
-  set_table_name :skyline_rights
+  self.table_name = "skyline_rights"
   
   has_and_belongs_to_many :roles, :class_name => "Skyline::Role", :join_table => "skyline_rights_skyline_roles"
 end

data/app/models/skyline/role.rb

@@ -1,6 +1,6 @@
 # @private
 class Skyline::Role < ActiveRecord::Base
-  set_table_name :skyline_roles
+  self.table_name = "skyline_roles"
   
   has_many :grants, :class_name => "Skyline::Grant"
   has_many :users, :class_name => "Skyline::User", :through => :grants

data/app/models/skyline/section.rb

@@ -1,6 +1,6 @@
 # @private
 class Skyline::Section < ActiveRecord::Base
-  set_table_name :skyline_sections
+  self.table_name = "skyline_sections"
   
   belongs_to :variant, :class_name => "Skyline::Variant"
   belongs_to :article_version, :class_name => "Skyline::ArticleVersion"
@@ -12,16 +12,16 @@ class Skyline::Section < ActiveRecord::Base
   
   default_scope :order => "position ASC"
   
-  def build_sectionable(sectionable_attributes)
-    params = sectionable_attributes.dup
-    raise ArgumentError, "Missing class parameter when building sectionable" unless params["class"]
-    klass = params.delete("class")
-    self.sectionable = klass.constantize.new(params)
+  def build_sectionable(*params, &block)
+    attrs = params.first.dup
+    raise ArgumentError, "Missing class parameter when building sectionable" unless attrs["class"]
+    klass = attrs.delete("class")
+    self.sectionable = klass.constantize.new(attrs)
   end
   
-  def clone
-    super.tap do |clone|
-      clone.sectionable = self.sectionable.clone
+  def dup
+    super.tap do |dup|
+      dup.sectionable = dup.sectionable.dup
     end
   end  
   

data/app/models/skyline/sections/content_collection_section.rb

@@ -31,9 +31,9 @@ class Skyline::Sections::ContentCollectionSection < ActiveRecord::Base
     self.content_class.published.with_tags(self.tags).scoped(:limit => self.number)
   end
   
-  def clone
-    super.tap do |clone|
-      clone.associated_tags = self.associated_tags.collect{|associated_tag| associated_tag.clone}
+  def dup
+    super.tap do |dup|
+      dup.associated_tags = self.associated_tags.collect{|associated_tag| associated_tag.dup}
     end
   end  
 end

data/app/models/skyline/sections/link_section.rb

@@ -9,9 +9,9 @@ class Skyline::Sections::LinkSection < ActiveRecord::Base
   
   accepts_nested_attributes_for :links, :allow_destroy => true
   
-  def clone
-    super.tap do |clone|
-      clone.links = self.links.collect{|link| link.clone}
+  def dup
+    super.tap do |dup|
+      dup.links = self.links.collect{|link| link.dup}
     end
   end  
   

data/app/models/skyline/sections/media_section.rb

@@ -27,6 +27,8 @@ class Skyline::Sections::MediaSection < ActiveRecord::Base
     width = self[:width].to_i
     height = self[:height].to_i
     if self.media.present? 
+      width = media.width if self[:width].blank?
+      height = media.height if self[:height].blank?
       proportional = self.media.proportional_dimension(width,height)
       if proportional
         width,height = proportional

data/app/models/skyline/sections/rss_section.rb

@@ -2,7 +2,6 @@ require 'fileutils'
 
 # @private
 class Skyline::Sections::RssSection < ActiveRecord::Base
-  extend ActiveSupport::Memoizable
   extend UrlValidation  
   include Skyline::Sections::Interface
 
@@ -31,15 +30,10 @@ class Skyline::Sections::RssSection < ActiveRecord::Base
     self.rss_feed ? self.rss_feed[:items] : []
   end
   
-  protected
-  def cache_file
-    File.join(self.class.cache_path, "#{self.id}.yml")
-  end
-  memoize :cache_file
-    
   def rss_feed
+    return @rss_feed unless @rss_feed === nil
     if File.exists?(self.cache_file) && File.mtime(self.cache_file) > Time.now - self.cache_timeout
-      YAML.load(File.read(self.cache_file))
+      @rss_feed = YAML.load(File.read(self.cache_file))
     else
       if feed = fetch_feed
         results = RSS::Parser.parse(feed, false)
@@ -66,20 +60,25 @@ class Skyline::Sections::RssSection < ActiveRecord::Base
           } if i < self.show_count  
         end        
         cache(feed)
-        feed
+        @rss_feed = feed
       elsif File.exists?(self.cache_file)
         self.reset_mtime
-        YAML.load(File.read(self.cache_file))
+        @rss_feed = YAML.load(File.read(self.cache_file))
       else
-        false
+        @rss_feed = false
       end
     end
+    @rss_feed
 #  rescue
 #    logger.error "[RssSection] Failed to parse feed!"
 #    false
   end
-  memoize :rss_feed
   
+  protected
+  def cache_file
+    @cache_file ||= File.join(self.class.cache_path, "#{self.id}.yml")
+  end
+    
   def fetch_feed
     logger.debug "[RssSection] Fetching feed #{self.url}"
     feed = open(self.url).read

data/app/models/skyline/tag.rb

@@ -1,5 +1,5 @@
 class Skyline::Tag < ActiveRecord::Base
-  set_table_name :skyline_tags
+  self.table_name = "skyline_tags"
   
   cattr_accessor :taggable_models
 

data/app/models/skyline/user.rb

@@ -1,202 +1,213 @@
-class Skyline::User < ActiveRecord::Base
-  include Skyline::Authentication::User
-  
-  set_table_name :skyline_users
-  has_many :grants, :class_name => "Skyline::Grant", :dependent => :delete_all
-  has_many :roles, :class_name => "Skyline::Role", :through => :grants
-  has_many :rights, :class_name => "Skyline::Right", 
-    :finder_sql => proc{ "SELECT DISTINCT r.* FROM skyline_rights AS r, skyline_grants AS g JOIN skyline_rights_skyline_roles AS rr ON rr.role_id = g.role_id WHERE g.user_id = #{id} AND r.id = rr.right_id" }
-  
-  # This must be set to change the password (by the user himself)
-  attr_accessor :current_password
-  
-  # This can be set by the admin to change the PW
-  attr_reader :force_password
-  attr_protected :force_password
-  
-  # This can be set by the admin to force checking of the current password etc
-  attr_accessor :editing_myself
-    
-  
-  # Validations
-  validate :valid_current_password, :if => :editing_myself, :on => :update
-
-  validates_presence_of :password, :if => :password_changed?
-  validates_presence_of :password_confirmation, :message => :confirmation, :if => :password_changed?, :on => :update
-  validates_confirmation_of :password, :message => :confirmation, :if => :password_changed?
-
-  validates_confirmation_of :force_password, :message => :confirmation, :if => lambda{|user| user.force_password.present?}
-  
-  validates_presence_of :email
-  validate :valid_email_address
-  validates_uniqueness_of :email, :unless => :is_destroyed
-
-  validate :grants_didnt_change, :if => :editing_myself
-
-  before_validation :reset_password_on_empty_current_password, :on => :update
-  before_save :set_forced_password,:encrypt_password
-  
-  default_scope :order => "email ASC"
-  
-  accepts_nested_attributes_for :grants
-  
-  
-  class << self
-    
-    # Authenticates a user with email and password
-    #
-    # ==== Returns
-    # User:: The user if authentication passed
-    # --
-    def authenticate(email,password)
-      user = self.first(:conditions => {:email => email.to_s.downcase, :password => encrypt(password.to_s), :is_destroyed => false})
-      user && user || false
-    end
-    
-    def find_by_identification(identification)
-      self.find_by_id(identification)
-    end
-    
-    def encrypt(pw)
-      Digest::SHA1.hexdigest(pw)
-    end
-    
-    def extract_valid_email_address(email)
-      if email.kind_of? Mail::Address
-        return email.address
-      else
-        begin
-          address = Mail::Address.new(email.to_s)
-        rescue
-          return false
-        end
-      end
-      if address && address.respond_to?(:domain) && address.domain
-        return address.address 
-      else
-        return false
-      end
-    end  
-    
-    def per_page; 30; end      
-    
-  end
-  
-  def identification
-    self.id
-  end
-
-  # Check if a user has a specific right
-  #
-  # ==== Parameters
-  # right_or_class<String,Symbol,~right_prefix>:: 
-  #   Can be a string or a symbol to check a specific right, or you can pass
-  #   an object that responds to #right_prefix, right_prefix must return a string
-  # suffix<String,Symbol>,::
-  #   A suffix to append to the right, mostly usefull in combination with an object
-  #
-  # ==== Returns
-  #<Boolean>:: true if the right exists in one of the roles fo the user
-  # --
-  def allow?(right_or_class,suffix=nil)
-    if right_or_class.respond_to?(:right_prefix)
-      right_or_class = right_or_class.right_prefix
-    end
-    
-    right = [right_or_class,suffix].compact.map(&:to_s).join("_")
-    
-    @rights ||= self.rights.map{|r| r.name }.uniq
-    @rights.include?(right)
-  end
-
-  # Check if this users password matches.
-  def correct_password?(password)
-    if self.password_changed?
-      self.password == password.to_s
-    else
-      self.password == self.class.encrypt(password.to_s)
-    end
-  end
-
-  def current_password=(v)
-    changed_attributes.delete("password") if v.blank?
-    @current_password = v
-  end
-
-  # Generate a new password, set it and return it.
-  #
-  # ==== Returns
-  # String:: The newly set password
-  # --
-  def generate_new_password!
-    pw = SimplePassword.new(8).to_s
-    self.force_password!(pw)
-  end
-
-  # Forcefully set a password without any validations
-  # Directly saves the object.
-  # --
-  def force_password!(pw)
-    self.update_attribute(:password, pw)
-    pw
-  end
-  
-  def force_password=(pw)
-    @force_password = pw if pw.present?
-  end
-  
-  # Display the name or e-mailaddress of the user for
-  # display purposes.
-  def display_name
-    self.name.present? ? self.name : self.email
-  end
-  
-  # Don't really destroy the object, just
-  # set the is_destroyed? flag.
-  def destroy_without_callbacks
-    unless new_record?
-      self.update_attributes(:is_destroyed => true)
-    end
-    
-    freeze
-  end
-      
-  def viewable_roles
-    if self.system?
-      Skyline::Role.all
-    else
-      Skyline::Role.all(:conditions => {:system => false})
-    end
-  end
-  
-
-  
-  protected
-  
-  def set_forced_password
-    self.password = @force_password if @force_password.present?
-  end
-  
-  def encrypt_password
-    return unless self.password_changed?
-    self.password = self.class.encrypt(self.password.to_s)
-  end
-
-  def valid_current_password
-    unless self.current_password && self.password_was == self.class.encrypt(self.current_password)
-      self.errors.add(:current_password, :mismatch)
-    end
-  end
-
-  def reset_password_on_empty_current_password
-    changed_attributes.delete("password") if self.current_password.blank?
-  end
-
-  def valid_email_address
-    return self.errors.add(:email,:invalid) if !Skyline::User.extract_valid_email_address(self.email)
-  end
-  
-  def grants_didnt_change
-    self.errors.add :grants, :changed if self.grants.detect{|g| g.changed?}
-  end
-end
+class Skyline::User < ActiveRecord::Base
+  include Skyline::Authentication::User
+  
+  self.table_name = "skyline_users"
+  has_many :grants, :class_name => "Skyline::Grant", :dependent => :delete_all
+  has_many :roles, :class_name => "Skyline::Role", :through => :grants
+  has_many :rights, :class_name => "Skyline::Right", 
+    :finder_sql => proc{ "SELECT DISTINCT r.* FROM skyline_rights AS r, skyline_grants AS g JOIN skyline_rights_skyline_roles AS rr ON rr.role_id = g.role_id WHERE g.user_id = #{id} AND r.id = rr.right_id" }
+  
+  # This must be set to change the password (by the user himself)
+  attr_accessor :current_password
+  
+  # This can be set by the admin to change the PW
+  attr_reader :force_password
+  attr_protected :force_password
+  
+  # This can be set by the admin to force checking of the current password etc
+  attr_accessor :editing_myself
+  
+  attr_accessor :skip_email_validation
+  
+  # Validations
+  validate :valid_current_password, :if => :editing_myself, :on => :update
+
+  validates_presence_of :password, :if => :password_changed?
+  validates_presence_of :password_confirmation, :message => :confirmation, :if => :password_changed?, :on => :update
+  validates_confirmation_of :password, :message => :confirmation, :if => :password_changed?
+
+  validates_confirmation_of :force_password, :message => :confirmation, :if => lambda{|user| user.force_password.present?}
+  
+  validates_presence_of :email
+  validate :valid_email_address
+  validates_uniqueness_of :email, :unless => :skip_email_validation
+
+  validate :grants_didnt_change, :if => :editing_myself
+
+  before_validation :reset_password_on_empty_current_password, :on => :update
+  before_save :set_forced_password,:encrypt_password
+  
+  default_scope :order => "email ASC"
+  
+  accepts_nested_attributes_for :grants
+  
+  
+  class << self
+    
+    # Authenticates a user with email and password
+    #
+    # ==== Returns
+    # User:: The user if authentication passed
+    # --
+    def authenticate(email,password)
+      user = self.first(:conditions => {:email => email.to_s.downcase, :password => encrypt(password.to_s), :is_destroyed => false})
+      user && user || false
+    end
+    
+    def find_by_identification(identification)
+      self.find_by_id(identification)
+    end
+    
+    def encrypt(pw)
+      Digest::SHA1.hexdigest(pw)
+    end
+    
+    def extract_valid_email_address(email)
+      if email.kind_of? Mail::Address
+        return email.address
+      else
+        begin
+          address = Mail::Address.new(email.to_s)
+        rescue
+          return false
+        end
+      end
+      if address && address.respond_to?(:domain) && address.domain
+        return address.address 
+      else
+        return false
+      end
+    end  
+    
+    def per_page; 30; end      
+    
+  end
+  
+  def identification
+    self.id
+  end
+
+  # Check if a user has a specific right
+  #
+  # ==== Parameters
+  # right_or_class<String,Symbol,~right_prefix>:: 
+  #   Can be a string or a symbol to check a specific right, or you can pass
+  #   an object that responds to #right_prefix, right_prefix must return a string
+  # suffix<String,Symbol>,::
+  #   A suffix to append to the right, mostly usefull in combination with an object
+  #
+  # ==== Returns
+  #<Boolean>:: true if the right exists in one of the roles fo the user
+  # --
+  def allow?(right_or_class,suffix=nil)
+    if right_or_class.respond_to?(:right_prefix)
+      right_or_class = right_or_class.right_prefix
+    end
+    
+    right = [right_or_class,suffix].compact.map(&:to_s).join("_")
+    
+    @rights ||= self.rights.map{|r| r.name }.uniq
+    @rights.include?(right)
+  end
+
+  # Check if this users password matches.
+  def correct_password?(password)
+    if self.password_changed?
+      self.password == password.to_s
+    else
+      self.password == self.class.encrypt(password.to_s)
+    end
+  end
+
+  def current_password=(v)
+    changed_attributes.delete("password") if v.blank?
+    @current_password = v
+  end
+
+  # Generate a new password, set it and return it.
+  #
+  # ==== Returns
+  # String:: The newly set password
+  # --
+  def generate_new_password!
+    pw = SimplePassword.new(8).to_s
+    self.force_password!(pw)
+  end
+
+  # Forcefully set a password without any validations
+  # Directly saves the object.
+  # --
+  def force_password!(pw)
+    self.update_attribute(:password, pw)
+    pw
+  end
+  
+  def force_password=(pw)
+    @force_password = pw if pw.present?
+  end
+  
+  # Display the name or e-mailaddress of the user for
+  # display purposes.
+  def display_name
+    self.name.present? ? self.name : self.email
+  end
+  
+  # Don't really destroy the object, just
+  # set the is_destroyed? flag.
+  def destroy
+    unless new_record?
+      self.update_attributes(:is_destroyed => true)
+      self.grants.collect {|g| g.destroy }
+    end
+    
+    freeze
+  end
+      
+  def viewable_roles
+    if self.system?
+      Skyline::Role.all
+    else
+      Skyline::Role.all(:conditions => {:system => false})
+    end
+  end
+  
+  # Reactivate user with these attributes, if they are valid
+  def reactivate(attributes)
+    temp_user = Skyline::User.new(attributes)
+    temp_user.skip_email_validation = true
+    if temp_user.valid?
+      self.attributes = attributes
+      self.force_password! attributes[:password]
+      self.is_destroyed = false
+    end
+  end
+  
+  protected
+  
+  def set_forced_password
+    self.password = @force_password if @force_password.present?
+  end
+  
+  def encrypt_password
+    return unless self.password_changed?
+    self.password = self.class.encrypt(self.password.to_s)
+  end
+
+  def valid_current_password
+    unless self.current_password && self.password_was == self.class.encrypt(self.current_password)
+      self.errors.add(:current_password, :mismatch)
+    end
+  end
+
+  def reset_password_on_empty_current_password
+    changed_attributes.delete("password") if self.current_password.blank?
+  end
+
+  def valid_email_address
+    return self.errors.add(:email,:invalid) if !Skyline::User.extract_valid_email_address(self.email)
+  end
+  
+  def grants_didnt_change
+    self.errors.add :grants, :changed if self.grants.detect{|g| g.changed?}
+  end
+end