westarete-skylinecms 3.0.8.20100329

data/lib/skyline/form_builder.rb

@@ -0,0 +1,182 @@
+# Provides error wrapping and some extra helper methods to working with labels and translations
+# easier.
+#
+# Apart from adding new helper methods, this class overwrites the standard *_field 
+# and *_select helpers. If one of the fields has an error, the validation errors for 
+# that method are added just after the field. See {Skyline::FormBuilder#wrap_with_error} 
+# for more information on what get's added.
+class Skyline::FormBuilder < ActionView::Helpers::FormBuilder
+
+  # Custom InstanceTag class from which we can extract the ID
+  # @private
+  class CustomInstanceTag < ActionView::Helpers::InstanceTag
+    def to_id(options={})
+      options = options.stringify_keys
+      name_and_id = options.dup
+      add_default_name_and_id(name_and_id)
+      options.delete("index")
+      name_and_id["id"]
+    end
+  end
+  
+  unless ActiveSupport::Dependencies.load_once_path?(__FILE__)
+    ActiveSupport::Dependencies.autoloaded_constants << "Skyline::FormBuilder::CustomInstanceTag"
+  end  
+  
+  # Overwrite all standard helpers with a wrapped version.
+  (field_helpers - %w(label fields_for radio_button check_box hidden_field) + %w(select collection_select time_zone_select date_select time_select datetime_select)).each do |selector|
+    src = <<-end_src
+      def #{selector}(method, *parms)
+        wrap_with_error(method,*parms) do |parms|
+          super(method,*parms)
+        end
+      end
+    end_src
+    class_eval src, __FILE__, __LINE__
+  end  
+  
+  # An improved version of the standard label helper it will append the class "invalid"
+  # 
+  # @see ActionView::Helpers::FormBuilder#label
+  # 
+  # @return [String]
+  def label(method, text = nil, options = {})
+    if @object.errors[method]
+      super(method,text,options.merge(:class => "invalid #{options[:class]}".strip))
+    else
+      super
+    end    
+  end
+  
+  # Same as label but automatically translates the field name
+  # 
+  # @see Skyline::FormBuilder#t
+  # 
+  # @return [String]
+  def label_with_text(method, options = {})
+    self.label(method, self.t(method), options)
+  end
+  
+  # Special field to handle automated reordering of elements (
+  # with help of {Skyline::NestedAttributesPositioning} module)
+  # 
+  # @example Usage:
+  #   <% article_form.fields_for "sections_attributes", section, :index => 5 do |s| %>
+  #     <%= s.hidden_field :id unless s.object.new_record? %>
+  #     <%= s.hidden_field :_destroy, :class => "delete" %>
+  #     <%= s.positioning_field %>
+  #     ...
+  #   <% end %>
+  # 
+  # @example Results in the following fields:
+  #   <input type="hidden" name="article[sections_attributes][5][id]" id="article_sections_attributes_5_id"      value="2211"/>
+  #   <input type="hidden" name="article[sections_attributes][5][_destroy]" id="article_sections_attributes_5__destroy" class="delete"/>
+  #   <input type="hidden" name="article[sections_position][]"  id="article_sections_position_5" value="5"/>
+  #
+  def positioning_field
+    name = self.object_name.sub(/\[([^\]]*)_attributes\]$/, "[\\1_position]") + "[]"
+    value = options[:index]    
+    raise "No options[:index] defined, need one to use for ordering correctly." unless value
+    
+    tag_id = name.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "") + value.to_s
+
+    @template.hidden_field_tag name, value, :id => tag_id
+  end
+  
+  # Does the object have any errors set on an attribute.
+  # 
+  # @param attribute [String,Symbol] The attribute to check for errors
+  # @return [Boolean] 
+  def has_error?(attribute)
+    @object.errors[attribute].present?
+  end
+  
+  # Add the index of the current scope to the object_name if an index is used.
+  #
+  # @return [String] The object_name with an optional index added
+  def object_name_with_index
+    if options[:index].present?
+      self.object_name + "[#{options[:index]}]"
+    else
+      self.object_name
+    end
+  end
+  
+  # Wrap an input element with errors, also appends "invalid" to the helpers
+  # class. See {Skyline::FormBuilder#fieldset_errors} on how
+  # the errors are added. 
+  #
+  # @param method [Symbol,String] The method/attribuet to check for errors
+  # @param parms []
+  # @param options [Hash] Options to pass to the original field helper, the key :text_suffix is stripped off
+  # 
+  # @option options :text_suffix () If you want text before the errors are 
+  #   added you can set it by using text_suffix. This will be added immideately after the field.
+  # 
+  # @yield [parameters] The return value of the block will be wrapped with the error
+  # @yieldparam [Hash] parameters The parameters to pass to the block (is the same as the parms of the method)
+  # 
+  # @return [String]
+  def wrap_with_error(method,*parms,&block)
+    options = parms.extract_options!
+    method_options = options.except(:text_suffix)
+    
+    if @object.errors[method]
+      method_options[:class] ||= ""
+      method_options[:class] << " invalid"
+    end
+    
+    parms << method_options if method_options.any?    
+    html = yield(parms)
+    html << options[:text_suffix] if options[:text_suffix]
+
+    if @object.errors[method]
+      html + fieldset_errors(method)
+    else
+      html
+    end
+    
+  end
+  
+  # Generates a list of errors. Each error is wrapped in a 
+  #   <div class="error">...</div>
+  # 
+  # @param attribute [String,Symbol] The attribute to get the errors for
+  # @return [String,nil] A string containing each error in a div or nil if there are no errors.
+  def fieldset_errors(attribute)
+    return unless @object.errors[attribute]
+    out = []
+    if errs = @object.errors[attribute]
+      errs = [errs] if self.single_error_message?(errs)
+      out = errs.map do |err|        
+        @template.content_tag("div",err,:class => "error")
+      end
+    end
+    out.join("\n")
+  end
+  
+  # The ID that a field for a certain field would get.
+  #
+  # @param attribute [String,Symbol] The attribute to use for the id
+  # @return [String] A sting containing the ID for the field
+  def dom_id(attribute,options={})
+    CustomInstanceTag.new(@object_name, attribute, @template, objectify_options(options)).to_id(@options)
+  end  
+  
+  # Translation for an attribute of that's used in this formbuilder. 
+  # Uses {ActiveRecord::Base#human_attribute_name}
+  # 
+  # @param attribute [~to_s] The attribute to get the translation for
+  # @param options [Hash] Options to pass to {ActiveRecord::Base#human_attribute_name}
+  # @return [String] The translated attribute name.
+  def t(attribute, options = {})
+    self.object.class.human_attribute_name(attribute.to_s, options)
+  end
+  
+  protected
+  
+  def single_error_message?(errors)
+    !errors.kind_of?(Array) || errors[1].kind_of?(Hash)
+  end  
+  
+end

