westarete-skylinecms 3.0.8.20100329

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 @@
+module Skyline::Content
+  # @private
+  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
+    
+    # @private          
+    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,43 @@
+# @private
+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,40 @@
+module Skyline::Content
+  # @private  
+  module Versioning
+    # @private    
+    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_section_selectable.rb

@@ -0,0 +1,32 @@
+# Use this Module in all classes you want to be found in the ContentItemSection
+#
+#
+# Usage: 
+# class Model < ActiveRecord::Base
+#   include Skyline::ContentItemSectionSelectable
+# end
+#
+# 
+# 1) Registers your model in the Skyline::Sections::ContentItemSection.selectable_models list
+# 
+# 2) Gives your Model the following interface:
+# 
+#    class  Model < ActiveRecord::Base
+#      -- If the model has a 'published' column:
+#      named_scope :for_content_item_section, :conditions => {:published => true}
+#      -- else
+#      named_scope :for_content_item_section, {}
+#    end
+
+
+module Skyline::ContentItemSectionSelectable
+  def self.included(base)
+    Skyline::Sections::ContentItemSection.register_selectable_model(base)
+    
+    if base.column_names.include?("published")
+      base.send :named_scope, :for_content_item_section, :conditions => {:published => true}
+    else
+      base.send :named_scope, :for_content_item_section, {}
+    end
+  end
+end

data/lib/skyline/deprecated.rb

@@ -0,0 +1,106 @@
+module Skyline
+
+  # @deprecated  Don't use Skyline::ContentItem anymore, use Skyline::BelongsToReferable (will be removed in 3.1.0)
+  module ContentItem
+    
+    def self.included(base)
+      warn "[DEPRECATION] Don't use Skyline::ContentItem anymore, use Skyline::BelongsToReferable (will be removed in 3.1.0) [#{caller[1]}]"
+      
+      base.send(:include, Skyline::BelongsToReferable)
+      
+      base.class_eval do
+        named_scope(:published, {}) unless method_defined?(:published)
+        
+        named_scope(:with_site, {}) unless method_defined?(:with_site)
+      end
+      
+      class << base 
+        alias_method :referable_content, :belongs_to_referable
+      end
+    
+    end    
+  end
+  
+  # @deprecated Don't use Skyline::Referable anymore, use Skyline::HasManyReferablesIn (will be removed in 3.1.0)
+  module Referable
+    def self.included(base)
+      warn "[DEPRECATION] Don't use Skyline::Referable anymore, use Skyline::HasManyReferablesIn (will be removed in 3.1.0) [#{caller[1]}]"
+            
+      base.send(:include, Skyline::HasManyReferablesIn)
+      class << base 
+        alias_method :referable_field, :has_many_referables_in
+      end      
+    end
+  end
+  
+  # @deprecated Don't use Skyline::SectionItem anymore, use Skyline::Sections::Interface (will be removed in 3.1.0)
+  module SectionItem
+    def self.included(base)
+      warn "[DEPRECATION] Don't use Skyline::SectionItem anymore, use Skyline::Sections::Interface (will be removed in 3.1.0) [#{caller[1]}]"
+      
+      base.send(:include, Skyline::Sections::Interface)
+    end
+  end
+  
+  # @deprecated Don't use Skyline::FormBuilderWithErrors anymore, use Skyline::FormBuilder (will be removed in 3.1.0)
+  module FormBuilderWithErrors
+    def self.included(base)
+      warn "[DEPRECATION] Don't use Skyline::FormBuilderWithErrors anymore, use Skyline::FormBuilder (will be removed in 3.1.0) [#{caller[1]}]"
+      
+      base.send(:include, Skyline::FormBuilder)
+    end
+  end
+  
+  # @deprecated Don't use Skyline::Renderer anymore, use Skyline::Rendering::Renderer (will be removed in 3.1.0)
+  class Skyline::Renderer < Skyline::Rendering::Renderer
+    class << self
+      %w{renderables register_renderables renderable_types helper}.each do |m|
+        define_method(m) do |*args|
+          deprecate!
+          super
+        end
+      end
+      
+      def deprecate!
+        warn "[DEPRECATION] Don't use Skyline::Renderer anymore, use Skyline::Rendering::Renderer (will be removed in 3.1.0) [#{caller[1]}]"
+      end
+    end
+    
+    def initialize(*args)
+      self.class.deprecate!
+      super
+    end
+    
+  end
+
+  # @deprecated Don't use Skyline::UrlValidation anymore, use UrlValidation (will be removed in 3.1.0)
+  module UrlValidation
+    def self.extended(base)
+      warn "[DEPRECATION] Don't use Skyline::UrlValidation anymore, use UrlValidation (will be removed in 3.1.0) [#{caller[1]}]"
+      
+      base.send(:extend, ::UrlValidation)
+    end
+  end
+  
+  
+  module Rendering
+    module Helpers
+      module SettingsHelper
+        # @deprecated Will be removed 3.1 in favour of {Skyline::Settings::KlassMethods#get}
+        def setting(setting_identifier, field)
+          warn "[DEPRECATION] Don't use #setting anymore, use Settings#get (will be removed in 3.1.0) [#{caller[1]}]"
+          ::Settings.get(setting_identifier,field)
+        end
+
+        # @deprecated Will be removed 3.1 in favour of {Skyline::Settings::KlassMethods#get_page}  
+        def page_from_setting(setting_identifier, field)
+          warn "[DEPRECATION] Don't use #page_from_setting anymore, use Settings#get_page (will be removed in 3.1.0) [#{caller[1]}]"
+          ::Settings.get_page(setting_identifier,field)
+        end
+      end
+    end
+  end
+  
+  # Include it in the RendererHelper for now, RendererHelper will always exist.
+  Rendering::Helpers::RendererHelper.send(:include, Rendering::Helpers::SettingsHelper)
+end