westarete-skylinecms 3.0.8.20100329

data/app/models/skyline/article.rb

@@ -0,0 +1,272 @@
+# Articles are container objects that contain Sections, have history and can (optional) be previewed
+# and published.
+#
+# @abstract Subclass and implement the Article interface
+class Skyline::Article < ActiveRecord::Base
+  
+  # The data object contains required structured data needed for an article.
+  # 
+  # @abstract Subclass and implement the Article::Data interface
+  class Data < ActiveRecord::Base
+    self.abstract_class = true
+    
+    def self.inherited(subclass)
+      super      
+      subclass.set_table_name subclass.name.underscore.gsub("/","_")
+      
+      parentclass = subclass.parent
+      parentclass.class_eval do
+        belongs_to :default_variant_data, :class_name => subclass.name
+        belongs_to :published_publication_data, :class_name => subclass.name
+      end
+      
+      subclass.class_eval do
+        has_one :article, :foreign_key => "published_publication_data_id", :class_name => parentclass.name
+        
+        named_scope :published, {
+          :include => [:article],
+          :conditions => "skyline_articles.published_publication_data_id = #{self.table_name}.id"
+        }
+      end
+      
+      if !Rails.configuration.cache_classes && !(ActiveSupport::Dependencies.load_once_path?(__FILE__) && subclass.parents[-2] == ::Skyline)        
+        ActiveSupport::Dependencies.autoloaded_constants << subclass.to_s
+      end
+    end
+
+    unless ActiveSupport::Dependencies.load_once_path?(__FILE__)
+      ActiveSupport::Dependencies.autoloaded_constants << "Skyline::Article::Data"
+    end
+    
+    has_one :version, :as => :data, :class_name => "Skyline::ArticleVersion"
+
+    attr_accessor :to_be_published    
+  end
+
+  extend ActiveSupport::Memoizable
+
+  set_table_name :skyline_articles
+  
+  # Associations
+  has_many :versions, :class_name => "Skyline::ArticleVersion"
+  has_many :variants, :class_name => "Skyline::Variant"
+  has_many :publications, :class_name => "Skyline::Publication", :dependent => :destroy
+  belongs_to :published_publication, :class_name => "Skyline::Publication"
+  belongs_to :default_variant, :class_name => "Skyline::Variant"
+
+  # Scopes
+  named_scope :published, {:conditions => "published_publication_id IS NOT NULL"}  
+
+  # Callbacks
+  before_destroy :confirm_destroyability
+  after_destroy :reset_ref_object
+  after_destroy :destroy_variants
+
+  # Validations
+  validate :has_at_least_one_variant
+
+  accepts_nested_attributes_for :variants
+
+  attr_protected :locked unless Skyline::Configuration.enable_locking
+
+  class << self
+    def to_param
+      self.name.underscore
+    end
+    
+    # The prefix to use when determining rights. User#allow? uses
+    # this method when called with 2 parameters.
+    # 
+    # @return [String] The string to prefix to the right (_create, _update, _delete)
+    # @abstract Implement the value correct value in your subclass, defaults to 'article'
+    def right_prefix
+      "article"      
+    end
+    
+    # Is this type of article publishable?
+    # 
+    # @return [true,false] Wether or not this article type can be published
+    # @abstract Implement in subclass if needed, true is a sensible default.
+    def publishable?
+      true
+    end
+  end
+
+  # Has this article been puslished?
+  #
+  # @return [true,false] True if it has a published_publication, meaning it's currently published
+  def published?
+    # Don't use only "self.published_publication" here, it causes way too many lookups
+    # If the next test is wrong, than maybe you should wonder why it is wrong? Foreign key left behind?
+    self.published_publication_id.present?
+  end
+
+  # Depublish an article, removes the published_publication if keep_history? is false
+  # 
+  # @raise [StandardError] If page is persistent and cannot be depulished
+  # @return [void] 
+  def depublish
+    raise StandardError, "can't be depublished because this page is persistent" if self.persistent?
+    
+    if self.published_publication
+      self.published_publication.destroy unless self.keep_history?
+      self.published_publication = nil
+    end
+    
+    self.published_publication_data = nil
+    self.url_part = "page-#{self.position}"
+    
+    self.save
+  end
+  
+  # Depublish this article and destroy it.
+  # 
+  # @see Skylien::Article#depublish
+  # @return [false,true] True sucessfully destroyed, otherwise false
+  def destroy
+    depublish
+    super
+  end
+  
+  # Can this article be depublished? 
+  # 
+  # @return [true,false]
+  def depublishable?
+    !self.persistent?
+  end
+  
+  # Can this article be destroyed? Only works if the article isn't persisntent and does not have
+  # a publication (isn't published).
+  # 
+  # @return [true,false]
+  def destroyable?
+    !self.persistent? && self.published_publication == nil
+  end
+  
+  # Can this article be rendered. This basically means wether or not there are any templates for
+  # this article.
+  # 
+  # @return [true,false]
+  def renderable?
+    self.renderable_scope.renderer.templates_for(self).any?
+  end
+  
+  # Can this article be previewed? Delegates to Skyline::Article#renderable?
+  #
+  # @return [true,false]
+  # @see Skyline::Article#renderable?
+  def previewable?
+    self.renderable?
+  end
+  
+  
+  def rollbackable?
+    true
+  end
+  
+  def keep_history?
+    false
+  end
+  
+  def enable_publishing?
+    true
+  end
+  
+  def enable_multiple_variants?
+    true
+  end
+  
+  def enable_locking?
+    true
+  end
+
+
+  # Checks if the page can be edited by a certain user
+  # Currently only checks on page locks.
+  # 
+  # @param user [Skyline::User,Integer] The user or user id to check the access for.
+  # @return [true,false] True if the user can edit this page, false otherwise
+  def editable_by?(user)
+    user = user.kind_of?(Skyline::User) ? user : Skyline::User.find_by_id(user)    
+    self.locked? && user.allow?(:page_lock) || !self.locked?
+  end  
+
+  
+  def set_default_variant!(variant)
+    return if variant.id == self.default_variant_id && variant.data_id == self.default_variant_data_id
+    self.update_attributes(:default_variant_id => variant.id, :default_variant_data_id => variant.data_id)
+  end
+  
+  def set_default_variant(variant)
+    return if variant.id == self.default_variant_id && variant.data_id == self.default_variant_data_id
+    self.attributes = {:default_variant_id => variant.id, :default_variant_data_id => variant.data_id}
+  end  
+
+  # The class that provides our custom data fields.
+  # 
+  # @return [Class,false] False if we don't have an inner Data class, the inner Data class if there is one.
+  def data_class
+    # Note: We can't use memoize here, because it freezes the class
+    return @_data_class unless @_data_class.nil?
+    @_data_class = (self.class.name + "::" + "Data").constantize
+  rescue NameError
+    @_data_class = false
+  end
+  
+  
+  def right_prefix
+    self.class.right_prefix
+  end
+  
+  def title
+    self.id
+  end
+  
+  # A subclass can return a Page in which the article (ie: NewsItem) will be rendered for previewing
+  # 
+  # @return [Skyline::Page,nil] The page to wrap this article in when previewing. Nil if no wrapping is needed.
+  # @abstract Implement this in a subclass to get the Page from Settings or from somewhere else.
+  def preview_wrapper_page
+    nil
+  end
+  
+  def sites
+    [Skyline::Site.new]
+  end
+  
+  def site
+    Skyline::Site.new
+  end  
+  
+  def renderable_scope
+    Skyline::Rendering::Scopes::Wildcard.new
+  end  
+  
+  protected
+  
+  def after_initialize
+    if self.new_record?
+      v = self.variants.build(:article => self)
+      self.default_variant_data = v.data
+    end
+  end
+  
+  def has_at_least_one_variant
+    self.errors.add "must have at least one Variant" if self.variants.empty?
+  end  
+
+  
+  def confirm_destroyability
+    raise StandardError, "can't be destroyed because this page is persistent" if self.persistent?
+  end  
+
+  # Reset ref objects that refer to this now removed Article.
+  # by setting referable_id = nil
+  def reset_ref_object
+    Skyline::RefObject.update_all({:referable_id => nil}, {:referable_id => self.id, :referable_type => self.class.name})    
+  end  
+  
+  def destroy_variants
+    self.variants.map(&:destroy_without_removing_page)
+  end
+end

