westarete-skylinecms 3.0.8.20100329

data/app/models/skyline/media_cache.rb

@@ -0,0 +1,39 @@
+# @private
+class Skyline::MediaCache < ActiveRecord::Base    
+  set_table_name :skyline_media_cache  
+  cattr_accessor :cache_path
+  @@cache_path ||= Skyline::Configuration.media_file_cache_path
+    
+  after_destroy :expire_cache
+    
+  class << self
+    def delete_file(path)
+      if File.file?(path)
+        File.delete(path)
+        dir = File.basename(path)
+        if File.directory?(dir) && Dir.entries(dir).size == 2
+          Dir.delete(dir) rescue nil
+        end
+      else
+        logger.error "Could not sweep #{path}"
+      end      
+    end            
+    
+  end
+  
+  private
+
+  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}"
+
+    logger.info "Sweeping #{path}"
+    delete_file(path)
+  end
+
+  def delete_file(path)
+    self.class.delete_file(path)
+  end
+  
+end

data/app/models/skyline/media_dir.rb

@@ -0,0 +1,62 @@
+# @private
+class Skyline::MediaDir < Skyline::MediaNode
+  extend ActiveSupport::Memoizable
+  include UniqueIdentifiers
+  
+  has_many :files, :foreign_key => "parent_id", :class_name => "Skyline::MediaFile"
+  has_many :nodes, :foreign_key => "parent_id", :class_name => "Skyline::MediaNode", :order => "type,name", :dependent => :destroy
+  has_many :subdirectories, :foreign_key => "parent_id", :class_name => "Skyline::MediaDir"
+            
+  after_save :update_children_path
+  
+  unique_identifier :name, :scope => :parent_id, :default => "new_folder"
+  
+  validate :only_one_root
+    
+  class << self
+    extend ActiveSupport::Memoizable
+    # returns an Array of hashes
+    #
+    # ==== Returns
+    # Array[Hash]:: Array of hashes grouped by parent_id
+    def group_by_parent_id
+      dirs = self.find(:all, :order => :name)
+    
+      out={}
+      dirs.each do |o|
+        out[o[:parent_id]] ||= []
+        out[o[:parent_id]] << o
+      end 
+      out       
+    end
+    
+    def root
+      self.find_by_parent_id(nil)
+    end
+  end        
+  
+  def root?
+    !self.parent_id
+  end
+   
+  protected  
+  def update_children_path
+    if self.renamed?      
+      sub_path = [(self.path && self.path.empty? ? nil : self.path),self.name.to_s].compact      
+      Skyline::MediaFile.update_all("path = '#{sub_path}'","parent_id = #{self.id}")
+
+      self.subdirectories.each do |dir|
+        dir.path = File.join(sub_path)
+      end
+    end
+  end
+  def only_one_root
+    if !self.parent_id
+      if self.new_record?
+        self.errors.add "cannot be another root node" if self.class.root
+      else
+        self.errors.add "cannot be another root node" if self.class.root && self.class.root.id != self.id
+      end
+    end
+  end 
+end

data/app/models/skyline/media_file.rb

