skylinecms 3.0.7

data/lib/skyline/content/exportable.rb

@@ -0,0 +1,28 @@
+# @private
+module Skyline::Content
+  module Exportable
+    
+    # List of possible export formats for this class
+    def export_formats
+      read_inheritable_attribute(:export_formats) || []
+    end      
+    
+    # Set a list of possible export format for this class
+    # [DOC]
+    def exportable_as(*formats)
+      # discard any options for now
+      options = formats.pop if formats.last.kind_of? Hash
+
+      formats.each do |format|
+        class << self; self; end.send(:define_method, "export_#{format}"){}
+      end
+      if formats.any?
+        write_inheritable_attribute(:export_formats,formats)
+        class << self; self; end.send(:define_method,:exportable?) do
+          true
+        end
+      end
+    end
+    
+  end # Exportable
+end

data/lib/skyline/content/field_meta_data.rb

@@ -0,0 +1,336 @@
+module Skyline::Content
+  module FieldMetaData
+    # General purpose method to set all kind of field options.
+    # Works with hashes and blocks:
+    #   field :description, :editor => :wysiwyg
+    #
+    #   field :description,:location_information do |o|
+    #    o.editor = :wysiwyg
+    #   end    
+    #
+    # === Common options
+    # <tt>editor</tt>::  
+    #   Defines the type of editor this field should be editted with, see below
+    #   for a more detailed description and possible options per editor.
+    # <tt>label</tt>::   
+    #   The label to be used for this field when it's editted: for checkboxes this will be the text
+    #   that's displayed just after the checkbox, use <tt>title</tt> to change the text above the checkbox.
+    #   Parameters can be an array having 2 elements ["singular", "plural"] or just a string, in which 
+    #   case it's assumed to be just singular.
+    # <tt>description</tt>::
+    #   Set a description for this field, it's usually displayed just below the title.
+    # <tt>hidden</tt>::
+    #   One or more of the following: [:list, :create, :edit] or just true for all of the aforementioned
+    # <tt>title</tt>::
+    #   The title will be used in the list, and as a title for checkboxes. The title will mostly be the same
+    #   as the label, which it's defaults from. Title accepts same parameters as label
+    # <tt>prefix</tt>::
+    #   This is the text that will be placed before the actual inputfield, can also be a proc so you can do:
+    #     field :url, :prefix => Proc.new{|owner| owner.parent.url }
+    #   Needless to say, this works only in the edit/create forms, not in the list.
+    # <tt>suffix</tt>::
+    #   Same as prefix but after the input field.
+    # <tt>filter_html</tt>::
+    #   This affects filtering of HTML tags in the list views. Defaults to true, if set to false it will not filter
+    #   Any HTML tag. *warning* : This will probably change in a later version!
+    # <tt>filterable</tt>::
+    #   Make this model filterable on this field, this only works with true database fields or belongs_to association
+    #   fields. It will raise an ArgumentError if a database field cannot be found.
+    #
+    # 
+    # == Editors
+    # === Textarea
+    # Renders a standard textarea tag.
+    # 
+    # <tt>style</tt>::
+    #   Gives a style tag to the textarea element, use hashlike notation: {:height => 14} for "height: 14px"    
+    #
+    # === Date
+    # The standard editor for date_time types.
+    #
+    # <tt>year_options</tt>::
+    #   Options to pass to the rails year_select helper, for instance: {:start_year => 1990, :end_year => Time.now.year + 5}
+    #
+    # === Text_field
+    # Renders a standard input text field tag.
+    #
+    # <tt>style</tt>::
+    #   Gives a style tag to the textarea element, use hashlike notation: {:height => 14} for "height: 14px"    
+    #
+    # === Wysiwyg
+    # Creates a wysywig editor for editting bigger texts
+    #
+    # <tt>style</tt>::
+    #   Gives a style tag to the textarea element, use hashlike notation: {:height => 14} for "height: 14px"    
+    # <tt>tinymce_options</tt>::
+    #   A hash with tinymce specific options. See tinyMCE documentation for more information. The hash will be converted
+    #   to a javscript hash, so {:theme => "simple", :plugins => ["a","b"]} will become "{theme:'simple', plugins:'a,b'}". Warning:
+    #   do not override mode and elements keys, they will not be included in the tinymce settings.
+    # <tt>image_classes</tt>::
+    #   Shortcut for tinymce_options[:skylineimage_classes], a Hash describing classes images can have, key is the classname, value is the description.
+    # <tt>link_classes</tt>::
+    #   Shortcut for tinymce_options[:advlink_styles], a Hash describing classes links can have, key is the classname, value is the description.
+    # <tt>blockformats</tt>::
+    #   Shortcut for tinymce_options[:theme_advanced_blockformats], a Hash description block elements, key is the element, value is description, can also
+    #   be an array of block elements.
+    # <tt>template</tt>::
+    #   A full set of tinymce options, including buttons etc. Currently only :standard (the default) and :email (a stripped
+    #   down version with only B/I/U/Link buttons in the toolbar) are available
+    # 
+    # === Textile
+    # Same as wywisywg but yields a regular textarea with a preview of the markup next to it.
+    #
+    # <tt>style</tt>:: 
+    #   Gives a style tag to the textarea element, use hashlike notation: {:height => 14} for "height: 14px"
+    # <tt>cache</tt>::
+    #   Cache defaults to true and uses <tt>field_name</tt>_html. It also sets :hidden => true for these 
+    #   cache fields. Warning: this does not do the actual textile transformation, you still need to do that yoruself.
+    # 
+    # === Display
+    # Doesn't display an actual editor, just the value
+    #
+    # <tt>blank</tt>:: The value that should be displayed when the field would have a nil value.
+    # 
+    # === Heading
+    # Displays the field as a bigger and bold textbox.    
+    #
+    # <tt>style</tt>::
+    #   Gives a style tag to the textarea element, use hashlike notation: {:height => 14} for "height: 14px"    
+    # 
+    # === List
+    # Makes the choice a dropdown box, needs the option :list to be set.
+    #
+    # <tt>list</tt>::
+    #   Accepts a proc which returns a list or just a regulur array. See the examples below for more info.
+    # 
+    # Example:
+    #  field :events, :editor => :list, :list => [["Letter A","a"],["Second Letter","b"]]
+    #  field :events, :editor => :list, :list => Proc.new{|owner| owner.events.collect{|e| [e.name,e.id]}}
+    #
+    # The above is short for:
+    #   field :events do |o|
+    #     o.editor = :list
+    #     o.list = Proc.new{|owner| owner.events.collect{|e| [e.name,e.id]} }
+    #   end
+    # 
+    # === Inline List
+    # Only works with has_many associations. Will show the list below the save button on the edit screen.
+    # Using a collection as an inline field will also remove it from the display in the list view of the 
+    # parent class.
+    # 
+    # <tt>presenter</tt>::
+    #   The presenter to use for the display list. (See also: Skyline::Content::ClassMetaData)
+    # 
+    # === Editable List
+    # Only works with has_many associations. It's best suited for editing of small items like
+    # agenda items. The list will appear inline and will save ONLY when the main object is saved. For
+    # every added item a new sub-form will be created. Items can be deleted but won't actually be removed
+    # before the main object is saved.
+    #    
+    # === Joinable List
+    # Makes inline joins possible for <tt>has_and_belongs_to_many</tt> relations and also for <tt>has_many :through => ""</tt>
+    # relations. Joinabe list is also the default editor for has_and_belongs_to_many if no editor is specified.
+    #
+    # <tt>default_filter</tt>::
+    #   Proc (in the format Proc.new{|owner| {:filter_field => owner.foreign_key}}) or a hash in the format
+    #   {:filter_field => "value"}. This filter will be applied on the list.
+    # 
+    # === Checkable List
+    # The checkable list works with has_and_belongs_to_many relations. It renders
+    # a list of the related objects with checkboxes in front of them. All checked objects
+    # will be related.
+    #
+    # === File browser
+    # The file_browser editor allows you to select files from the media_library. They will
+    # be added through a RefObject.
+    # 
+    # === Page browser
+    # The page_browser editor allows you to select pages from the Pages in Skyline. They will
+    # be added through a RefObject.
+    # 
+    #--
+    def field(*fields,&block)
+      options = options_from_params_with_default fields      
+      fields = fields.first if fields.any? && fields.first.kind_of?(Array)
+      options.reverse_merge! field_create_defaults(options)
+  
+      fields.each do |field_name|
+        options.update(:name => field_name, :owner => self)
+        if self.fields.has_key?(field_name)
+          write_inheritable_hash(:fields,{field_name => MetaData::Field.from(self.fields[field_name],options)})
+        else
+          write_inheritable_hash(:fields,{field_name => MetaData::Field.new(options)})
+        end
+        self.ungrouped_fields << field_name 
+        yield self.fields[field_name] if block_given?
+        after_field_create!(self.fields[field_name])
+      end
+      fields.map{|f| self.fields[f]}
+    end
+    
+    # @deprecated
+    alias :field_options_for :field #:nodoc:
+    
+    # Group fields together into a fieldgroup.  
+    #   field_group :naw, :title => "Naam, adres en woonplaats" do |g|
+    #     g.field :name, :editor => :heading
+    #     g.field :address
+    #     g.field :city, :label => "Woonplaats"
+    #   end
+    #--
+    def field_group(name,options={})
+      options.reverse_merge! :fields => [], :title => name.to_s.humanize, :type => nil
+  
+      field_group = MetaData::FieldGroup.new(options.update(:owner => self, :name => name))
+      yield field_group if block_given?
+      
+      write_inheritable_attribute(:ungrouped_fields,self.ungrouped_fields.dup << name)
+      write_inheritable_hash(:fields,{name => field_group}) 
+      
+      field_group
+    end
+    
+    # Order the fields (also works with field groups)
+    #   field_order :name,:naw,:body
+    def field_order(*order)
+      if order.empty?
+        read_inheritable_attribute(:field_order) || write_inheritable_attribute(:field_order,order)
+      else
+        write_inheritable_attribute(:field_order,order)
+      end
+    end
+    
+    # All directly writable fields. This includes all defined fields except fields:
+    # * with editor "display" because these aren't editable anyway
+    # * which are associations, as they would not appear in the form
+    # * which are hidden in the edit screen (although, they can still be hidden in the create screen)
+    # 
+    # ==== Returns
+    # <tt>Array[Symbol]</tt>:: Field names of fields which are writable.
+    #--
+    def writable_fields #:nodoc:
+      self.fields.select do |k,v| 
+        if v.kind_of?(MetaData::Field) && v.editor == :file && !v.hidden_in(:edit)
+          true
+        else
+          !v.kind_of?(MetaData::FieldGroup) &&
+          ![:display].include?(v.editor) && 
+          !v.hidden_in(:edit) && 
+          !v.association?
+        end
+      end.map{|k,v| k}
+    end
+    
+    # All fields that can be used for filtering
+    # 
+    # ==== Returns
+    # <tt>Array[Symbol]</tt>:: An array of fieldnames which can be used in filtering.
+    #--
+    def filterable_fields #:nodoc:
+      self.fields.select{|k,v| v.kind_of?(MetaData::Field) && v.filterable }.map{|k,v| k}
+    end
+    
+    def fields #:nodoc:
+      read_inheritable_attribute(:fields) || write_inheritable_hash(:fields,{})
+    end
+            
+    def ungrouped_fields #:nodoc:
+      read_inheritable_attribute(:ungrouped_fields) || write_inheritable_attribute(:ungrouped_fields,[])
+    end
+    
+    # @deprecated
+    def association_fields #:nodoc:
+      if self.respond_to?(:reflect_on_all_associations)
+    		@assoc_names ||= self.reflect_on_all_associations().collect{|assoc| assoc.name} 
+    	else
+    	  []
+    	end
+    end
+    
+    # @deprecated
+    def hidden_columns #:nodoc:
+      [:published, :position]
+    end
+    
+    # @deprecated
+    def non_hidden_columns #:nodoc:
+      return [] if !self.table_exists?
+      self.content_columns.map{|col| col.name.to_sym} - self.hidden_columns
+    end
+    
+        
+    # Yields all fields in order (also the columns not specified in field_order)    
+    def each_field(&block) #:nodoc:  
+      self.field_names.each do |field_name|
+        yield_field(field_name, &block)
+      end      
+    end    
+    
+    def only_each_field_of(selection,&block) #:nodoc:
+      selection.each do |field_name|
+        if self.field_names.include?(field_name)          
+          yield_field(field_name,&block)
+        else
+          yield nil
+        end
+      end
+    end
+    
+    # Array of all fields in order (also the columns not specified in @@field_order)
+    def field_names #:nodoc:
+      get_field_names.uniq      
+    end
+    
+    private   
+    
+    # Defaults for different field types.
+    #--
+    def field_create_defaults(options)
+      case options[:editor]
+        when :textile : {:cache => true} 
+        when :inline_list : {:hidden => [:list,:create]}
+        else {}
+      end
+    end
+    
+    # Callback after a field is created, add special options that needs to be invoked based
+    # on the field meta data here.
+    #-- 
+    def after_field_create!(field)
+      case field.editor
+        when :textile
+          self.field("#{field.attribute_name}_html".to_sym, :hidden => true) if field.cache
+        when :inline_list 
+          self.settings.return_to_self_after_save = true
+        when :joinable_list, :editable_list, :checkable_list
+          alias_method "original_#{field.attribute_name}=", "#{field.attribute_name}="
+          define_method("#{field.attribute_name}=") do |values|
+            process_related_objects(field,values)
+          end
+      end      
+    end
+        
+    def options_from_params_with_default(params,default = {})
+      options = params.pop if params.last.kind_of? Hash
+      options ||= {}
+      options.reverse_merge! default
+      options
+    end
+   
+    def get_field_names
+      @field_name ||= self.field_order | self.ungrouped_fields.dup
+      @field_name
+    end 
+    
+    # Checks if the field exists, if it does it yields it otherwise it creates a new one.  
+    def yield_field(name,&block)
+      if self.fields.has_key? name
+        field = self.fields[name]
+      else
+        field = MetaData::Field.new(:name => name,:owner => self)
+      end
+      
+      yield field
+    end
+  end
+end

