skylinecms 3.1.0 → 3.2.0

data/app/models/skyline/article_version.rb

@@ -4,11 +4,13 @@ class Skyline::ArticleVersion < ActiveRecord::Base
   
   belongs_to :article, :class_name => "Skyline::Article", :foreign_key => "article_id"
   belongs_to :data, :polymorphic => true, :dependent => :destroy
-  belongs_to :creator, :class_name => "Skyline::User"
-  belongs_to :last_updated_by, :class_name => "Skyline::User"
+  belongs_to :creator, :class_name => "::#{Skyline::Configuration.user_class.name}"
+  belongs_to :last_updated_by, :class_name => "::#{Skyline::Configuration.user_class.name}"
   has_many :sections, :class_name => "Skyline::Section", :dependent => :destroy
   
   validates_presence_of :name
+  
+  after_initialize :set_defaults  
   before_update :increase_version
   
   accepts_nested_attributes_for :data
@@ -65,12 +67,10 @@ class Skyline::ArticleVersion < ActiveRecord::Base
   end
   alias_method_chain :data, :build
 
-  def respond_to?(method, include_priv = false)
-    if method.to_s == self.article.class.name.demodulize.underscore
-      self.article
-    else
-      super
-    end
+  def respond_to?(method, include_private = false)
+    s = super
+    return s if s
+    method.to_s == self.article.class.name.demodulize.underscore
   end
   
   # Method missing implementation so we can call 
@@ -78,19 +78,32 @@ class Skyline::ArticleVersion < ActiveRecord::Base
   def method_missing(method,*params,&block)
     if method.to_s == self.article.class.name.demodulize.underscore
       self.article
+    elsif method == :to_ary
+      # this line fixes the to_ary problem
+      raise NoMethodError
     else
       super
     end
   end
   
+  def save_with_skip_version(*args)
+    @_skip_version = true
+    v = self.save(*args)
+  ensure
+    @_skip_version = false
+    v
+  end
+  
   protected
   
-  def after_initialize
+  def set_defaults
     self.name = I18n.t(:default_name, :scope => [:page_version]) if self.name.blank?
     self.version ||= 1
   end
   
   def increase_version
+    return if @_skip_version    
     self.version += 1
   end
+  
 end

data/app/models/skyline/image_ref.rb

@@ -30,7 +30,7 @@ class Skyline::ImageRef < Skyline::InlineRef
     
     if skyline_attr
       skyline_prefix = "/#{Skyline::Configuration.url_prefix}"
-      html_options.update "skyline-ref-id" => skyline_ref_id, "skyline-referable-id" => self.referable_id, "skyline-referable-type" => self.referable_type
+      html_options.update "data-skyline-ref-id" => skyline_ref_id, "data-skyline-referable-id" => self.referable_id, "data-skyline-referable-type" => self.referable_type
     end
     option_str = html_options.collect{|k,v| "#{k}=\"#{v}\""}.join(" ")
     

data/app/models/skyline/inline_ref.rb

@@ -8,17 +8,15 @@ class Skyline::InlineRef < Skyline::RefObject
   class << self    
     # Convert an html tag to RefObject tag and update or create RefObject in database
     #
-    # ==== Parameters
-    # html_node<String>:: the html node from the editor
-    # refering_object<Object>:: refering object
-    # refering_column_name<Symbol>:: column name in which the data is stored
-    # ==== Returns
-    # String:: converted html
-    # Array:: ids of refs in html
-    def parse_html(html_node, refering_object, refering_column_name)    
+    # @param [String] html the html node from the editor
+    # @param [Object] refering_object refering object
+    # @param [Symbol] refering_column_name column name in which the data is stored
+    # 
+    # @return [Array[String, Array]] An array containing the converted html and a list of IDS of refs in the HTML
+    def parse_html(html, refering_object, refering_column_name)    
       old_refs = find_ref_ids_for_object(refering_object, refering_column_name)
             
