westarete-skylinecms 3.0.8.20100329

data/lib/skyline/rendering/renderer.rb

@@ -0,0 +1,391 @@
+# The skyline renderer renders all Articles, Sections and basically anything that's renderable
+# or previewable in Skyline.
+class Skyline::Rendering::Renderer
+  attr_reader :assigns, :template_paths
+  attr_accessor :_config
+  
+  cattr_accessor :renderables
+  @@renderables ||= {}
+  
+  @@renderables[:sections] = Skyline::Configuration.sections
+  @@renderables[:articles] = %w{Skyline::Page} + Skyline::Configuration.articles
+  
+  class << self
+    # The list of renderable classes by type
+    #
+    # @param type [Symbol] The type to get the renderable classes for
+    # @param sub [Symbol,Class] The sub class ie. :news_item or Skyline::Page when @@renderables[type] is an Hash]
+    # 
+    # @return [Array<Class>] Array of renderable classes
+    def renderables(type, sub = :all)
+      @@renderables ||= {}
+      
+      if @@renderables[type].kind_of?(Hash)
+        @@renderables[type] ||= {}
+        if sub == :all
+          @@renderables[type][:all] = renderables_to_class(type, @@renderables[type].values.flatten.uniq)
+        else
+          sub = sub.name.downcase.underscore.to_sym if sub.kind_of?(Class)
+          classes = @@renderables[type][sub] || @@renderables[type][:default]
+          @@renderables[type][sub] = renderables_to_class(type, classes)
+        end
+      else
+        @@renderables[type] = renderables_to_class(type, @@renderables[type])
+      end
+    end
+
+    # Add your own renderables
+    #
+    # @param type [Symbol] The type (for instance `:sections` or `:articles`) to register your renderables under
+    # @param renderables [Array<String,Symbol,Class>] Your own renderables
+    def register_renderables(type, renderables)
+      @@renderables[type] = renderables
+    end
+    
+    # All availables renderable types
+    #
+    # @return [Array<Symbol>] All available types
+    def renderable_types
+      @@renderables.keys
+    end
+
+    # Add a helper to the standard renderer
+    #
+    # @param module_name [~to_s,Module>] Module/module name to include in the helper for renderer.
+    def helper(module_name)
+      Helpers.helper(module_name)
+    end   
+
+    
+    protected
+    
+    # Convert a renderable specified by string to a class
+    def renderables_to_class(type, renderables, additional_map = {})
+      map = {:sections => "Skyline::Sections"}.merge(additional_map)
+      renderables.map{|f| f.kind_of?(String) ? "#{[map[type], f.camelize].compact.join("::")}".constantize : f}
+    end
+    
+  end
+  
+  # Creates a new renderer instance.
+  #
+  # @param options [Hash] Options
+  #
+  # @option options :assigns [Hash] ({}) Assigns to pass to the template, all assigns are accessible
+  #   by their instance variable. `:test` becomes @test in the template.
+  # @option options :controller [Controller] (nil) The controller that is serving the current request.
+  # @option options :paths [Array<String,Pathname>]  (["app/templates", Skyline.root + "app/templates/skyline"])
+  #   Paths that will be searched for templates.
+  # @option options :site [Site] The currently active site object
+  def initialize(options = {})
+    options.reverse_merge!(:assigns => {}, 
+                           :controller => nil, 
+                           :paths => ["app/templates", Skyline.root + "app/templates/skyline"],
+                           :site => nil)
+
+    @assigns = options[:assigns].update(:_controller => options[:controller], 
+                                        :_site => options[:site])
+
+    @template_paths = options[:paths].collect{|p| (Rails.root + p).to_s if File.exist?(Rails.root + p)}.compact
+    @template_assigns = {}
+  end
+  
+  # Render one renderable object
+  # 
+  # @param object [renderable] A renderable object
+  # @param options [Hash] Options
+  #
+  # @option options :locals [Hash] ({}) Locals to make available to the template
+  # @option options :assigns [Hash] ({}) Assigns merged with the global assigns of this renderer
+  # 
+  # @return [String] The rendered template
+  def render(object, options = {})
+    options.reverse_merge!(:locals => {}, :assigns => {})
+    
+    object_config = self.object_config(object)
+
+    if object_config[:proxy]
+      object_config[:proxy].call(self, object, options)
+    else
+      template = self.object_template(object)
+      load_paths = self.object_template_paths(object)
+
+      Rails.logger.debug "Rendering index template from paths: #{load_paths.join(', ')} (object.template = #{template})"
+
+      av = ActionView::Base.new(load_paths.map(&:to_s))
+
+      self.assigns.merge(options[:assigns]).each do |k, v|
+        av.assigns[k.to_sym] = v
+      end
+
+      av.assigns[:_template_assigns] = @template_assigns
+      av.assigns[:_renderer] = self
+      av.assigns[:_local_object_name] = object_config[:class_name].demodulize.underscore.to_sym
+      av.assigns[:_local_object] = object
+      @_local_object = object   # for object function
+      
+      av.extend Skyline::Rendering::Helpers::RendererHelper
+      av.extend Helpers
+      
+      av.render(:file => "index", :locals => options[:locals])
+    end
+  end
+  
+  # Render a collection of objects (array), this gives
+  # support for peek() and skip!() in the templates. A template
+  # can decide too look n items forward and skip n items because the template
+  # itself rendered the next n items.
+  #
+  # By default each object is rendered with the default rendering options. If
+  # you pass a block, this block is called for every item in the collection. The
+  # return value of the block will be added to the output. No automatic rendering will be done.
+  #
+  # All assigns and template_assigns will be available to all (cloned) renderers. (This is
+  # because clone only makes a shallow clone, attributes (like assigns) which are Hashes aren't copied:
+  # a clone uses the same memory address of the attribute.)
+  #
+  # @param objects [Array<renderable>] An array of renderable objects.
+  # @param options [Hash] Options will be passed to each consequent {Renderer#render} call.
+  # 
+  # @return [String] The rendererd templates
+  def render_collection(objects, options = {}, &block)
+    self.clone.send(:_render_collection, objects, options, &block)
+  end
+  
+  # The current object that's being rendered
+  #
+  # @return [renderable] The renderable object.
+  def object
+    @_local_object
+  end
+  
+  # Peek looks forward N position in the current renderable collection. Peek does not
+  # modify the renderable collection.
+  # 
+  # Can only be used within a render_collection call. 
+  # 
+  # @param n [Integer] Number of items to look ahead
+  # 
+  # @return [Array<renderable>] N renderable items (or less if the collection end has been reached)
+  def peek(n = 1)
+    return [] if @_current_collection.blank?
+    @_current_collection[@_current_collection_index + @_collection_skip + 1, n]
+  end
+  
+  # Peek until the conditions in the passed block return true. Peek_until does not
+  # modify the renderable collection.
+  # 
+  # Can only be used within a render_collection call. 
+  # 
+  # @yield [i] A block that must evaluate to true/false
+  # @yieldparam i [renderable] The current renderable item
+  # @yieldreturn [true,false] If true the collection from the entry point up until the
+  #   moment the block returns true is returned as an array. If false the loop continues until
+  #   the end of the collection is reached or the conditions in the block are met.
+  # 
+  # @return [Array<renderable>] Renderable items.
+  def peek_until(&block)
+    return [] if @_current_collection.blank?
+    peeking = []
+    items = @_current_collection[@_current_collection_index + @_collection_skip + 1 .. -1]
+    return [] unless items
+    items.each do |i|
+      return peeking if yield i
+      peeking << i
+    end
+    peeking
+  end
+  
+  # Render_until does the same as peek_until but it also renders the objects
+  # and advances the collection pointer until the conditions in the block are met.
+  # 
+  # @see peek_until
+  def render_until(&block)
+    peek_until(&block).collect{|i| self.skip!; self.render(i)}.join
+  end
+  
+  # Advances the collection pointer by one
+  # 
+  # Can only be used within a render_collection call.
+  # 
+  # @param n [Integer] Number of items to skip
+  def skip!(n = 1)
+    return 0 if @_current_collection.blank?    
+    @_collection_skip += n
+  end
+  
+  # Skip_until! works like peek_until except it skips until the conditions
+  # in the passed block are met.
+  # 
+  # @see peek_until
+  def skip_until!(&block)
+    return [] if @_current_collection.blank?
+    items = @_current_collection[@_current_collection_index + @_collection_skip + 1 .. -1]
+    return [] unless items
+    item.each do |i|
+      return if yield i
+      skip!    
+    end
+  end
+  
+  # Returns a list of templates for a certain object or class. Raises an exception
+  # if the class can't be found in the config.
+  #
+  # @param klass_or_obj [Class,Object] The instance / class to get the templates for.
+  #
+  # @return [Array] An array with template names
+  def templates_for(klass_or_obj)
+    klass = klass_or_obj.kind_of?(Class) ? klass_or_obj : klass_or_obj.class
+    self.config[klass.name].andand[:templates] || []
+  end
+  
+  # The current rendering configuration
+  # 
+  # @param options [Hash] Options
+  #
+  # @option options :additional_config [Hash] ({}) An additional config to use just for 
+  #   this instance of the renderer. Setting :additional_config updates the config!
+  # 
+  # @return [Hash] the current config
+  # 
+  # @todo Check the exact syntax of options and what happens with the parameters of the :proxy.
+  #   blocks.
+  def config(options = {})
+    return self._config if self._config && Rails.env == "production"
+    options.reverse_merge!(:additional_config => {})
+    
+    delegate_proc = Proc.new do |object| 
+      {
+        :class_name => "Skyline::ArticleVersion", 
+        :path => object.article.class.name.sub(/^Skyline::/, '').underscore,
+        :templates => self._config[object.article.class.name].andand[:templates] || []
+      }
+    end
+    
+    config = {"Skyline::Variant"      => delegate_proc,
+              "Skyline::Publication"  => delegate_proc,
+              "Skyline::Section"      => {:proxy => Proc.new{|renderer, section, options| renderer.render(section.sectionable, options)}},
+             }.merge(options[:additional_config])
+    
+    self.class.renderable_types.each do |type|
+      self.class.renderables(type).each do |renderable|
+        name = renderable.name
+        config[name] = {:class_name => name }
+      end
+    end
+
+    config.each do |object, object_config|
+      if object_config.kind_of?(Hash) && !object_config[:proxy]
+        object_config[:path] ||= object_config[:class_name].sub(/^Skyline::/, '').underscore
+        object_config[:templates] = templates_in_path(object_config[:path])
+        object_config[:templates].sort!
+      end
+    end
+    
+    self._config = config
+  end
+  
+  def object_template_paths(object)
+    object_config = self.object_config(object)
+    template = self.object_template(object)
+    
+    template_path = object_config[:path]
+    path = "#{template_path}/#{template}"
+    default_path = "#{template_path}/default"
+
+    load_paths = []
+    load_paths += @template_paths.collect{|p| File.join(p, path)}
+    load_paths += @template_paths.collect{|p| File.join(p, template_path)}
+    load_paths += @template_paths.collect{|p| File.join(p, default_path)} unless template == "default"
+    load_paths
+  end
+
+  def file_path(object, filename)
+    paths = object_template_paths(object)
+    paths.each do |path|
+      return File.join(path, filename) if File.exists?(File.join(path, filename))
+    end
+    nil
+  end
+  
+  protected
+  
+  def object_config(object)
+    object_config = self.config[object.class.name]
+    raise ArgumentError, "Don't know how to render an object of class '#{object.class}'" unless object_config
+    object_config.respond_to?(:call) ? object_config.call(object) : object_config
+  end
+  
+  def object_template(object, template = nil)
+    object_config = self.object_config(object)
+    
+    template ||= object.template if object.respond_to?(:template)
+    template ||= object.section.template if object.respond_to?(:section)
+    template ||= "default"
+    unless object_config[:templates].include?(template)
+      Rails.logger.debug "Can find template '#{template}' for class '#{object.class}' so falling back to the default template. Available templates: #{object_config[:templates].inspect}"
+      template = "default" 
+    end
+    template
+  end
+
+  def templates_in_path(path)
+    template_paths = []
+    @template_paths.each do |root|
+      Dir.chdir(root) do
+        template_paths = template_paths | Dir.glob("#{path}/*").select{|d| File.directory?(d)  }.map{|d| File.basename(d)}
+      end
+    end
+    template_paths
+  end  
+  
+  # Do not use this method directly. Instead use the render_collection method.
+  # This is because nested calls to render_collection will fail due to shared
+  #   variables (like @_current_collection).
+  def _render_collection(objects, options = {}, &block)
+    @_collection_skip = 0
+    @_current_collection = objects
+    output = []
+    Array(objects).each_with_index do |object, i|
+      
+      if @_collection_skip > 0
+        @_collection_skip -= 1
+        next
+      end
+      
+      @_current_collection_index = i
+      if block_given?
+        output << yield(object)
+      else
+        output << self.render(object, options)
+      end
+    end    
+    @_current_colection = nil
+    
+    output.join("\n")
+  end  
+  
+    
+  # The default Helpers module
+  module Helpers
+    include Skyline::Rendering::Helpers::ColumnHelper
+    include Skyline::Rendering::Helpers::BreadCrumbHelper
+    
+    def helper(module_name)
+      return self.send(:include,module_name) if module_name == Module
+      
+      module_name = module_name.to_s
+      module_name << "_helper" if module_name !~ /_helper$/
+      module_name = module_name.camelize
+      module_name = "::#{module_name}" if module_name !~ /^::/
+      self.send(:include, module_name.constantize)      
+    end
+    module_function :helper
+
+    # Load all helpers
+    Dir[Rails.root + "app/helpers/**/*_helper.rb"].each do |helper|
+      self.helper helper.sub(Rails.root + "app/helpers/","").sub(/_helper\.rb$/,"")
+    end  
+    
+  end
+end

