skylinecms 3.0.7

data/lib/skyline/rendering/helpers/bread_crumb_helper.rb

@@ -0,0 +1,46 @@
+module Skyline::Rendering::Helpers::BreadCrumbHelper
+  
+  # Helper to easily create breadcrumbs that are cut off in the middle.
+  #
+  # @param bc [Array<Array>] :: An array of arrays with two elements: [[title,url],[title,url]...]
+  # @param options [Hash] :: Options
+  #
+  # @option options :max_length [Integer] () Limit the max length in chars. Returns an array with nil element where 
+  #   something has been cut away.
+  def bread_crumb(bc,options={})
+    if bc.kind_of? Skyline::ArticleVersion
+      page = bc
+      bc = bc.page.nesting.map{|p| [p.published_publication_data.navigation_title,p.url]}
+      bc[-1][0] = page.data.navigation_title
+    end
+    
+    if options[:max_length] && bc.size > 1
+      # always display the last page
+      b = [bc.pop]
+      length = b[-1][0].size
+            
+      # then try to 'add' the first page if it fits
+      first = nil
+      if length + bc[0][0].to_s.size <= options[:max_length]
+        first = bc.shift
+        length += first[0].to_s.size
+      end
+      
+      # try to add pages in between starting from the 2nd to last page and going back as long as it fits
+      bc.reverse.each do |p|
+        if length + p[0].to_s.size <= options[:max_length]
+          b.unshift(p)
+          length += p[0].to_s.size
+        else
+          b.unshift(nil)
+          break
+        end
+      end
+      
+      b.unshift(first) if first
+      b
+    else
+      bc
+    end    
+  end  
+end

data/lib/skyline/rendering/helpers/column_helper.rb

@@ -0,0 +1,22 @@
+module Skyline::Rendering::Helpers::ColumnHelper
+  
+  # Devides the sections into columns depending on splitter location
+  #
+  # @param page_version [ArticleVersion] The ArticleVersion to get section from to split
+  #
+  # @return [Array<Array<Section>>]:: An array of columns each containing and array of sections.
+  def page_sections_per_column(page_version)
+    sections_per_col ||= []
+    col = 0
+    page_version.sections.each do |section|
+      if section.sectionable_type == "Skyline::Sections::SplitterSection" 
+        col += 1
+      else
+        sections_per_col[col] ||= []
+        sections_per_col[col].push(section)
+      end
+    end
+    sections_per_col
+  end
+    
+end

data/lib/skyline/rendering/helpers/renderer_helper.rb