data/lib/skyline/content/implementation.rb

@@ -0,0 +1,57 @@
+# @private
+class Skyline::Content::Implementation
+  extend ActiveSupport::Memoizable
+  include Singleton
+  
+  # All the content_classes. This works fine when using in Rails
+  # as the implementation instance get's reloaded on each request. Make sure to reset
+  # the cache if the classes change.
+  def content_classes
+    return @_contentclasses if @_contentclasses
+
+    do_not_include = []
+    @_contentclasses = Skyline::Configuration.content_classes.collect do |klass|
+      klass = klass.kind_of?(Class) ? klass : klass.to_s.constantize
+      if klass.respond_to?(:content?) && klass.content? && !klass.abstract_class
+        klass.reflect_on_all_associations(:has_many).each do |assoc|
+          # Do not include associated classes unless it's self-referential
+          if assoc.klass && assoc.klass != klass && !assoc.through_reflection
+            do_not_include << assoc.klass 
+          end
+        end
+        klass              
+      end
+    end.compact
+    @_contentclasses -= do_not_include
+    
+    Rails.logger.debug("Content constants: #{@_contentclasses.map{|c| c.to_s}.inspect}")    
+    @_contentclasses
+  end
+    
+  # Does this implementations have a Settings class?
+  def has_settings?
+    "Settings".constantize
+    true
+  rescue NameError
+    false
+  end
+  memoize :has_settings?
+  
+  # The settings class for this implementation
+  def settings
+    "Settings".constantize if self.has_settings?
+  end
+  
+  # Retrieve a content_class from the Implementation namespace by type
+  # type can be a plural or a singular.
+  def content_class(type)
+    type_class_name = type.to_s.singularize.camelcase
+    return if type_class_name.blank?
+    content_class = type_class_name.constantize
+    content_class if content_class.content? && !content_class.abstract_class
+  rescue StandardError => e
+    Rails.logger.warn("Failure while trying to get #{type_class_name} : #{e} #{e.backtrace.join("\n\t")}")
+    nil
+  end
+  
+end    

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