data/lib/skyline/rendering/scopes/interface.rb

@@ -0,0 +1,29 @@
+# @abstract Implement this interface in classes that can be used
+#   as renderable scopes.
+module Skyline::Rendering::Scopes::Interface
+  
+  # @abstract
+  def renderer(options = {})
+    raise "renderer(options = {}) must be overridden"
+  end
+
+  # @abstract  
+  def serialize
+    raise "serialize() must be overridden"
+  end
+  
+  # @abstract  
+  def self.load_from_serialized_string(serialized_string)
+    raise "self.load_from_serialized_string() must be overridden"
+  end    
+  
+  def self.unserialize(serialized_string)
+    class_name, params = serialized_string.split("-")
+    class_name.constantize.load_from_serialized_string(params.to_s)
+  end
+  
+  def templates_for(klass_or_obj)
+    self.renderer.templates_for(klass_or_obj)
+  end
+  
+end

data/lib/skyline/rendering/scopes/wildcard.rb

@@ -0,0 +1,16 @@
+# @private
+class Skyline::Rendering::Scopes::Wildcard
+  include Skyline::Rendering::Scopes::Interface
+
+  def renderer(options = {})
+    Skyline::Rendering::Renderer.new(options)
+  end
+    
+  def serialize
+    "#{self.class.name}-n/a"
+  end
+  
+  def self.load_from_serialized_string(serialized_string)
+    self.new
+  end    
+end