@@ -0,0 +1,130 @@
+# We have this in here so YARD recognizes the module nesting
+module Skyline::Rendering
+  module Helpers
+    module RendererHelper
+      def assign(key, value = nil)
+        return @_template_assigns[key] if value.nil?
+        @_template_assigns[key] = value
+      end
+
+      # Get's the current Renderer instance that is rendering the template we're in.
+      # 
+      # @return [Skyline::Renderer] The renderer
+      def renderer
+        @_renderer
+      end
+
+      # @see Skyline::Renderer#render
+      def render_object(object, options = {})
+        renderer.render(object, options)
+      end
+
+      # @see Skyline::Renderer#render_collection
+      def render_collection(objects, options = {},&block)
+        renderer.render_collection(objects, options, &block)
+      end
+
+      # @see Skyline::Renderer#peek
+      def peek(n=1, &block)
+        renderer.peek(n, &block)
+      end
+
+      # @see Skyline::Renderer#peek_until} 
+      def peek_until(&block)
+        renderer.peek_until(&block)
+      end
+
+      # @see Skyline::Renderer#render_until
+      def render_until(&block)
+        renderer.render_until(&block)
+      end    
+
+      # @see Skyline::Renderer#skip!
+      def skip!(n=1)
+        renderer.skip!(n)
+      end
+
+      # @see Skyline::Renderer#skip_until!
+      def skip_until!(&block)
+        renderer.skip_until!(&block)
+      end
+
+      # @see ActionController::Request#session  
+      def session
+        @_controller.session
+      end
+
+      # @see ActionController::Request#params 
+      def params
+        @_controller.params
+      end
+
+      # @see ActionController::Cookies#cookies
+      def cookies
+        @_controller.cookies
+      end
+
+      # The request that's currently being processed
+      #
+      # @return ActiveRecord::Request  
+      def request
+        @_controller.request
+      end
+
+      def flash
+        @_controller.send(:flash)
+      end
+
+      # The site that's currently in scope for this template
+      #
+      # @return Skyline::Site
+      def site
+        @_site
+      end
+
+      # @see ActionView::Helpers::UrlHelper#url_for
+      def url_for(options = {})
+        options ||= {}
+        url = case options
+        when String
+          super
+        when Hash
+          options = { :only_path => options[:host].nil? }.update(options.symbolize_keys)
+          escape  = options.key?(:escape) ? options.delete(:escape) : true
+          @_controller.send(:url_for, options)
+        when :back
+          escape = false
+          @_controller.request.env["HTTP_REFERER"] || 'javascript:history.back()'
+        else
+          super
+        end
+
+        escape ? escape_once(url) : url
+      end
+
+      # @see ActionController::RequestForgeryProtection#protect_against_forgery?
+      def protect_against_forgery?
+        @_controller.send(:protect_against_forgery?)
+      end
+
+      # @see ActionController::RequestForgeryProtection#request_forgery_protection_token
+      def request_forgery_protection_token
+        @_controller.request_forgery_protection_token
+      end
+
+      # @see ActionController::RequestForgeryProtection#form_authenticity_token
+      def form_authenticity_token
+        @_controller.send(:form_authenticity_token)
+      end
+
+      # Simple, quick 'n dirty solution so you can use 'acticle_version', 'news_item', .. in all 
+      # your templates. So you don't have to use @.... or pass the local to all partials.
+      # 
+      # @private
+      def method_missing(method, *params, &block)
+        return @_local_object if @_local_object_name == method
+        super
+      end
+    end
+  end
+end

data/lib/skyline/rendering/helpers/settings_helper.rb

@@ -0,0 +1,31 @@
+module Skyline::Rendering::Helpers::SettingsHelper
+  # 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 setting(setting_identifier, field)
+    if s = ::Settings[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,nil] The page if found, nil otherwise
+  def page_from_setting(setting_identifier, field)
+    if page_id = setting(setting_identifier, field)
+      return Skyline::Page.find_by_id(page_id) if page_id.present?
+    end    
+    nil
+  end  
+end

data/lib/skyline/searchable_item.rb