@@ -0,0 +1,18 @@
+module Skyline::Content
+  module MetaData
+    class ClassSettings < Field #:nodoc:
+  
+      def singular_label
+        singular(self.label,self.klass.to_s.demodulize.underscore.humanize)
+      end
+      def plural_label
+        plural(self.label,self.klass.to_s.demodulize.underscore.humanize.pluralize)    
+      end
+  
+  
+      # Klass these ClassSettings belong to
+      def klass; self.owner; end  
+  
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+module Skyline::Content
+  module MetaData
+    require 'ostruct'
+  
+    class Field < OpenStruct #:nodoc:
+  
+      class << self
+        def from(field,options)
+          table = field.instance_variable_get(:@table)
+          options.delete(:name)
+          new(table.dup.update(options))
+        end
+      end
+      
+      def initialize(*params)
+        super(*params)
+        
+        # Set implicit association data.
+        if self.owner_class && reflection = self.owner_class.reflect_on_association(self.name)
+          self.reflection = reflection
+          self.hidden = [:edit,:create] unless self.editor || !self.hidden.nil?
+        end
+        
+        # Check if this was a filterable field and check if:
+        # * this field is a column
+        # * this field is a belongs_to association
+        if self.respond_to?(:filterable) && self.filterable && (!self.owner_class.column_names.include?(self.name.to_s) && (!self.association? || self.reflection.macro != :belongs_to))
+          raise ArgumentError, "Cannot use filter on non-database field."
+        end
+        
+        # Set default editors if it's not set but type is available
+        if !self.respond_to?(:editor) || self.editor.blank?
+          self.editor = {
+            :string => :text_field,
+            :boolean => :boolean,
+            :datetime => :date_time,
+            :timestamp  => :date_time,
+            :date => :date,
+            :text => :textarea
+          }[self.type]
+        end
+      end
+      
+      def singular_title
+        singular(self.title,self.singular_label)
+      end
+      def plural_title
+        plural(self.title,self.plural_label)
+      end
+      def singular_label(alt=self.name)
+        singular(self.label,alt)
+      end
+      def plural_label(alt=self.name)
+        plural(self.label,alt)    
+      end
+  
+      def singular(value,alternative=nil)
+        return alternative.to_s.humanize if value.nil?    
+        value.kind_of?(Array) && value.first || value.to_s
+      end
+  
+      def plural(value,alternative=nil)
+        return alternative.to_s.humanize.pluralize if value.nil?    
+        value.kind_of?(Array) && value.last || value.to_s.pluralize
+      end
+      
+      # Is this field an association
+      #
+      # ==== Returns
+      # Boolean:: Wether or not this is an association
+      #--
+      def association?
+        self.respond_to?(:reflection) && !self.reflection.nil?
+      end
+      
+      # The ActiveRecord::Column object this field is related to.
+      # If empty this can be a virtual field or a field defined through a method.
+      # 
+      # ==== Returns
+      # ActiveRecord::Column,nil:: The column object if any.
+      #--
+      def column
+        self.owner && self.owner.respond_to?(:columns_hash) && self.owner.columns_hash[self.name.to_s]
+      end
+      
+      # Gets all unique values for this field on the owner_class.
+      # Returns arrays usable in select/options_for_select helpers.
+      # 
+      # ==== Returns
+      # Array[String,Array[Integer,String]]:: Array of values. If this is an association we get an array of [id,title]
+      #--
+      def unique_values
+        if self.association?
+          self.reflection.klass.find(:all).map{|a| [a.human_id,a.id] }
+        else
+          self.owner_class.connection.select_values("SELECT DISTINCT(#{self.name}) FROM #{self.owner_class.table_name}")
+        end
+      end        
+      
+      # The method/column name this field writes to. This takes foreign_keys of belongs_to associations in account.
+      def attribute_name
+        self.association? && self.reflection.macro == :belongs_to && self.reflection.primary_key_name || self.name
+      end
+      
+      # The type of the associated column, or if it's serialized
+      # the type that this serialized field was defined as.
+      #
+      # ==== Returns
+      # Symbol:: 
+      #   The type name can by any of:
+      #    *  :string   
+      #    *  :text     
+      #    *  :integer  
+      #    *  :float    
+      #    *  :decimal  
+      #    *  :datetime 
+      #    *  :timestamp
+      #    *  :time     
+      #    *  :date     
+      #    *  :binary   
+      #    *  :boolean
+      #--
+      def type
+        type = method_missing(:type)
+        if type.kind_of?(Class) || type.blank?
+          self.column && self.column.type
+        else
+          type
+        end
+      end
+      
+      def owner
+        method_missing(:owner)
+      end
+      
+      def owner_class
+        if self.owner && self.owner.kind_of?(Class) && self.owner.ancestors.include?(ActiveRecord::Base)
+          self.owner
+        elsif self.owner
+          # This is a group so we get the group's owner
+          self.owner.owner
+        end
+      end
+      
+      def value(record)
+        raise(ArgumentError, "The record class (#{record.class}) and the field class (#{self.owner_class}) do not match") if !record.kind_of?(self.owner_class)
+        raise(ArgumentError, "The record does not respond do this field name (#{self.name})") unless record.respond_to?(self.name)
+        record.send(self.name)
+      end
+  
+      def attribute_value(record)
+        raise(ArgumentError, "The record class (#{record.class}) and the field class (#{self.owner_class}) do not match") if !record.kind_of?(self.owner_class)
+        raise(ArgumentError, "The record does not respond do this field name (#{self.name})") unless record.respond_to?(self.name)
+        record.send(self.attribute_name)      
+      end
+  
+      def hidden_in(scope)
+        self.respond_to?(:hidden) && (self.hidden == true || self.hidden.include?(scope))      
+      end
+  
+      def update(options={})
+        options.each{|value, key| self.send("#{key}=",value)}
+      end
+  
+      # Functions below only needed on fields with serialized attributes
+      def klass
+        case self.type
+          when :integer       then Fixnum
+          when :float         then Float
+          when :decimal       then BigDecimal
+          when :datetime      then Time
+          when :date          then Date
+          when :timestamp     then Time
+          when :time          then Time
+          when :text, :string then String
+          when :binary        then String
+          when :boolean       then Object
+          else nil
+        end
+      end  
+  
+      # Casts value (which is a String) to an appropriate instance. Only needed
+      # on fields that are in serialized data.
+      def type_cast(value)
+        return nil if value.nil?
+        case self.type
+          when :string    then value
+          when :text      then value
+          when :integer   then value.to_i rescue value ? 1 : 0
+          when :float     then value.to_f
+          when :decimal   then ActiveRecord::ConnectionAdapters::Column.value_to_decimal(value)
+          when :datetime  then ActiveRecord::ConnectionAdapters::Column.string_to_time(value)
+          when :timestamp then ActiveRecord::ConnectionAdapters::Column.string_to_time(value)
+          when :time      then ActiveRecord::ConnectionAdapters::Column.string_to_dummy_time(value)
+          when :date      then ActiveRecord::ConnectionAdapters::Column.string_to_date(value)
+          when :binary    then ActiveRecord::ConnectionAdapters::Column.binary_to_string(value)
+          when :boolean   then ActiveRecord::ConnectionAdapters::Column.value_to_boolean(value)
+          else value
+        end
+      end
+      
+      def inspect
+        "<Field @table=#{@table.inspect}>"
+      end
+      
+      def to_param
+        self.name
+      end
+          
+    end
+  end
+end