-      h = Hpricot(html_node)
+      h = Hpricot(html)
       updated_refs = []
       
       # html tags to be converted to [REF:id]
@@ -26,17 +24,21 @@ class Skyline::InlineRef < Skyline::RefObject
                           "img" => {:src => "src", :inner_html => false, :skyline_class => Skyline::ImageRef}                                          
                           } 
       
-      iterate_elements.each do |tag, attributes|                
-        h.search("#{tag}[@skyline-referable-type]").each do |node|                                 
-          ref_obj_id = create_ref_from_node(node, refering_object, refering_column_name, attributes[:src], attributes[:skyline_class])
-          if attributes[:inner_html]
-            node.swap("[REF:#{ref_obj_id}]#{node.inner_html}[/REF:#{ref_obj_id}]")
-          else
-            node.swap("[REF:#{ref_obj_id}]")
-          end
-                  
-          updated_refs << ref_obj_id
+      process_tags = lambda{|tag, attributes, node|
+        ref_obj_id = create_ref_from_node(node, refering_object, refering_column_name, attributes[:src], attributes[:skyline_class])
+        if attributes[:inner_html]
+          node.swap("[REF:#{ref_obj_id}]#{node.inner_html}[/REF:#{ref_obj_id}]")
+        else
+          node.swap("[REF:#{ref_obj_id}]")
         end
+                
+        updated_refs << ref_obj_id        
+      }
+      
+      iterate_elements.each do |tag, attributes|                
+        h.search("#{tag}[@data-skyline-referable-type]").each{ |node| process_tags.call(tag, attributes, node) }
+        # Deprecated
+        h.search("#{tag}[@skyline-referable-type]").each{ |node| process_tags.call(tag, attributes, node) }        
       end
       
       del = (old_refs - updated_refs)
@@ -46,47 +48,53 @@ class Skyline::InlineRef < Skyline::RefObject
       end
                   
       [h.to_html, updated_refs]
-    end            
-    
-    # Create hash of InlineRef objects for specified object and column name
-    #
-    # ==== Paramenters
-    # object<Object>:: the object containing the Inline Refs
-    # column_name<String>:: column name in which the inline refs are stored as [REF:id] tags
-    #
-    # ==== Retruns
-    # Hash:: a hash of inlinerefs with id as key and object as value
-    def hash_refs_for_object(object, column_name)
-      types = [Skyline::ImageRef,Skyline::LinkRef].map(&:name)
-      refs = Skyline::RefObject.all(:conditions => {:refering_id => object.id, :refering_type => object.class.name, :refering_column_name => column_name.to_s, :type => types})
-      refs.inject({}){|mem,o| mem[o.id] = o; mem }
     end
     
-    # Convert [REF:id] tags to html tags
-    #
-    # ==== Parameters
-    # object<Object>:: the object containing the string to be converted
-    # column_name<String>:: name of column containing the string to be converted
-    # with_refs<Boolean>:: boolean that sets wether to print skyline-reference tags into the html tag
+    # Convert a string containing [REF] references into html
     # 
-    # ==== Returns
-    # String:: converted html text
-    def convert(object,column_name,with_refs=false,options={})
+    # @param [String] ref_html The HTML containing [REF] references
+    # @param [Object] refering_object The object containing the string to be converted
+    # @param [String] refering_column_name Name of column containing the string to be converted
+    # @param [Boolean] include_ref_data Boolean that sets wether to print skyline-reference attributes into the html tags (default = false)
+    # 
+    # @option options [Boolean] :nullify Wether of not to nullify the ID's of the refs to force creation of new refs (needed for cloning)
+    # 
+    # @return [String] Converted html text
+    def compile_html(ref_html, refering_object, refering_column_name, include_ref_data = false, options = {})
       options.reverse_merge! :nullify => false
+
+      return ref_html unless ref_html.kind_of?(String)
       