@@ -0,0 +1,132 @@
+# Use this module in all content models that need to be indexed and searchable by Solr
+#
+# Usage: 
+# class Model < ActiveRecord::Base
+#   include Skyline::SearchableItem
+#
+#   searchable_field :title => :title,
+#                    :body => :body,
+#                    :documentdate => :publication_date,
+#                    :url => :url,
+#                    :theme_s => :theme_title,
+#                    :year_i => :publication_year
+#
+#   [indexer_option :if => :published_publication_id_changed?]
+# end
+#
+# 
+# 1) Gives your Model the following interface:
+# 
+#    class  Model < ActiveRecord::Base
+#      after_save :add_index
+#      after_destroy :remove_from_index
+#
+#      self << class
+#        def searchable_field(fields)
+#      end
+#    end
+
+module Skyline::SearchableItem
+	
+	def self.included(base)
+ 		base.extend(ClassMethods)
+		base.send(:after_save, :add_index)
+		base.send(:after_destroy, :remove_from_index)
+		base.send(:cattr_accessor, :searchable_fields)
+		base.send(:cattr_accessor, :indexer_options)
+		base.send(:indexer_options=, {})
+	end
+ 	
+ 	module ClassMethods
+ 		# Method to add fields from the model to the solr index
+ 		# ==== Parameters
+ 		# fields<Hash>::hash of fields as 
+ 		# field => solr-field
+ 		#
+ 		# ==== Options
+ 		# if field is symbol then the value of the field is indexed
+ 		# if field is a string then the string itself is indexed
+ 		# if field is a Proc, the result of calling the Proc (with myself as argument) is indexed
+ 		#
+ 		# 							solr-field must be pressent in solr configuration
+ 		def searchable_field(fields)
+ 			self.searchable_fields ||= {} 			
+ 			fields.each do |sf, f|
+        self.searchable_fields.merge!(sf => f)
+      end
+ 		end
+ 		
+ 		# Method to set options for the indexer
+ 		# ==== Parameters
+ 		# options<Hash>::
+ 		# 
+ 		# ==== Options
+ 		# :if            a method or lambda function which should return true for the indexing process to continue
+ 		def indexer_option(options)
+ 		  self.indexer_options = options
+ 		end
+ 	end
+ 	
+  def solr_typecast(v)
+    case v
+    when ActiveSupport::TimeWithZone, Date, Time, DateTime
+      v.to_time.utc.iso8601(3)
+    when String
+      ActionController::Base.helpers.strip_tags(v)
+    else
+      v
+    end
+  end
+ 	
+ 	# Return the solr id
+ 	def solr_id
+		solr_id = "#{self.class.name}-#{self.id}"
+	end
+	
+	# create hash for solr from self.searchable_fields
+	# ==== Returns
+	# Hash:: hash with solr_field => value pairs
+	def hash_searchable_fields
+		hash = {}
+		self.searchable_fields.each do |sf, f|
+		  value = case f.class.name
+		          when "Proc"
+		            f.call(self)
+		          when "String"
+		            f
+		          else
+		            self.send(f)
+		          end
+	    hash[sf] = solr_typecast(value)			
+		end
+  	hash.merge!({:id => self.solr_id, :cat => self.class.name})
+	end
+	
+	# Add/Update solr index
+ 	def add_index
+ 	  return unless self.evaluate_if_option
+ 	  
+ 	  indexer = Skyline::Indexer.instance	
+ 	  if (self.class.publishable? && self.published?) || !self.class.publishable?
+		  indexer.add_index(hash_searchable_fields)
+		else
+		  indexer.remove_from_index(self.solr_id)
+		end
+	end
+		
+	# Remove item from solr-index
+	def remove_from_index
+		indexer = Skyline::Indexer.instance
+		indexer.remove_from_index(self.solr_id)
+	end
+ 		
+	def evaluate_if_option
+	  return true unless self.indexer_options.has_key?(:if)
+	  return case self.indexer_options[:if].class.name
+           when "Proc"
+             self.indexer_options[:if].call(self)
+           else
+             self.send(self.indexer_options[:if])
+           end
+  end
+end

data/lib/skyline/section_item.rb

@@ -0,0 +1,35 @@
+# Defines the SectionItem 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::SectionItem
+#   end
+#
+# @example Defines:
+#   Model.default_interface = true # defaults to true
+#   @model = Model.new
+#   @model.to_text #=> ""
+#
+module Skyline::SectionItem 
+ 
+  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,175 @@
+module Skyline::Settings
+  
+  def self.included(obj)
+    obj.extend(KlassMethods)
+    obj.send(:serialize, :data)
+  end  
+  
+  module KlassMethods
+    
+    # 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)
+    # ==== Parameters
+    # setting_identifier<Symbol>:: the symbol of the settings page
+    # field<Symbol>:: the name of the setting
+    #
+    # ==== Returns
+    # 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     
+    # ==== Parameters
+    # setting_identifier<Symbol>:: the symbol of the settings page
+    # field<Symbol>:: the name of the setting that references a page_id
+    #
+    # ==== Returns
+    # Page:: the page if found or 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
+    
+    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