@@ -0,0 +1,156 @@
+# @private
+class Skyline::MediaFile < Skyline::MediaNode    
+  has_and_belongs_to_many :tags, :class_name => "Skyline::Tag", :join_table => "skyline_media_files_skyline_tags"
+	  
+  include Skyline::Taggable
+
+  after_create :store_data
+  after_destroy :remove_data, :reset_ref_object
+  validates_presence_of :data, :on => :create
+  validates_uniqueness_of :name, :scope => "parent_id"
+  
+  default_scope :order => :name
+    
+  def self.set_missing_file_types
+    self.all(:conditions => "file_type = '' OR file_type IS NULL").each do |media_file|
+      media_file.set_file_type!
+    end
+    true
+  end
+  
+  # returns thumbnail of image
+  # ==== Parameters
+  # width<Integer>:: required width of the thumbnail
+  # height<Integer>:: required height of the thumbnail
+  #
+  # ==== Returns
+  # <ImageBlob>:: blob of the Magick::Image  
+  def thumbnail(width=100,height=100)
+    img = Magick::Image::read(self.file_path).first
+    
+    width,height = self.proportional_dimension(width,height,img.columns,img.rows)
+    
+    stream = img.change_geometry!("#{width}x#{height}"){ |c,r,i| i.resize!(c,r) }
+    stream.to_blob        
+  end
+
+  # returns the dimension of the original image
+  #
+  # ==== Returns
+  # <Hash>:: hash of width and height attributes
+  def dimension
+    return nil if self.file_type != "image"
+    {"width" => self.width, "height" => self.height}
+  end
+  
+  # Calculate the proportional dimension of this media file
+  # this method will never go beyond the bounds of org_w and org_h.
+  # 
+  # @param width [Integer] The target width of this calculation
+  # @param height [Integer] The target height of this calculation
+  # @param org_w [Integer] The original width
+  # @param org_h [Integer] The origin height
+  #
+  # @return Array<Integer,Integer> The new width and height
+  def proportional_dimension(width,height,org_w = self.width, org_h = self.height)
+    return nil if org_w.blank? && org_h.blank?
+
+    # Make sure we don't go beyond the actual size!
+    if (width.to_i > org_w || height.to_i > org_h) 
+      width = [width.to_i, org_w].min
+      height = [height.to_i, org_h].min
+    end
+    
+    w_factor = width.to_f / org_w.to_f
+    h_factor = height.to_f / org_h.to_f
+    factor = case 
+      when w_factor == 0 then h_factor
+      when h_factor == 0 then w_factor
+      else [w_factor, h_factor].min
+    end
+    
+    [(org_w*factor).round, (org_h*factor).round]
+  end
+  
+  # sanitize filename and set correct mime-type for IO object of file data
+  #
+  # ==== Parameters
+  # data<IO>:: IO object with file data
+  #
+  # ==== Returns
+  # data<IO>:: IO object with sanitized filename and correct mime-type
+  def data=(data)
+    unless data.size == 0
+      @data = data
+      self.name = sanitize_filename(@data.original_filename)
+      
+      # Fix the mime types
+      @data.content_type = MIME::Types.type_for(@data.original_filename).to_s
+      self.content_type = @data.content_type.downcase.gsub(/[^a-z\-\/]/,"")
+      self.file_type = self.determine_file_type
+      
+      self.set_dimensions
+      self.size = @data.size
+    end
+    @data
+  end
+
+  def data
+    @data
+  end
+
+  def url(prefix=nil)
+    if prefix
+      "/media_dirs/#{self.parent_id}/media_files_data/#{prefix}/#{self.name}"
+    else
+      "/media_dirs/#{self.parent_id}/media_files_data/#{self.name}"
+    end
+  end
+  
+  def determine_file_type
+    lookup = Mime::Type.lookup(self.content_type)
+    lookup.instance_variable_get("@symbol").to_s
+  end
+  
+  def set_file_type!
+    file_type = determine_file_type
+    self.update_attribute(:file_type, file_type) unless file_type.blank?
+  end
+      
+  protected
+  
+  def set_dimensions
+    return if self.file_type != "image"
+    
+    begin
+      img = case self.data
+      when ActionController::UploadedTempfile,Tempfile
+        Magick::Image::read(self.data.path).first
+      else
+        Magick::Image::from_blob(self.data.read).first
+        self.data.rewind        
+      end
+      
+      self.width = img.columns
+      self.height = img.rows
+    rescue
+    end
+  end
+  
+  
+  # Write data to disk
+  def store_data
+    File.open(self.file_path,"wb"){ |f| f.write(self.data.read) } if self.data
+  end
+  
+  # Remove data from disk
+  def remove_data
+    File.unlink(self.file_path) if File.exist?(self.file_path)
+  end 
+  
+  # reset ref objects that refer to removed media file
+  # 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
+end

data/app/models/skyline/media_node.rb