data/lib/skyline/has_many_referables_in.rb

@@ -0,0 +1,108 @@
+# Use this module in all models that have references to MediaFiles/Page/URL etc via WYSWIWYG-editors
+# It adds the class method `has_many_referables_in`. With {Skyline::HasManyReferablesIn::ClassMethods#has_many_referables_in} you can use any
+# text/string database field to have links/images that will refer correctly to their respective
+# targets through RefObject
+# 
+# @see Skyline::BelongsToReferable If you want to use a reference to a MediaFile/Page/URL directly as an association.
+#
+# @example Usage: 
+#   class Model < ActiveRecord::Base
+#     include Skyline::HasManyReferablesIn
+#     has_many_referables_in :body # :body is a database text/string field
+#   end
+#
+# @example Defines:
+#   @model = Model.new
+#   @model.body = "text <a href='http://www.google.com'>test</a>"
+#   @model.body_before_typecast #=> The unconverted value which still includes [REF:XX] tags.
+#   @model.body #=> Evertyhing is converted back to it's original state
+#   @model.body(true) #=> The HTML includes extra attributes used for editing in the WYSIWYG-editor
+#
+module Skyline::HasManyReferablesIn 
+ 
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:before_save, :parse_referable_fields)
+    base.send(:after_save, :update_referable_objects)
+    base.send(:cattr_accessor, :referable_fields)
+    
+    base.send(:has_many, :image_refs, :class_name => "Skyline::ImageRef", :foreign_key => :refering_id, :source_type => base.name, :dependent => :destroy)
+    base.send(:has_many, :link_refs, :class_name => "Skyline::LinkRef", :foreign_key => :refering_id, :source_type => base.name, :dependent => :destroy)
+    
+    base.send :alias_method_chain, :clone, :referables    
+  end
+  
+  module ClassMethods    
+    
+    
+    # Make one or more fields/columns have support for referable content in HTML.
+    #
+    # Overwrites the models accessors for the specified fields/columns. It also adds
+    # extra options to the reader. The reader accepts two parameters: `edit` (Boolean) and
+    # an options string which is passed to {Skyline::InlineRef#convert}
+    #
+    # @param fields [String,Symbol] The field(s) to enable the referable content for.
+    def has_many_referables_in(*fields)      
+      self.referable_fields ||= []
+      
+      fields.each do |f|
+        self.referable_fields << f
+        
+        self.class_eval <<-END
+          def #{f}=(body)
+            self.referable_field_bodies[:#{f}] = body            
+          end
+          def #{f}_before_typecast
+            self.referable_field_bodies[:#{f}] || self[:#{f}]
+          end
+          def #{f}(edit = false, options={})
+            options.reverse_merge! :nullify => false
+            ret = self.referable_field_bodies[:#{f}].nil? ? Skyline::InlineRef.convert(self,:#{f},edit,options) : self.referable_field_bodies[:#{f}]
+          end
+        END
+      end
+    end
+  end
+  
+  # Implementation of the clone interface
+  # @private
+  def clone_with_referables
+    returning clone_without_referables do |clone|      
+      if !self.referable_fields.nil?
+        self.referable_fields.each do |field|         
+          clone.send("#{field}=".to_sym, self.send(field,true,{:nullify => true}))
+        end
+      end
+    end
+  end
+
+  # @private  
+  # @todo Shouldn't this be protected?  
+  def referable_field_bodies
+    @referable_field_bodies ||= {}
+  end
+        
+  # @private
+  # @todo Shouldn't this be protected?    
+  def parse_referable_fields  
+    return if self.referable_fields.nil?    
+      
+    updated_refs = []
+    self.referable_fields.each do |col|      
+      if new_body = self.referable_field_bodies.delete(col)
+        self[col], refs = Skyline::InlineRef.parse_html(new_body, self, col)
+        updated_refs += refs
+      end
+    end
+        
+    @updated_ids = updated_refs.join(",")
+  end
+  
+  # @private
+  # @todo Shouldn't this be protected?  
+  def update_referable_objects
+    return if self.referable_fields.nil?
+    Skyline::InlineRef.update_all({:refering_id => self.id}, "id IN(#{@updated_ids})") unless @updated_ids.blank?
+  end
+  
+end

data/lib/skyline/javascript_generator_methods.rb

@@ -0,0 +1,13 @@
+# The JavascriptGeneratorMethods are added so they can be used within RJS blocks
+# and `render :update` blocks.
+# 
+# @private
+module Skyline::JavascriptGeneratorMethods
+  def message(type,message,options={})
+    record Skyline::MessageGenerator.new(type,message,options={})
+  end
+  
+  def notification(type,message,options={})
+    record Skyline::MessageGenerator.new(type,message,options={})    
+  end  
+end

data/lib/skyline/plugins_manager.rb

@@ -0,0 +1,29 @@
+# The {Skyline::PluginsManager} load all plugins. Currently the manager is quite
+# static as it can only load plugins from `Rails.root/vendor/skyline_plugins`. As
+# we extend the Plugin API the manager will become more advanced.
+# 
+# @private
+class Skyline::PluginsManager
+  class << self
+    def init_all!
+      public_skyline_plugins_path = Pathname.new(Rails.public_path) + "skyline_plugins"
+      FileUtils.mkdir(public_skyline_plugins_path) unless public_skyline_plugins_path.exist?
+            
+      # Initialize external skyline plugins (only once)
+      Dir[Rails.root + "vendor/skyline_plugins/*/skyline/init.rb"].each do |file|
+        load file
+      end
+    end
+        
+    def load_all!
+      # Load external skyline plugins (possibly at every request)
+      Dir[Rails.root + "vendor/skyline_plugins/*/skyline/load.rb"].each do |file|
+        load file
+      end      
+    end
+    
+    def migration_paths
+      Dir[Rails.root + "vendor/skyline_plugins/*/db/migrate"]
+    end
+  end
+end

data/lib/skyline/positionable.rb

@@ -0,0 +1,47 @@
+# Positionable automatically adds the last position number to ActiveRecord models 
+# in the `position` column. It only set's the position if it isn't set yet.
+# 
+# By defining an optional scope the position numbering will only look inside a certain scope.
+#
+# @example Usage: 
+#   class Model < ActiveRecord::Base
+#     include Skyline::Positionable
+#     self.positionable_scope = :parent_id   # (Optional)
+#   end
+# 
+module Skyline::Positionable
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send :before_save, :set_position
+  end
+  
+  module ClassMethods
+    
+    # Get the positionable_scope for this class (uses an instance variable on class level)
+    #
+    # @return [String,Symbol] The scope to look in
+    def positionable_scope
+      @positionable_scope
+    end
+    
+    # Set the positionable_sope for this class
+    #
+    # @param scope [String,Symbol] The scope to use, mostly a column name.
+    # @return [String,Symbol] The scope that has just been set.
+    def positionable_scope=(scope)
+      @positionable_scope = scope
+    end
+  end
+  
+  protected
+  
+  def set_position
+    return unless self.position.nil?
+    
+    if self.class.positionable_scope
+      self.position = self.class.find_by_sql(["SELECT MAX(position) as position FROM #{self.class.table_name} WHERE #{self.class.positionable_scope}=?", self.send(self.class.positionable_scope)]).first["position"].to_i + 1
+    else
+      self.position = self.class.find_by_sql("SELECT MAX(position) as position FROM #{self.class.table_name}").first["position"].to_i + 1
+    end
+  end  
+end

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

@@ -0,0 +1,48 @@
+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.
+  # 
+  # @return [Array<Array>] Array of arrays with the first element the title and as second element the url.
+  def bread_crumb(bc,options={})
+    if bc.kind_of? Skyline::ArticleVersion
+      page = bc
+      bc = bc.page.nesting.map{|p| [p.published_publication_data.andand.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,25 @@
+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 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
+  
+  # @deprecated Will be removed in 3.1 for the more general sections_per_column
+  alias :page_sections_per_column :sections_per_column
+    
+end

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

@@ -0,0 +1,147 @@
+# We have this in here so YARD recognizes the module nesting
+module Skyline::Rendering
+  module Helpers
+    module RendererHelper
+      
+      # Set global renderer assigns. These are accessible throughout all render/render_collection calls. They
+      # are especially usefull in scenarios where you want a sub-item render a piece of the page. You can assign it
+      # to `:content_for_sidebar` and in your page template you can read `assigns(:content_for_sidebar)` and place the content
+      # the content item rendered to the variable `:content_for_sidebar`
+      # 
+      # @param key [Symbol] The key to store or read
+      # @param value [Object] Anything you want to store, if empty and no block given this method just returns the stored value
+      # 
+      # @yield A block to capture, see also the `capture` documentation in Rails
+      # @yieldreturn [String] The result of doing a regular `capture`
+      # 
+      # @return The value stored with the key.
+      def assign(key, value = nil, &block)
+        return @_template_assigns[key] if value.nil? && !block_given?
+        if block_given?
+          @_template_assigns[key] = capture(&block)
+        else
+          @_template_assigns[key] = value
+        end
+      end
+
+      # Get's the current Renderer instance that is rendering the template we're in.
+      # 
+      # @return [Skyline::Rendering::Renderer] The renderer
+      def renderer
+        @_renderer
+      end
+
+      # @see Skyline::Rendering::Renderer#render
+      def render_object(object, options = {})
+        renderer.render(object, options)
+      end
+
+      # @see Skyline::Rendering::Renderer#render_collection
+      def render_collection(objects, options = {},&block)
+        renderer.render_collection(objects, options, &block)
+      end
+
+      # @see Skyline::Rendering::Renderer#peek
+      def peek(n=1, &block)
+        renderer.peek(n, &block)
+      end
+
+      # @see Skyline::Rendering::Renderer#peek_until} 
+      def peek_until(&block)
+        renderer.peek_until(&block)
+      end
+
+      # @see Skyline::Rendering::Renderer#render_until
+      def render_until(&block)
+        renderer.render_until(&block)
+      end    
+
+      # @see Skyline::Rendering::Renderer#skip!
+      def skip!(n=1)
+        renderer.skip!(n)
+      end
+
+      # @see Skyline::Rendering::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.
+      # 
+      # @deprecated Don't use the name of the object anymore,  use `renderer.object` instead.
+      def method_missing(method, *params, &block)
+        return @_local_object if @_local_object_name == method
+        super
+      end
+    end
+  end
+end