skylinecms 3.0.7

data/lib/skyline/content/meta_data/field_group.rb

@@ -0,0 +1,83 @@
+module Skyline::Content
+  module MetaData
+    class FieldGroup < Array #:nodoc:
+      attr_accessor :name, :owner, :title
+  
+      def initialize(options)
+        super([])
+  
+        self.name = options[:name]
+        self.title = options[:title]
+        self.owner = options[:owner]
+  
+        self.field(options[:field]) if options[:fields] && options[:fields].any?    
+      end
+  
+      def singular_title
+        return self.name.to_s.humanize if self.title.blank?
+        self.title.kind_of?(Array) && self.title.first || self.title.to_s
+      end
+  
+      def plural_title
+        return self.name.to_s.humanize.pluralize if self.title.blank?
+        self.title.kind_of?(Array) && self.title.last || self.title.to_s.pluralize
+      end
+  
+      def inspect
+        "#<FieldGroup fields=#{super}>"
+      end
+  
+      def field(*fields,&block)
+        created_fields = self.owner.field(*fields,&block)
+        self.concat(created_fields.map(&:name))
+  
+        # Remove newly grouped fields from the ungrouped list as well as the existing order
+        current_order = self.owner.field_order.dup
+        fields.each do |field_name| 
+          next unless field_name.kind_of?(Symbol)
+  
+          self.owner.ungrouped_fields.delete(field_name)
+          current_order.delete(field_name)
+        end
+        self.owner.field_order(*current_order)
+  
+        created_fields
+      end
+  
+      def each_field(&block)  
+        self.each do |field_name|
+          yield_field(field_name, &block)
+        end      
+      end  
+  
+      def only_each_field_of(selection,&block)
+        selection.each do |field_name|
+          if self.include?(field_name)          
+            yield_field(field_name,&block)
+          else
+            yield nil
+          end
+        end    
+      end
+  
+      def field_names
+        self.to_a
+      end
+  
+      def columns_hash
+        self.owner.columns_hash
+      end
+      
+      # You can't hide groups
+      def hidden_in(scope)
+        false
+      end
+  
+      private   
+      # Checks if the field exists, if it does it yields it otherwise it creates a new one.  
+      def yield_field(name,&block)
+        self.owner.send(:yield_field,name,&block)
+      end    
+    end  
+  end
+end

data/lib/skyline/content/meta_data/field_page.rb

@@ -0,0 +1,82 @@
+module Skyline::Content
+  module MetaData
+    class FieldPage #:nodoc:
+  
+      attr_reader :owner,:name,:options
+  
+      def initialize(owner,name,options={})
+        @owner = owner
+        @name = name
+        @options = options
+        @fields = {}
+        @ungrouped_fields = []
+      end
+  
+      def description(v=nil)
+        @options[:description] = v if v
+        @options[:description]
+      end
+      
+      def title(v=nil)
+        @options[:title] = v if v
+        @options[:title]
+      end
+  
+      def each_field(&block)
+        self.ungrouped_fields.each do |field_name|
+          yield_field(field_name,&block)
+        end
+      end
+  
+      def yield_field(field_name,&block)
+        yield self.fields[field_name]
+      end
+  
+      def field(*fields,&block)
+        options = fields.last.kind_of?(Hash) ? fields.pop : {}
+        fields = fields.first if fields.any? && fields.first.kind_of?(Array)
+  
+        fields.map do |name|
+          @fields[name] = Field.new(options.update(:name => name, :owner => self))
+          yield @fields[name] if block_given?
+          @ungrouped_fields << name
+          @fields[name]
+        end
+      end
+  
+      def field_group(name,options={})
+        field_group = FieldGroup.new(options.update(:owner => self, :name => name))
+        yield field_group if block_given?
+        @fields[name] = field_group
+        @ungrouped_fields << name
+      end
+  
+      def fields
+        @fields
+      end
+  
+      def field_order(*order)
+        if order.empty?
+          @ungrouped_fields
+        else
+  
+        end
+      end
+  
+      def ungrouped_fields
+        @ungrouped_fields
+      end
+  
+      def field_names
+        @fields.keys
+      end
+  
+      def human_name
+        self.title.present? ? self.title : self.name.to_s.humanize
+      end
+  
+      def owner; @owner; end
+  
+    end  
+  end
+end