@@ -0,0 +1,105 @@
+# @private
+class Skyline::MediaNode < ActiveRecord::Base
+  set_table_name :skyline_media_nodes
+
+  belongs_to :directory, :foreign_key => "parent_id", :class_name => "Skyline::MediaDir"
+  
+  cattr_accessor :assets_path
+  @@assets_path ||= Skyline::Configuration.assets_path
+
+  before_create :set_path  
+  
+  class << self
+    # sanitize nodename
+    # ==== Parameters
+    # filename<String>:: nodename that has to be sanitized
+    #
+    # ==== Returns
+    # <String>:: sanitized nodename
+    def sanitize_filename(filename)
+      filename = filename.gsub("\\","/")
+      filename = filename.downcase.gsub(/[^a-z0-9\.\-\+_]/,"_").squeeze("_")
+      filename = "_#{filename}" if filename =~ /^\.+$/
+      filename
+    end
+     
+  end
+  
+  # check if filename has been sanitized
+  # ==== Returns
+  # <Boolean>:: true if sanitized
+  def sanitized?
+    @sanitized
+  end
+
+  # return the sanitized nodename as name
+  #
+  # ==== Parameters
+  # name<String>:: original nodename
+  #
+  # ==== Returns
+  # <String>:: satized name
+  def name=(name)
+    name = sanitize_filename(name)
+    @renamed = true if name != self.name
+    self.write_attribute(:name,name)
+  end
+
+  # write the path of the node
+  #
+  # ==== Parameters
+  # name<String>:: original nodename
+  def path=(name)
+    @renamed = true if name != self.name
+    self.write_attribute(:path,name)
+  end  
+  
+  # check if node has been renamed after sanitizing the name
+  # ==== Returns
+  # <Boolean>:: true if renamed
+  # sets @renamed if file was sanitized  
+  def renamed?
+    @renamed
+  end
+  
+  # returns the full path of the media node
+  # ==== Retruns
+  # <String>:: Full path including parent and filename
+  def full_path
+    p = File.join(self.path.to_s,self.name) 
+    p = p[1,p.size] if p[0,1] == "/"
+    p
+  end
+  
+  # returns the path of the media node
+  # ==== Retruns
+  # <String>:: path 
+  def file_path
+    File.join(self.class.assets_path,self.id.to_s)
+  end  
+
+  def title
+    self[:title].present? ? self[:title] : self.name
+  end
+
+  protected
+  # set the path of a directory node extracted from directory.full_path   
+  def set_path
+    return unless self.directory
+    self.path = self.directory.full_path
+  end
+  
+  # sanitize nodename
+  # ==== Parameters
+  # filename<String>:: nodename that has to be sanitized
+  #
+  # ==== Returns
+  # <String>:: sanitized nodename
+  # sets @sanitized if file was sanitized
+  def sanitize_filename(filename)    
+    orig = filename.dup
+    filename = self.class.sanitize_filename(filename)      
+    @sanitized = true if filename != orig
+    filename    
+  end  
+end

data/app/models/skyline/object_ref.rb

@@ -0,0 +1,48 @@
+# @private
+class Skyline::ObjectRef < Skyline::RefObject	
+  after_destroy :destroy_referable
+  
+	def respond_to?(m)
+		return true if super
+		if self.referable
+			self.referable.respond_to?(m)
+		else
+			super
+		end
+	end
+	
+	def method_missing(m,*a)
+		if self.referable && self.referable.respond_to?(m)
+			self.referable.send(m,*a)
+		else
+			super
+		end
+	end			
+	
+	def blank?
+	  self.referable.blank?
+  end
+  
+  def present?
+	  self.referable.present?
+  end
+  
+  def external?
+    self.referable.andand.respond_to?(:external?) ? self.referable.external? : false
+  end
+  
+  def file?
+    self.referable_type == "Skyline::MediaFile"
+  end
+  
+  def clone
+    returning super do |clone|
+      clone.referable = self.referable.clone if self.referable.kind_of?(Skyline::ReferableUri)
+    end
+  end
+  
+  protected
+  def destroy_referable
+    self.referable.destroy if self.referable.kind_of?(Skyline::ReferableUri)
+  end
+end

data/app/models/skyline/page.rb