data/app/models/skyline/article_version.rb

@@ -0,0 +1,96 @@
+# @private
+class Skyline::ArticleVersion < ActiveRecord::Base
+  set_table_name :skyline_article_versions
+  
+  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"
+  has_many :sections, :class_name => "Skyline::Section", :dependent => :destroy
+  
+  validates_presence_of :name
+  before_update :increase_version
+  
+  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)
+  end
+
+  def to_text  
+    self.sections.collect{|s| s.to_text}.join(" ").squeeze(" ")
+  end
+  
+  def clone
+    returning super do |clone|
+      clone.created_at = nil
+      clone.updated_at = nil
+      clone.sections = self.sections.collect{|section| section.clone}
+      clone.data = self.data.clone
+    end
+  end  
+  
+  # Clones this object and makes it have another class
+  def clone_to_class(klass_or_proxy)
+    clone = 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
+    
+    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
+  end
+  
+  # Custom data method that ensures that you always have 
+  # a data object if this article needs one.
+  def data_with_build
+    return self.data_without_build unless self.article  # article has been destroyed
+    return self.data_without_build unless self.article.data_class
+    if current_data = self.data_without_build
+      return current_data
+    else
+      current_data = self.article.data_class.new 
+      self.data = current_data unless self.frozen?
+      return current_data
+    end
+  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
+  end
+  
+  # Method missing implementation so we can call 
+  # article_version.page to get the Page or article_version.xxx to get Xxx
+  def method_missing(method,*params,&block)
+    if method.to_s == self.article.class.name.demodulize.underscore
+      self.article
+    else
+      super
+    end
+  end
+  
+  protected
+  
+  def after_initialize
+    self.name = I18n.t(:default_name, :scope => [:page_version]) if self.name.blank?
+    self.version ||= 1
+  end
+  
+  def increase_version
+    self.version += 1
+  end
+end