data/lib/skyline/content/orderable.rb

@@ -0,0 +1,81 @@
+#
+# @private
+module Skyline::Content
+  module Orderable
+    
+    def acts_as_orderable(options)
+      config = {:column => "position", :scope => "1 = 1"}
+      config.update(options) if options.kind_of?(Hash)
+      
+      config[:scope] = "#{config[:scope]}_id".intern if config[:scope].is_a?(Symbol) && config[:scope].to_s !~ /_id$/
+
+      class << self; self; end.class_eval do
+        define_method(:orderable?){true}
+        define_method(:position_column) do
+          config[:column]
+        end
+        define_method(:position_scope) do
+          config[:scope]
+        end
+      end
+      
+      include Skyline::Content::Orderable::InstanceMethods
+      if config[:scope].is_a?(Symbol)
+        define_method(:position_scope_condition) do
+          if (value = self.send(self.class.position_scope)).nil?
+            "#{self.class.position_scope} IS NULL"
+          else
+            "#{self.class.position_scope} = #{value}"
+          end            
+        end
+      else
+        define_method(:position_scope_condition) do
+          config[:scope]
+        end
+      end        
+
+      self.before_create :set_initial_position
+      self.sort_order [:position,:asc],[:id,:asc]      
+    end
+    
+    
+    # Accepts a list of ids which will then
+    # be put in the order they are provided by 
+    # keeping the positions and reshuffling them
+    def reorder(*ids)
+      ids.flatten!
+      objects = find_all_by_id(ids)
+      return false if ids.size != objects.size
+      
+      positions = objects.collect{|o| o[self.position_column] || o.id }
+      positions.sort!
+            
+      objects.each do |object|
+        idx = ids.index(object.id)
+        unless positions[idx] == object[self.position_column]
+          object.update_attribute(self.position_column,positions[idx]) 
+        end
+      end
+    end
+              
+    module InstanceMethods
+      def set_initial_position
+        unless self[self.class.position_column]
+          self[self.class.position_column] = self.current_bottom_position + 1
+        end
+      end
+      
+      protected
+      
+      # Overriden by setting :scope
+      def position_scope_condition
+        "1"
+      end
+      
+      def current_bottom_position
+        conditions = position_scope_condition
+        self.class.connection.select_value("SELECT #{self.class.position_column} FROM #{self.class.table_name} WHERE #{conditions} ORDER BY #{self.class.position_column} DESC LIMIT 1").to_i
+      end
+    end
+  end # Orderable
+end

data/lib/skyline/content/stack.rb