data/lib/skyline/sections/interface.rb

@@ -0,0 +1,42 @@
+# Defines the section interface. Include this module in all your sections.
+#
+# If you're creating your Section within the Skyline module (you probably shouldn't), it
+# will automatically sets your models table name to `skyline_sections_#{base.table_name}`
+#
+# @example Usage: 
+# 
+# class Model < ActiveRecord::Base
+#   include Skyline::Sections::Interface
+# end
+#
+# @example Defines the following interface:
+# 
+# class Model < ActiveRecord::Base
+#   has_one :section, :as => :sectionable, :class_name => "Skyline::Section" # The link back to the section
+#   self.default_interface = true # defaults to true
+#   
+#   def to_text
+#     ...
+#   end
+# end
+# 
+module Skyline::Sections::Interface
+ 
+  def self.included(base)
+    base.class_eval do
+      set_table_name "skyline_sections_#{base.table_name}" if base.parents.include?(Skyline)
+      has_one :section, :as => :sectionable, :class_name => "Skyline::Section"
+    end
+    base.send(:cattr_accessor, :default_interface)
+    base.send(:default_interface=, true)
+  end
+
+  # The to_text method is needed for searching and other string operations which
+  # just want the content of this section without any markup.
+  # 
+  # @return [String] The section's content flattened to only text
+  # @abstract Implement in your own section
+  def to_text
+    ""
+  end
+end