data/app/models/skyline/associated_tag.rb

@@ -0,0 +1,15 @@
+# @private
+class Skyline::AssociatedTag < ActiveRecord::Base
+  set_table_name :skyline_associated_tags
+  
+  belongs_to :taggable, :polymorphic => true
+  belongs_to :tag
+  
+  after_save :delete_unused_tags
+  after_destroy :delete_unused_tags
+  
+  protected
+  def delete_unused_tags
+    Skyline::Tag.delete_unused_tags
+  end
+end

data/app/models/skyline/grant.rb

@@ -0,0 +1,7 @@
+# @private
+class Skyline::Grant < ActiveRecord::Base
+  set_table_name :skyline_grants
+  
+  belongs_to :user, :class_name => "Skyline::User"
+  belongs_to :role, :class_name => "Skyline::Role"
+end

data/app/models/skyline/image_ref.rb

@@ -0,0 +1,36 @@
+# @private
+class Skyline::ImageRef < Skyline::InlineRef
+  
+  # Render html for specified RefObject
+  # ==== Parameters
+  # skyline_attr<Boolean>:: boolean that sets if skyline attributes should be added to the html tag
+  #
+  # ==== Returns
+  # html image tag
+  def to_start_html(skyline_attr = false,options={})
+    options.reverse_merge! :nullify => false
+    html_options = {}.merge(self.options)
+    
+    #TODO: get default image from options
+    src = "broken.jpg"
+    
+    if self.referable_id.present? && image = self.referable_type.constantize.find_by_id(self.referable_id)
+      if html_options["width"].blank? || html_options["height"].blank?
+        dimen = image.dimension
+        html_options.reverse_merge! dimen
+      end
+      src = image.url("#{html_options["width"]}x#{html_options["height"]}")
+    end
+    
+    skyline_ref_id = options[:nullify] ? "" : self.id
+    
+    if skyline_attr
+      skyline_prefix = "/skyline"
+      html_options.update "skyline-ref-id" => skyline_ref_id, "skyline-referable-id" => self.referable_id, "skyline-referable-type" => self.referable_type
+    end
+    option_str = html_options.collect{|k,v| "#{k}=\"#{v}\""}.join(" ")
+    
+    html_str = "<img src=\"#{skyline_prefix}#{src}\" #{option_str} />"
+  end
+    
+end

data/app/models/skyline/inline_ref.rb