@@ -0,0 +1,111 @@
+# @private
+class Skyline::Content::Stack < Array
+  
+  def logger
+    RAILS_DEFAULT_LOGGER
+  end
+
+  def initialize(implementation,types)
+    @implementation = implementation
+    @raw_types = types
+    self.types.each do |type,id|
+      instantiate!(type,id)
+    end
+  end
+  
+  # You can only push on the stack if the last item on the stack is an object
+  # You can't push something on the stack if it's a collection, this would break the types array
+  def push(type,id=nil)
+    raise NameError, "You can't push onto the stack if the last item is a collection!" if self.types.last.last.nil?
+    self.types << [type,id]
+    instantiate!(type,id)
+  end
+  
+  # URL based on the current stack
+  #
+  # Up and down can be combined! If we currently have [[:pages,1],[:pages,13],[:pages,29]] in the types array
+  # and we pass in \{:up => 1, :down => [:articles,5]} we will end up with [[:pages,1],[:pages,13],[:articles,5]]
+  #
+  # If by accident nil is still in the types array (due to incorrectly walkin up the types array) it will be compacted.
+  # be aware that this might break things!
+  # @param [Hash] options The options to use
+  # @option options [Integer] :up Integer which tells the url how many type levels we should walk up
+  # @option options [Array<String>] :down Array of items to add to the types array
+  # @option options [Boolean] :collection If set to true doesn't add the ID of the last object on the stack. Doesn't do anything if the last object
+  #   on the type array isn't an ID
+  def url_types(options={})
+    base = self.types.dup.flatten
+    base.pop if options[:collection]
+    base = base[0..((-2*options[:up].to_i) -1 )]
+    base += options[:down] if options[:down]
+    base.compact
+  end
+  
+  # The current last object on the stack
+  def current
+    self.last
+  end
+  
+  # The parent object on the stack (2 stacklevels up, because one would be the collection)
+  def parent
+    self[-2]
+  end
+  
+  def has_parent?
+    !self.parent.nil?
+  end
+    
+  # The collection of which "current" is a member
+  def collection
+    self.parent.send(self.parent_collection_name) if self.parent_collection_name
+  end
+  alias :parent_collection :collection
+  
+  def collection_name
+    self.types.last[0]
+  end
+  alias :parent_collection_name :collection_name
+  
+  def klass
+    self.current.class
+  end
+  
+  def types
+    return @types if @types
+    @types = []
+    t = @raw_types
+    (0..t.size-1).step(2){|i| @types << [t[i].to_sym,t[i+1] && t[i+1].to_i ] }
+    @types
+  end
+  
+  def object_for_type(type)
+    self[self.types.index(type)]
+  end
+
+  protected
+  
+  def instantiate!(type,id)
+    # We're currently operating on an object
+    if id
+      if self.empty?
+        self << @implementation.content_class(type).find(id) 
+      else
+        self << self.last.send(type).find(id)
+      end
+    # Now we're working on a collection (we'll instantiate a new object for uniformity)
+    else
+      if self.empty?
+        logger.warn "typ " + type.inspect
+        self << @implementation.content_class(type).new      
+      else
+        logger.debug "Trying: #{type} :: #{self.last.class.reflect_on_association(type.to_sym).inspect}"
+        assoc = self.last.class.reflect_on_association(type)
+        self << case assoc.macro
+          when :has_many : self.last.send(type).build
+          else assoc.klass.new
+        end
+      end
+    end
+  end
+  
+end

data/lib/skyline/content/versioning/version.rb

@@ -0,0 +1,42 @@
+class Skyline::Content::Versioning::Version < ActiveRecord::Base
+  set_table_name "skyline_versions"
+  belongs_to :versionable, :polymorphic => true
+  alias_attribute :current_version, :version
+  alias_attribute :current_author, :author
+  
+  class << self        
+    # Increase the version number of the record
+    # add the username as updater.
+    # --
+    def increase!(record,user)
+      class_name = self.class_name(record)
+      logger.warn("[VERSIONING] -- <#{class_name}: #{record.id}> [INCREASE]")
+      if id = self.connection.select_value("SELECT id FROM #{self.table_name} WHERE versionable_type = '#{class_name}' AND versionable_id = #{record.id} LIMIT 1")
+        self.connection.update "UPDATE #{self.table_name} SET version = version+1, author = '#{user.username.to_s}' WHERE id = #{id}"
+      else
+        self.connection.insert "INSERT INTO #{self.table_name} (versionable_type,versionable_id,version,author) VALUES ('#{class_name}',#{record.id},1,'#{user.username.to_s}')"
+      end
+    end
+    
+    # Remove the version as the original
+    # record has also been removed.
+    # --
+    def destroy!(record)
+      class_name = self.class_name(record)        
+      logger.warn("[VERSIONING] -- <#{class_name}: #{record.id}> [DESTROY]")
+      self.delete_all("versionable_type = '#{class_name}' AND versionable_id = #{record.id}")
+    end
+    
+    protected
+    
+    def class_name(record)
+      record.class.name
+    end
+  end
+ 
+  # Version objects SHOULD NOT BE SAVED!
+  def save(*params)
+    return true
+  end
+  
+end

data/lib/skyline/content/versioning/versionable.rb