data/lib/skyline/settings.rb

@@ -0,0 +1,185 @@
+module Skyline::Settings
+  
+  def self.included(obj)
+    obj.extend(ClassMethods)
+    obj.send(:serialize, :data)
+  end  
+  
+  module ClassMethods
+    
+    # Define a page in the object, see example below
+    #
+    #  class DummyImplementation::Settings < DummyImplementation::ImplementationSettings
+    #    page :general do |p|
+    #      p.description "Here you can edit all your general settings"
+    #      p.field :address, :type => :text
+    #      p.field :newsletter, :type => :text    
+    #      p.field :mission_statement, :type => :text
+    #    end
+    #    page :test do |p|
+    #      p.description "A test of all possible options"
+    #      p.field_group :name do |g|
+    #        g.field :firstname, :type => :string
+    #        g.field :lastname, :type => :string
+    #      end
+    #      p.field :birthdate, :type => :date
+    #      p.field :today, :type => :datetime
+    #      p.field :nr_of_kids, :type => :integer
+    #      p.field :price_of_favourite_food, :type => :float
+    #      p.field :loves_meat, :type => :boolean
+    #    end    
+    #  end
+    def page(name,options={},&block)
+      page = Skyline::Content::MetaData::FieldPage.new(self,name,options)
+      yield(page)
+      create_proxy_method(name)
+      pages.update(name => page)
+      page_order << page.name
+      page
+    end
+  
+    # The pages hash, access pages like this: Settings.pages[:name] to get the settingspage definition
+    def pages
+      @pages ||= {}
+    end
+      
+    # The pages in order of page_order, returns an array of page objects.
+    def ordered_pages
+      page_order.map{|name| pages[name]}
+    end
+    
+    # Return the page order as an array of page names
+    def page_order
+      @page_order ||= []
+    end
+    alias :page_names :page_order
+    
+    # We have to make sure always the same object will be retrieved
+    # Do a forcefull reload if you want to get a new instance from the database
+    def [](name)
+      f = self.find(:first, :conditions => {:page => name.to_s})
+      f ||= create(:page => name.to_s, :data => HashWithIndifferentAccess.new)
+      f
+    end
+    
+    # A safe way to get a value of a setting and report a warning if it can't be found  
+    # instead of calling Setting[:setting_identifier].field directly use setting(:setting_identifier, :field)
+    # 
+    # @param setting_identifier [Symbol] the symbol of the settings page
+    # @param field [Symbol] the name of the setting
+    # 
+    # @return [Object] the value of the setting or nil if not found
+    def get(setting_identifier, field)
+      if s = self[setting_identifier]
+        if s.respond_to?(field)
+          return s.send(field)
+        end
+      end
+      Rails.logger.warn "Couldn't find Setting[:#{setting_identifier}].#{field}"
+      nil
+    end
+    
+    # a safe way to get a page from the settings  
+    # 
+    # @param setting_identifier [Symbol] the symbol of the settings page
+    # @param field [Symbol] the name of the setting that references a page_id
+    # 
+    # @return [Page, NilClass] The page if found, nil otherwise
+    def get_page(setting_identifier, field)
+      if page_id = self.get(setting_identifier, field)
+        return Skyline::Page.find_by_id(page_id) if page_id.present?
+      end        
+      nil
+    end
+    
+    # Can be used to reference a Page/MediaFile etc directly. Sets it
+    # to `FIELD_id`.
+    # 
+    # @param field [String,Symbol] The field name to use (multiple possible)
+    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    
+    
+    protected
+    
+    def page_cache
+       @_page_cache ||= {}
+    end
+    
+    def create_proxy_method(name)
+      (class << self; self; end).send(:define_method,name){ self[name] }
+    end    
+  end
+  
+  # Set the data for this page, this works the same as .attributes= on 
+  # regular ActiveRecord objects.
+  def data=data
+    data = HashWithIndifferentAccess.new(data)
+    multi_parameter_attributes = [] 
+    data.each do |k,v|
+      k.include?("(") ? multi_parameter_attributes << [k,v] : send(k+"=",v)
+    end
+    assign_multiparameter_attributes(multi_parameter_attributes)
+  end
+  def data
+    self[:data] ||= HashWithIndifferentAccess.new    
+  end
+
+  # Returns a hash before it was typecasted, is empty when we didn't set any data through
+  # any virtual accessors yet.
+  def data_before_type_cast
+    @data_before_type_cast ||= HashWithIndifferentAccess.new
+  end
+
+  # Catch various virtual accessors and make sure xxx_before_typecast is also set.
+  # Typecasts data on setting.
+  def method_missing(meth,*args)
+    base_method = meth.to_s.gsub(/(_before_type_cast)|(=)$/,"").to_sym
+    if self[:page] && self.page && self.page.field_names.include?(base_method)
+      field = self.page.fields[base_method.to_sym]
+      case meth.to_s
+        when /=$/ 
+          self.data[base_method] = field.type_cast(args.first.blank? ? nil : args.first)
+          self.data_before_type_cast[base_method] = args.first
+        when /_before_type_cast$/ 
+          self.data_before_type_cast[base_method]
+        else self.data[base_method]
+      end
+    else 
+      super
+    end
+  end
+  
+  # Analogue to method_missing
+  def respond_to?(meth)
+    base_method = meth.to_s.gsub(/(_before_type_cast)|(=)$/,"").to_sym
+    self[:page] && self.page && self.page.field_names.include?(base_method) || super
+  end
+
+  # The fields hash of the current settings-page
+  def fields
+    self.page.fields
+  end
+
+  # Returns the current settingspage. Every object instance can only
+  # represent the data of one page.
+  def page
+    self.class.pages[(self.read_attribute_before_type_cast("page") || @attributes["page"]).to_sym]
+  end      
+    
+  protected
+  
+  # Make sure we catch data fields first, this way we can make the multiparameter assignment work.
+  # All other stuff is delegated to the superclass
+  def column_for_attribute(name)
+    return super if self.new_record? || self.class.column_names.include?(name)
+    self.page.fields[name.to_sym]
+  end
+    
+end