@@ -0,0 +1,191 @@
+# @private
+class Skyline::InlineRef < Skyline::RefObject  
+
+  attr_accessor :previous_referable
+  after_save :possibly_destroy_previous_referable
+  after_destroy :possibly_destroy_referable
+
+  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)    
+      old_refs = find_ref_ids_for_object(refering_object, refering_column_name)
+            
+      h = Hpricot(html_node)
+      updated_refs = []
+      
+      # html tags to be converted to [REF:id]
+      iterate_elements = {"a" => {:src => "href", :inner_html => true, :skyline_class => Skyline::LinkRef}, 
+                          "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
+        end
+      end
+      
+      del = (old_refs - updated_refs)
+      unless del.blank?
+        self.destroy_all("id IN(#{del.join(',')})") 
+        logger.warn("[InlineRef] Destroying refs for #{refering_object.class.name} id: #{refering_object.id} column: #{refering_column_name}. Ref's destroyed: #{del.inspect}")
+      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
+    # 
+    # ==== Returns
+    # String:: converted html text
+    def convert(object,column_name,with_refs=false,options={})
+      options.reverse_merge! :nullify => false
+      
+      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|
+        i = match[5..-2]
+        refs[i.to_i].to_start_html(with_refs,options)
+      end
+    
+      outp = v.gsub(/\[\/REF:(\d+)\]/) do |match|
+        i = match[6..-2]
+        refs[i.to_i].to_end_html
+      end
+    end
+    
+    private
+    # find ref idss by sql for refering object
+    # ==== Parameters
+    # refering_object<Object>:: Object containing the refs
+    # refering_column_name<Symbol>:: column name where refs are stored
+    #
+    # ==== Returns
+    # Array:: Array of ids of refering objects
+    def find_ref_ids_for_object(refering_object, refering_column_name)            
+      # 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)
+      Skyline::InlineRef.find(
+        :all, 
+        :conditions => {
+          :refering_id => refering_object.id, 
+          :refering_type => refering_object.class.name, 
+          :refering_column_name => refering_column_name.to_s
+        }
+      ).collect(&:id)
+    end
+    # create ref_object 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
+    #
+    # ==== Returns
+    # 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"])
+      
+      referable_params = {}
+      referable_params[:uri] = html_node[:href]
+
+      options = []        
+      html_node.remove_attribute(src_attr)
+      
+      options = html_node.attributes.to_hash.inject({}) do |result, element|
+        result[element.first.to_s] = element.last.to_s
+        result
+      end
+   
+      new_ref = skyline_class.find_by_id_and_refering_type_and_refering_id(id,refering_object.class.name,refering_object.id) unless id.blank?
+      new_ref ||= skyline_class.new
+
+      new_ref.previous_referable = new_ref.referable.dup if new_ref.referable
+        
+      new_ref.attributes = {
+        :referable_id => ref_id,
+        :referable_type => ref_type,
+        :options => options, 
+        :refering_id => refering_object.id, 
+        :refering_type => refering_object.class.name,
+        :refering_column_name => refering_column_name.to_s
+      }
+      
+      new_ref.referable.reload if new_ref.referable
+      if ref_type == "Skyline::ReferableUri"
+        new_ref.referable ||= ref_type.constantize.new
+
+        if referable_params.kind_of?(Hash)
+          referable_params.each do |k, v|
+            new_ref.referable.send(k.to_s + "=", v) if new_ref.referable.respond_to?(k.to_s + "=")
+          end
+        end
+      end
+
+      new_ref.save!
+      
+      new_ref.id
+    end
+    
+    # Remove multiple attributes from html_node
+    # ==== Parameters
+    # node<String>:: html node
+    # attributes<Array>:: attributes to be stripped
+    # ==== 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
+      end
+    end
+  end    
+  
+  protected
+  def possibly_destroy_previous_referable
+    return unless self.previous_referable
+    if previous_referable != self.referable
+      previous_referable.destroy if previous_referable.kind_of?(Skyline::ReferableUri)
+    end
+  end
+
+  def possibly_destroy_referable
+    self.referable.destroy if self.referable.kind_of?(Skyline::ReferableUri)
+  end  
+end

data/app/models/skyline/link_ref.rb

@@ -0,0 +1,35 @@
+# @private
+class Skyline::LinkRef < Skyline::InlineRef
+  
+  # Render html start tag for specified RefObject
+  # ==== Parameters
+  # skyline_attr<Boolean>:: boolean that sets if skyline attributes should be added to the html tag
+  #
+  # ==== Returns
+  # String:: html link tag
+  def to_start_html(skyline_attr = false,options={})
+    options.reverse_merge! :nullify => false
+    skyline_attr_str = ""
+    
+    href = "broken"
+    if !self.referable_id.blank?
+      linked_file = self.referable_type.constantize.find_by_id(self.referable_id)
+      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    
+    options = self.options.collect{|k,v| "#{k}=\"#{v}\""}.join(" ")
+        
+    html_str = "<a href=\"#{href}\" #{options} #{skyline_attrs}>"
+  end
+  
+  # Render html end tag for specified RefObject
+  # ==== Parameters
+  # skyline_attr<Boolean>:: boolean that sets if skyline attributes should be added to the html tag
+  #
+  # ==== Returns
+  # String:: html link closing tag
+  def to_end_html
+    html_str = "</a>"
+  end
+end

data/app/models/skyline/link_section_link.rb

@@ -0,0 +1,24 @@
+# @private
+class Skyline::LinkSectionLink < ActiveRecord::Base
+  include Skyline::BelongsToReferable
+  include Skyline::Positionable
+  
+  set_table_name :skyline_link_section_links
+  
+  self.positionable_scope = :link_section_id
+  
+  belongs_to_referable :linked
+  delegate :url, :external?, :file?, :blank?, :to => :linked
+  
+  belongs_to :link_section
+  
+  validates_presence_of :title
+  validate :presence_of_linked
+  
+  default_scope :order => "position"  
+  
+  protected
+  def presence_of_linked
+    self.errors.add :linked, :empty if self.linked.blank? || self.linked.marked_for_destruction?
+  end
+end