@@ -0,0 +1,264 @@
+class Skyline::Page < Skyline::Article
+  class Data < Skyline::Article::Data
+    before_validation :sanitize_url_part
+    validate :validate_url_part, :if => :to_be_published  
+    validates_presence_of :title  
+
+    def navigation_title
+      self[:navigation_title].present? ? self[:navigation_title] : self.title.to_s
+    end
+
+    def title_tag
+      self[:custom_title_tag].present? ? self[:custom_title_tag] : self.title
+    end
+
+    protected
+
+    def after_initialize
+      self.title ||= I18n.t(:default_title, :scope => [:page_version])    
+    end
+
+    def sanitize_url_part
+      self.url_part = self.url_part.to_s.downcase.gsub(/[^a-z0-9\.\-\+_]/,"_").squeeze("_") if self.url_part
+    end
+
+    def validate_url_part
+      return if self.version.article.root?
+      if self.url_part.blank?
+        self.errors.add :url_part, :blank 
+      else
+        if match = self.version.article.parent.children.find_by_url_part(self.url_part)
+          self.errors.add :url_part, :taken  if match != self.version.article
+        end
+      end      
+    end
+  end
+  
+  include Skyline::Positionable
+  self.positionable_scope = :parent_id
+  
+  has_many :children, :class_name => "Skyline::Page", :foreign_key => :parent_id, :dependent => :destroy
+  belongs_to :parent, :class_name => "Skyline::Page", :foreign_key => :parent_id
+      
+  before_save :set_url_part
+  after_save :process_move_behind
+  
+  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]}
+  
+  default_scope :order => "position"
+ 
+  class << self
+    extend ActiveSupport::Memoizable
+    
+    def right_prefix
+      "page"
+    end  
+    
+    # returns an Array of hashes
+    #
+    # ==== Returns
+    # <Array[Hash]>:: Array of hashes grouped by parent_id
+    def group_by_parent_id
+      out = {}
+      pages = self.connection.select_all("
+        SELECT page.id,
+               page.parent_id,
+               data.navigation_title as navigation_title,
+               data.title as title,
+               page.locked,
+               page.published_publication_id,
+               page.default_variant_id,
+               published_publication.variant_id AS published_publication_variant_id,
+               published_publication.version AS published_publication_version,
+               default_variant.version AS default_variant_version
+        FROM #{self.table_name} AS page
+        LEFT JOIN skyline_page_data AS data ON data.id=page.default_variant_data_id
+        LEFT JOIN skyline_article_versions AS published_publication ON published_publication.id=page.published_publication_id
+        LEFT JOIN skyline_article_versions AS default_variant ON default_variant.id=default_variant_id
+        WHERE page.type='Skyline::Page'
+        ORDER BY page.position")
+
+      pages.each do |o|
+        class << o
+          def id; self["id"].to_i; end
+          def parent_id; self["parent_id"].blank? ? nil : self["parent_id"].to_i; end
+          def title
+            if self["navigation_title"].blank?
+              self["title"].blank? ? "n/a" : self["title"]
+            else
+              self["navigation_title"]
+            end
+          end
+          def published?; self["published_publication_id"].present?; end
+          def identical_to_publication?
+            self["published_publication_variant_id"] == self["default_variant_id"] && self["published_publication_version"] == self["default_variant_version"]
+          end
+          def open; true; end
+        end
+
+        out[o.parent_id] ||= []
+        out[o.parent_id] << o
+      end
+      out
+    end
+    
+    def root
+      self.first(:conditions => "parent_id IS NULL")
+    end
+    
+    # build menu of certain level
+    # ==== Parameters
+    # level<Integer>:: level of the menu that has to be returned
+    # nesting<Array>:: the nesting of page starting with the root node
+    #
+    # ==== Returns
+    # <Array>:: an array of pages to display in the menu
+    def menu(level = 1, nesting = nil)
+      menu = []
+      menu << {:page => self.root, :children => []} if level == 1 && self.root.in_navigation?
+      nesting ||= [self.root]
+      menu += nesting[level-1].menu if nesting[level-1]
+      menu
+    end
+    
+    # Find the page by url_parts and return the page and url_parts left over after we've found
+    # the deepest page.
+    #
+    # @param [Array<String>] url_parts The url_parts to look for
+    # @param [Skyline::Page] root An optional root to search in.
+    # 
+    # @return [Array<Skyline::Page,Array<String>>] First return parameter is the deepest page we found (can be nil), 
+    #   the second return is the url_parts not consumed by the found page.
+    def find_by_url(url_parts, root = nil)
+      root ||= self.root
+      return nil unless root
+      return [root, []] if url_parts.empty?
+      if child = root.children.find_by_url_part(url_parts.first)
+        return self.find_by_url(url_parts[1..-1], child)
+      end
+      return [root, url_parts]
+    end
+    
+  	def reorder(pages)
+  		return unless pages.kind_of?(Array)
+  		pages.each_with_index do |parent_id, position|
+  			self.connection.execute("UPDATE #{self.table_name} SET position=#{position.to_i} WHERE id=#{parent_id.to_i}")
+  		end  		
+		end
+	end
+  
+  def root?
+    !self.parent
+  end
+  
+  def nesting
+    self.root? ? [self] : self.parent.nesting + [self]
+  end
+  memoize :nesting
+  
+  def parents
+    self.nesting.dup[0..-2]
+  end
+  
+  # Returns the path (url excluding current url_path), with trailing /
+  # for the root page: nil
+  # pages directly in the root: /
+  # other pages, ie: /a/b/c/
+  def path
+    return nil if self.root?
+    path = "/" + self.parents[1..-1].collect{|page| page.url_part}.join("/") + "/"
+    path.squeeze("/")
+  end
+  
+  def url
+    return "/" if self.root?
+    self.path + self.url_part
+  end
+
+  def menu
+	  self.children.collect{|child| {:page => child, :children => child.menu} if child.published_publication_data.andand.in_navigation?}.compact
+  end
+
+  def destroyable?
+    !self.persistent? && self.children.empty? && self.published_publication == nil
+  end
+  
+  def keep_history?
+    Skyline::Configuration.enable_publication_history
+  end
+
+    
+  # create a new page on position
+  # ==== Parameters
+  # position<Symbol>:: Can either be :below, :above or :in
+  #
+  # ==== Returns
+  # <Page>:: The new page
+  def create_new!(position)
+    page = Skyline::Page.new
+    
+    self.class.transaction do
+	    case position
+	  	when :below
+	  		page.parent = self.parent
+  			page.position = self.position + 1
+  			self.class.connection.execute("UPDATE #{self.class.table_name} SET position=position+1 WHERE #{self.parent ? "parent_id=#{self.parent.id}" : 'parent_id IS NULL'} AND position>#{self.position}")
+			when :above
+				page.parent = self.parent
+  			page.position = self.position
+  			self.class.connection.execute("UPDATE #{self.class.table_name} SET position=position+1 WHERE #{self.parent ? "parent_id=#{self.parent.id}" : 'parent_id IS NULL'} AND position>=#{self.position}")
+			when :in
+				page.parent = self
+			end    
+			
+			page.sites << self.site
+			page.save
+		end
+		page
+	end
+  
+	def move_behind=(parent_id)
+	  @do_move_behind = true
+	  @move_behind = parent_id
+  end
+    
+  protected
+  
+  def process_move_behind
+    if @do_move_behind
+      if move_behind = self.class.find_by_id(@move_behind)
+        self.class.connection.execute("UPDATE #{self.class.table_name} SET position=position+1 WHERE parent_id=#{self.parent_id} AND position > #{move_behind.position}")
+        self.class.connection.execute("UPDATE #{self.class.table_name} SET position=#{move_behind.position + 1} WHERE id=#{self.id}")
+      else
+        self.class.connection.execute("UPDATE #{self.class.table_name} SET position=position+1 WHERE parent_id=#{self.parent_id}")
+        self.class.connection.execute("UPDATE #{self.class.table_name} SET position=0 WHERE id=#{self.id}")
+      end
+      @do_move_behind = nil
+      @move_behind= nil
+    end
+  end
+  
+  def set_url_part
+    self.url_part = "page-#{self.position}" if self.url_part.blank?
+  end
+
+  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
+      else
+        self.errors.add_to_base "cannot be another root node" if self.site.root && self.site.root.id != self.id
+      end
+    end
+  end
+  
+  def confirm_destroyability
+    raise StandardError, "can't be destroyed because this page has children" if self.children.any?
+    super
+  end  
+
+end

data/app/models/skyline/page_fragment.rb

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