-      refs = self.hash_refs_for_object(object, column_name)
-      value = object[column_name]
-      
-      return value unless value.kind_of?(String)
-      v = value.gsub(/\[REF:(\d+)\]/) do |match|
+      refs = self.hash_refs_for_object(refering_object, refering_column_name)
+      v = ref_html.gsub(/\[REF:(\d+)\]/) do |match|
         i = match[5..-2]
-        refs[i.to_i].to_start_html(with_refs,options)
+        refs[i.to_i].to_start_html(include_ref_data, options)
       end
     
       outp = v.gsub(/\[\/REF:(\d+)\]/) do |match|
         i = match[6..-2]
         refs[i.to_i].to_end_html
-      end
+      end      
+    end
+    
+    
+    # Create hash of InlineRef objects for specified object and column name
+    #
+    # @param [Object] refering_object the object containing the Inline Refs
+    # @param [String] refering_column_name column name in which the inline refs are stored as [REF:id] tags
+    #
+    # @return [Hash] a hash of inlinerefs with id as key and object as value
+    def hash_refs_for_object(refering_object, refering_column_name)
+      types = [Skyline::ImageRef,Skyline::LinkRef].map(&:name)
+      refs = Skyline::RefObject.all(:conditions => {:refering_id => refering_object.id, :refering_type => refering_object.class.name, :refering_column_name => refering_column_name.to_s, :type => types})
+      refs.inject({}){|mem,o| mem[o.id] = o; mem }
+    end
+    
+    # Convert [REF:id] tags to html tags
+    #
+    # @see Skyline::InlineRef#compile_html
+    def convert(refering_object, refering_column_name, include_ref_data=false, options={})
+      compile_html(refering_object[refering_column_name], refering_object, refering_column_name, include_ref_data, options)
     end
     
     private
@@ -101,19 +109,24 @@ class Skyline::InlineRef < Skyline::RefObject
       Skyline::InlineRef.connection.select_values("SELECT id FROM #{self.table_name} WHERE refering_id = '#{refering_object.id}' AND refering_type = '#{refering_object.class.name}' AND refering_column_name = '#{refering_column_name.to_s}'").map(&:to_i)
     end
     
-    # create ref_object from html node
+    # Create an InlineRef instance from html node
     #
-    # ==== Parameters
-    # html_node<String>:: html node to be converted to ref_object
-    # refering_object<Object>:: object containing the html node
-    # refering_column_name<Symbol>:: column name of the object containing the html node
-    # src_attr<String>:: attribute of the html node containing the source of the element
-    # skyline_class<Class>:: sti class for the ref_object
+    # @param [String] html_node html node to be converted to ref_object
+    # @param [Object] refering_object object containing the html node
+    # @param [Symbol] refering_column_name column name of the object containing the html node
+    # @param [String] src_attr attribute of the html node containing the source of the element
+    # @param [Class] skyline_class sti class for the ref_object
     #
-    # ==== Returns
-    # Integer:: id of the new ref_object
+    # @return [Integer] id of the new ref_object
     def create_ref_from_node(html_node, refering_object, refering_column_name, src_attr, skyline_class)            
-      id, ref_id, ref_type = remove_attributes(html_node, ["skyline-ref-id", "skyline-referable-id", "skyline-referable-type"])
+      id, ref_id, ref_type = remove_attributes(html_node, ["data-skyline-ref-id", "data-skyline-referable-id", "data-skyline-referable-type"])
+      
+      # Deprecated attributes
+      d_id, d_ref_id, d_ref_type = remove_attributes(html_node, ["skyline-ref-id", "skyline-referable-id", "skyline-referable-type"])
+      
+      id ||= d_id
+      ref_id ||= d_ref_id
+      ref_type ||= d_ref_type
       
       referable_params = {}
       referable_params[:uri] = html_node[:href]
@@ -163,9 +176,12 @@ class Skyline::InlineRef < Skyline::RefObject
     # ==== Returns
     # Array:: values of removed attributes
     def remove_attributes(node, attributes)