@@ -0,0 +1,38 @@
+module Skyline::Content
+  module Versioning
+    module Versionable
+      def self.included(obj)
+        obj.send(:has_one, :skyline_version, :as => :versionable, :class_name => "Skyline::Content::Versioning::Version")
+        obj.send(:delegate, :current_author, :to => :version)      
+      end
+      
+      
+      def version
+        self.skyline_version || self.build_skyline_version(:version => 1, :author => "")
+      end
+      
+      def current_version
+        return @skyline_from_version if @skyline_keep_from_version && @skyline_from_version
+        self.version.current_version
+      end
+      
+      # The version this new data we want to save is built on.
+      # --
+      def from_version=(version)
+        @skyline_from_version = version.to_i
+      end
+      
+      def keep_version!
+        @skyline_keep_from_version = true
+      end
+      
+      
+      # Does the version of the data to save match the one in the DB?
+      # --
+      def matching_versions?
+        return true if @skyline_from_version.blank?
+        self.version.current_version == @skyline_from_version
+      end
+    end
+  end
+end

data/lib/skyline/content_item.rb

@@ -0,0 +1,197 @@
+# Use this Module in in a class that references a Page/MediaFile etc throug an ObjectRef
+#
+#
+# Usage: 
+# class Model < ActiveRecord::Base
+#   include Skyline::ContentItem
+# 
+#   referable_content :teaser      (column teaser_id must be crreated)
+# end
+#
+# 
+# 1) Gives your Model the following interface:
+# 
+#    class Model < ActiveRecord::Base
+#      before_save :set_refering_type_and_id
+#      after_create :set_refering_id
+#      named_scope :published             (scope to return only published items)
+#
+#      def referable_content(*fields)
+#
+#      belongs_to :teaser, :class_name => "Skyline::ObjectRef", :foreign_key => "teaser_id", :dependent => :destroy
+#      accepts_nested_attributes_for :teaser, :reject_if => proc {|attributes| attributes['referable_type'].blank?}, :allow_destroy => true
+#      [validates_presence_of :teaser     (only if options[:allow_nil] is not set)]
+#     
+#      def teaser_with_passthrough=(obj)            (obj can be an ObjectRef or a Teaser, in which case it will be passed through)
+#      alias_method_chain :teaser=, :passthrough
+#    end
+#
+#
+# ***** OR *****
+#
+# it can be used to reference a Page/MediaFile etc directly when the foreign key must be serialized (or isn't available as an association)
+#
+# Usage: 
+# class Settings < ActiveRecord::Base
+#   include Skyline::ContentItem
+# 
+#   referable_serialized_content  :results_page      (obj.results_page_id and obj.results_page_id= must be available)
+# end
+#
+# 
+# 1) Gives your Settings the following interface:
+# 
+#    class Settings < ActiveRecord::Base
+#      def referable_serialized_content(*fields)
+#
+#      def results_page_attributes=       (set results_page_id to the referable_id; bypassing an ObjectRef)
+#    end
+
+module Skyline::ContentItem 
+  def self.included(base)
+    base.extend(ClassMethods)
+
+    base.send(:before_save, :set_refering_type_and_id)
+    base.send(:after_create, :set_refering_id)
+    base.send(:cattr_accessor, :referable_contents)
+    base.send(:attr_accessor, :previous_referables)
+    base.send(:alias_method_chain, :clone, :referable_content)
+    base.send(:after_save, :possibly_destroy_previous_referables)
+    base.send(:after_destroy, :possibly_destroy_referables)
+    
+    base.send("referable_contents=", [])
+    
+    base.class_eval do
+      
+      named_scope :published, lambda {
+        if self.respond_to?(:publishable?) && self.publishable?
+          {:conditions => {:published => true}}
+        elsif self.ancestors.include?(Skyline::Article::Data)
+          {:include => self.table_name.sub("_data", "").to_sym,
+           :conditions => "skyline_articles.published_publication_data_id = #{self.table_name}.id"}
+        else
+          {}
+        end
+      }
+
+      named_scope :with_site, lambda {|site|
+        if site && self.ancestors.include?(Skyline::Article::Data)
+          site.named_scope_with_site_for(self)
+        else
+          {}
+        end
+      }
+    end
+  end  
+  
+  module ClassMethods   
+
+    # accepts options as the last parameter
+    #   options[:allow_nil] = true/false    (default: true)
+    def referable_content(*fields)
+      options = fields.extract_options!.reverse_merge(:allow_nil => true)
+      fields.each do |f|
+        self.referable_contents << f
+                
+        belongs_to f, :class_name => "Skyline::ObjectRef", :foreign_key => "#{f}_id", :dependent => :destroy
+        accepts_nested_attributes_for f, :reject_if => proc {|attributes| attributes['referable_type'].blank?}, :allow_destroy => true
+
+        unless options[:allow_nil]
+          # validating on :linked instead of :linked_id here; see:
+          #   http://railsforum.com/viewtopic.php?id=30300
+          #   https://rails.lighthouseapp.com/projects/8994/tickets/1943
+          #   https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2815-nested-models-build-should-directly-assign-the-parent          
+          validates_presence_of f
+        end
+
+        self.class_eval(<<-END, __FILE__, __LINE__ + 1)
+          def #{f}_with_passthrough=(obj)
+            if obj.kind_of?(Skyline::ObjectRef)
+              self.#{f}_without_passthrough = obj
+            else
+              self.attributes = {"#{f}_attributes" => {:referable_type => obj.class.name, :referable_id => obj.id}}
+            end
+          end
+          alias_method_chain :#{f}=, :passthrough
+          
+          def #{f}_attributes=(attributes)
+            referable_params = attributes.delete("referable_attributes")
+            self.previous_referables ||= {}
+            self.previous_referables[:#{f}] = self.#{f}.referable.dup if self.#{f}.andand.referable
+            assign_nested_attributes_for_one_to_one_association(:#{f}, attributes)
+  
+            # only create and modify referable if it is a Skyline::ReferableUri
+            if self.#{f} && attributes[:referable_type] == "Skyline::ReferableUri"
+              self.#{f}.referable.reload if self.#{f}.referable
+              self.#{f}.referable ||= attributes[:referable_type].constantize.new
+            
+              if referable_params.kind_of?(Hash)
+                referable_params.each do |k, v|
+                  self.#{f}.send(k.to_s + "=", v) if self.#{f}.respond_to?(k.to_s + "=")
+                end
+              end
+            end
+          end          
+        END
+      end
+    end
+    
+    def referable_serialized_content(*fields)
+      fields.each do |f|
+        self.class_eval <<-END
+          def #{f}_attributes=(attr)
+            self.#{f}_id = attr[:referable_id]
+          end
+        END
+      end
+    end
+  end
+  
+  def set_refering_type_and_id
+    self.referable_contents.each do |field|
+      if object_ref = self.send(field)
+        object_ref.refering_type = self.class.name
+        object_ref.refering_id = self.id unless self.new_record?
+      end
+    end
+  end
+  
+  def set_refering_id
+    self.referable_contents.each do |field|
+      if object_ref = self.send(field) 
+        object_ref.update_attribute(:refering_id, self.id) if object_ref.refering_id.blank?
+      end
+    end
+  end
+  
+  def clone_with_referable_content
+    returning clone_without_referable_content do |clone|      
+      if self.referable_contents.any?
+        self.referable_contents.each do |field|
+          if self.send(field).present?
+            clone.send("#{field}_id=", nil)
+            clone.send("#{field}=", self.send(field).clone)
+          end
+        end
+      end
+    end
+  end
+  
+  def possibly_destroy_previous_referables
+    return unless self.previous_referables
+    self.previous_referables.each do |field, previous_referable|
+      if previous_referable != self.send(field).referable
+        previous_referable.destroy if previous_referable.kind_of?(Skyline::ReferableUri)
+      end
+    end
+  end
+  
+  def possibly_destroy_referables
+    self.referable_contents.each do |field|
+      if object_ref = self.send(field) 
+        object_ref.destroy if object_ref.kind_of?(Skyline::ReferableUri)
+      end      
+    end
+  end
+end
+