-      ret = attributes.inject([]) do |result, element|
-        result << node.remove_attribute(element).to_s.strip
-        result
+      attributes.inject([]) do |result, attribute|
+        if node.has_attribute?(attribute)
+          result << node.remove_attribute(attribute).to_s.strip 
+        else 
+          result << nil
+        end
       end
     end
   end    

data/app/models/skyline/link_ref.rb

@@ -17,7 +17,7 @@ class Skyline::LinkRef < Skyline::InlineRef
       href = linked_file.url unless linked_file.blank?
     end
     skyline_ref_id = options[:nullify] ? "" : self.id
-    skyline_attrs = "skyline-ref-id=\"#{skyline_ref_id}\" skyline-referable-id=\"#{self.referable_id}\" skyline-referable-type=\"#{self.referable_type}\"" if skyline_attr    
+    skyline_attrs = "data-skyline-ref-id=\"#{skyline_ref_id}\" data-skyline-referable-id=\"#{self.referable_id}\" data-skyline-referable-type=\"#{self.referable_type}\"" if skyline_attr    
     options = self.options.collect{|k,v| "#{k}=\"#{v}\""}.join(" ")
         
     html_str = "<a href=\"#{href}\" #{options} #{skyline_attrs}>"

data/app/models/skyline/media_cache.rb

@@ -1,6 +1,8 @@
 # @private
 class Skyline::MediaCache < ActiveRecord::Base    
   set_table_name :skyline_media_cache  
+  
+  # Cache path must be a Pathname object
   cattr_accessor :cache_path
   @@cache_path ||= Skyline::Configuration.media_file_cache_path
     
@@ -10,7 +12,7 @@ class Skyline::MediaCache < ActiveRecord::Base
     def delete_file(path)
       if File.file?(path)
         File.delete(path)
-        dir = File.basename(path)
+        dir = File.dirname(path)
         if File.directory?(dir) && Dir.entries(dir).size == 2
           Dir.delete(dir) rescue nil
         end
@@ -26,7 +28,7 @@ class Skyline::MediaCache < ActiveRecord::Base
   def expire_cache
     # It'd be better to call expire_page here, except it's a
     # controller method and we can't get to it.
-    path = self.class.cache_path + "#{self.url}"
+    path = self.class.cache_path.to_s + "#{self.url}"
 
     logger.info "Sweeping #{path}"
     delete_file(path)

data/app/models/skyline/media_file.rb

@@ -1,7 +1,5 @@
 # @private
-class Skyline::MediaFile < Skyline::MediaNode    
-  has_and_belongs_to_many :tags, :class_name => "Skyline::Tag", :join_table => "skyline_media_files_skyline_tags"
-	  
+class Skyline::MediaFile < Skyline::MediaNode      
   include Skyline::Taggable
 
   after_create :store_data
@@ -121,10 +119,9 @@ class Skyline::MediaFile < Skyline::MediaNode
   
   def set_dimensions
     return if self.file_type != "image"
-    
     begin
       img = case self.data
-      when ActionController::UploadedTempfile,Tempfile
+      when ActionDispatch::Http::UploadedFile,Tempfile
         Magick::Image::read(self.data.path).first
       else
         Magick::Image::from_blob(self.data.read).first

data/app/models/skyline/media_node.rb

@@ -42,7 +42,7 @@ class Skyline::MediaNode < ActiveRecord::Base
   def name=(name)
     name = sanitize_filename(name)
     @renamed = true if name != self.name
-    self.write_attribute(:name,name)
+    write_attribute(:name, name)
   end
 
   # write the path of the node
@@ -51,7 +51,7 @@ class Skyline::MediaNode < ActiveRecord::Base
   # name<String>:: original nodename
   def path=(name)
     @renamed = true if name != self.name
-    self.write_attribute(:path,name)
+    write_attribute(:path, name)
   end  
   
   # check if node has been renamed after sanitizing the name

data/app/models/skyline/object_ref.rb

@@ -2,7 +2,7 @@
 class Skyline::ObjectRef < Skyline::RefObject	
   after_destroy :destroy_referable
   
-	def respond_to?(m)
+	def respond_to?(m, include_private = false)
 		return true if super
 		if self.referable
 			self.referable.respond_to?(m)
@@ -36,7 +36,7 @@ class Skyline::ObjectRef < Skyline::RefObject
   end
   
   def clone
-    returning super do |clone|
+    super.tap do |clone|
       clone.referable = self.referable.clone if self.referable.kind_of?(Skyline::ReferableUri)
     end
   end

data/app/models/skyline/page.rb

@@ -1,6 +1,8 @@
 class Skyline::Page < Skyline::Article
   class Data < Skyline::Article::Data
+    after_initialize :set_defaults    
     before_validation :sanitize_url_part
+    
     validate :validate_url_part, :if => :to_be_published  
     validates_presence_of :title  
 
@@ -14,7 +16,7 @@ class Skyline::Page < Skyline::Article
 
     protected
 
-    def after_initialize
+    def set_defaults
       self.title ||= I18n.t(:default_title, :scope => [:page_version])    
     end
 
@@ -45,9 +47,9 @@ class Skyline::Page < Skyline::Article
   
   validate :only_one_root
   
-  named_scope :root_nodes, {:conditions => {:parent_id => nil}}
-  named_scope :in_navigation, {:conditions => {:skyline_page_data => {:in_navigation => true}}, :include => [:published_publication_data]}
-  named_scope :with_default_data, {:include => [:default_variant_data, :default_variant, :published_publication]}
+  scope :root_nodes, {:conditions => {:parent_id => nil}}
+  scope :in_navigation, {:conditions => {:skyline_page_data => {:in_navigation => true}}, :include => [:published_publication_data]}
+  scope :with_default_data, {:include => [:default_variant_data, :default_variant, :published_publication]}
   
   default_scope :order => "position"
  
@@ -249,9 +251,9 @@ class Skyline::Page < Skyline::Article
   def only_one_root
     if !self.parent && self.site
       if self.new_record?
-        self.errors.add_to_base "cannot be another root node." if self.site.root
+        self.errors.add(:base, "cannot be another root node.") if self.site.root
       else
-        self.errors.add_to_base "cannot be another root node" if self.site.root && self.site.root.id != self.id
+        self.errors.add(:base, "cannot be another root node.") if self.site.root && self.site.root.id != self.id
       end
     end
   end

data/app/models/skyline/page_fragment.rb

@@ -1,8 +1,10 @@
 class Skyline::PageFragment < Skyline::Article
   class Data < Skyline::Article::Data
+    after_initialize :set_defaults
+    
     protected
     
-    def after_initialize
+    def set_defaults
       self.title ||= I18n.t(:default_title, :scope => [:page_fragment])    
     end    
   end  
@@ -10,5 +12,5 @@ class Skyline::PageFragment < Skyline::Article
     "page_fragment"
   end
   
-  named_scope :ordered_by_title, :include => :default_variant_data, :order => "#{Data.table_name}.title"
+  scope :ordered_by_title, :include => :default_variant_data, :order => "#{Data.table_name}.title"
 end

data/app/models/skyline/publication.rb

@@ -3,7 +3,7 @@ class Skyline::Publication < Skyline::ArticleVersion
   belongs_to :variant, :class_name => "Skyline::Variant"
   
   default_scope :order => "created_at DESC"
-  named_scope :with_variant, {:conditions => "variant_id IS NOT NULL"}
+  scope :with_variant, {:conditions => "variant_id IS NOT NULL"}
   
   def published?
     self.article.published_publication == self

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

@@ -32,7 +32,7 @@ class Skyline::Sections::ContentCollectionSection < ActiveRecord::Base
   end
   
   def clone
-    returning super do |clone|
+    super.tap do |clone|
       clone.associated_tags = self.associated_tags.collect{|associated_tag| associated_tag.clone}
     end
   end  

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

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