skylinecms 3.0.7

data/app/helpers/skyline/editors/list.rb

@@ -0,0 +1,15 @@
+class Skyline::Editors::List < Skyline::Editors::Editor
+  def output_without_errors
+    select_tag(input_name(self.attribute_names),option_tags)       
+  end
+  
+  private
+  def option_tags
+    list = case field.list
+      when Array, Hash : field.list
+      when Proc : perform_proc(field.list)
+    end
+    options_for_select(list,field.attribute_value(self.record))
+  end
+    
+end

data/app/helpers/skyline/editors/page_browser.rb

@@ -0,0 +1,54 @@
+class Skyline::Editors::PageBrowser < Skyline::Editors::Editor
+  def output_without_errors
+    attr_names = self.attribute_names.dup
+    attr_names[-1] = attr_names[-1].to_s.gsub(/_id$/, "_attributes")
+    input_name_prefix = input_name(attr_names)                    # ie: element[image_attributes]
+    input_id_prefix = input_id(attr_names)                        # ie: element_image_attributes
+    
+    association = field.name.to_s.gsub(/_id$/, "")                # ie: image
+    location = nil
+    if record.respond_to?(association)
+      location = :model
+      page = record.send(association)
+      page ||= record.send("build_#{association}")
+      page_title = page.referable_type.blank? ? "" : page.andand.default_variant.andand.data.andand.navigation_title
+      linked = !page.referable_type.blank?
+      referable_type = page.referable_type
+      referable_id = page.referable_id
+    else
+      location = :settings
+      page = Skyline::Page.find_by_id(field.value(record))
+      page_title = page.andand.default_variant.andand.data.andand.navigation_title
+      linked = page.present?
+      referable_type = page ? "Skyline::Page" : ""
+      referable_id = page ? page.id : ""
+    end
+    
+    <<-EOF
+      <div id="#{input_id_prefix}">
+        #{hidden_field_tag(input_name(attr_names+['id']), page.id) if location == :model}
+        #{hidden_field_tag(input_name(attr_names+['_destroy']), 0, :class => 'delete')}
+        #{hidden_field_tag(input_name(attr_names+['referable_type']), referable_type, :class => 'referable_type')}
+        #{hidden_field_tag(input_name(attr_names+['referable_id']), referable_id, :class => 'referable_id')}
+
+        <div class="content-browser">
+          <div class="relatesTo#{' linked' if linked}">
+
+            <div class="not-linked">
+              <div class="blank">
+                #{t(:nothing_selected, :scope => [:browser,:page])}
+                #{link_to_function button_text(:browse),  "Application.Browser.browsePageFor('#{input_id_prefix}');", :class => "browse button small"}
+              </div>
+            </div>        
+
+            <div class="linked">
+              #{t(:links_to, :scope => [:browser,:page], :referable_title => "<span class=\"referable_title\">#{page_title}</span>")}
+              #{link_to_function(button_text(:delete), "Application.Browser.unlink('#{input_id_prefix}');", :class => "delete button small red")}
+              #{link_to_function button_text(:browse),  "Application.Browser.browsePageFor('#{input_id_prefix}');", :class => "browse button small"}
+            </div>
+          </div>
+        </div>
+      </div>
+EOF
+  end
+end    

data/app/helpers/skyline/editors/text_field.rb

@@ -0,0 +1,12 @@
+class Skyline::Editors::TextField < Skyline::Editors::Editor
+  def output_without_errors
+   text_field_tag(
+     input_name(self.attribute_names), 
+     field.value(record),
+     :size => 40,
+     :id => input_id(self.attribute_names),
+     :style => params_to_styles(field.style),
+     :class => "full"
+   )
+  end
+end    

data/app/helpers/skyline/editors/textarea.rb

@@ -0,0 +1,11 @@
+class Skyline::Editors::Textarea < Skyline::Editors::Editor
+   def output_without_errors
+     text_area_tag(
+       input_name(self.attribute_names), 
+       field.value(record), 
+       :rows => 8,:cols => 50,
+       :id => input_id(self.attribute_names),
+       :style => params_to_styles(field.style)       
+     )
+   end
+ end

data/app/helpers/skyline/editors/textile.rb

@@ -0,0 +1,12 @@
+class Skyline::Editors::Textile < Skyline::Editors::Editor
+  def output_without_errors
+    text_area_tag(
+      input_name(self.attribute_names), 
+      field.value(record), 
+      :rows => 8,
+      :cols => 50, 
+      :class => "textile",
+      :style => params_to_styles(field.style)
+    ) + content_tag("div", "You can use textile syntax to format your text. See <a href=\"http://hobix.com/textile/\" target=\"_blank\">the syntax rules for help</a>.")
+  end      
+end

data/app/helpers/skyline/editors/wysiwyg.rb

@@ -0,0 +1,28 @@
+class Skyline::Editors::Wysiwyg < Skyline::Editors::Editor
+  def output_without_errors
+    out = content_tag("div",text_area_tag(
+      input_name(self.attribute_names), 
+      record.send(field.name,true), 
+      :class => "wysiwyg", 
+      :rows => 15,
+      :cols => 90,
+      :id => self.tag_id,
+      :style => params_to_styles(field.style)
+    ), :class => "section")
+    out << self.tinymce_js
+  end
+  
+  def tag_id
+    "wysiwyg" + self.attribute_names.join("_")
+  end
+  
+  def tinymce_js
+    javascript_tag "new Skyline.Editor('#{self.tag_id}',{
+      contentCss : '/skyline/stylesheets/wysiwyg.css',
+      #{"enableEditHtml : true," if current_user.allow?("tinymce_edit_html")}
+      language : Application.locale    
+    })"
+  end
+  
+
+end

data/app/helpers/skyline/media_files_helper.rb

@@ -0,0 +1,6 @@
+module Skyline::MediaFilesHelper
+  def skyline_media_file_path_with_session_information(media_dir)
+    session_key = ActionController::Base.session_options[:session_key] || ActionController::Base.session_options[:key]
+    skyline_media_dir_media_files_path(media_dir, session_key => cookies[session_key], request_forgery_protection_token => form_authenticity_token)
+  end
+end

data/app/helpers/skyline/message_generator.rb

@@ -0,0 +1,24 @@
+class Skyline::MessageGenerator
+  include ActionView::Helpers::JavaScriptHelper
+  
+  def initialize(type,message,options={})
+    (@options = options || {}).update(:type => "'#{escape_javascript(type.to_s)}'")
+    @message = message
+  end
+  
+  def to_s
+    options = @options.dup
+    options.each do |k,v|
+      options[k] = case v
+        when Hash : self.options_for_javascript(v)
+        else v
+      end
+    end    
+    "new Application.Message('#{self.escape_javascript(@message)}',#{self.options_for_javascript(options)})"
+  end
+  
+  def to_str
+    to_s
+  end
+  
+end

data/app/helpers/skyline/pages_helper.rb

@@ -0,0 +1,44 @@
+module Skyline::PagesHelper  
+  
+  # Renders a label and selectbox for the sectionable_type passed in, it doesn't render
+  # anything if there is only one template.
+  #
+  # ==== Parameters
+  # st<String,Symbol> :: The sectionable type
+  # form<FormBuidler> :: The formbuilder to place this select in.
+  # options<Hash>     :: See options
+  #
+  # ==== Options
+  # :label<String,false> :: Use another label or false for no label
+  #
+  # ==== Returns
+  # String :: The label and the selectbox
+  # nil :: Nil if there is nothing to render
+  # --
+  def renderable_templates_select(object, form, options = {})
+    raise "@renderable_scope not available" unless @renderable_scope
+    
+    return nil if @renderable_scope.templates_for(object).size <= 1
+    
+    options.reverse_merge! :label => Skyline::Section.human_attribute_name("template")
+    
+    out = []
+    if options[:label]
+      out << form.label(:template, options[:label]) 
+      out << ": "
+    end
+    out << form.select(:template, templates_for_select(object) )
+    out.join
+  end
+  
+  def templates_for_select(object)
+    raise "@renderable_scope not available" unless @renderable_scope
+    
+    scope = [:templates]
+    scope += object.class.name.sub(/^Skyline::/,"").underscore.split("/").map(&:to_sym)
+    templates = @renderable_scope.templates_for(object).dup
+    templates = (["default"] + templates) if templates.delete("default")
+    templates.map {|tmpl| [t(tmpl,:scope => scope, :default => tmpl),tmpl]  }
+  end
+  
+end

data/app/helpers/skyline/presenters/article_list.rb

@@ -0,0 +1,139 @@
+class Skyline::Presenters::ArticleList < Skyline::Presenters::Presenter
+    
+  def output
+    ["<div id=\"list-wrapper\"><ul class=\"article-list #{"orderable" if self.fieldset.orderable?}\" id=\"list\">",header,body,"</ul>",footer,"</div>"].join("\n")
+  end
+  
+  def body
+    if self.collection.any?
+      self.collection.map{|el| self.row(el) }
+    else
+      "<li class=\"blank-slate\">#{t(:blank_slate, :scope => [:content,:list], :class =>  self.fieldset.plural_name.downcase)} " +
+      link_to(t(:add_a_new, :scope => [:content], :class => self.fieldset.singular_name.downcase),:action => "create", :types => stack.url_types, :return_to => url_for({})) +
+      "</li>"
+    end
+  end
+  
+  def footer
+    if fieldset.orderable? && self.collection.any?
+      <<-EOS
+        <script type="text/javascript" charset="utf-8">
+          var s = new Skyline.Sortable("list",{handle: "span.drag", clone: true, revert: true, draggables: "li.element"});
+          s.addEvent("afterDrop", function(){
+            #{
+              remote_function(
+                :url => {:action => "order", :types => stack.url_types},
+                :data => "'order=' + Application.getSequence('#list li.element').join(',')"
+              )            
+            }
+          });
+        </script>
+      EOS
+    else
+      ""
+    end
+  end
+  
+  
+  #   <li class="header">
+  #   <div class="draggable">
+  #     <ul class="meta">
+  #       <li style="width: 50%">Sub-pagina's</li>  
+  #       <li style="width: 50%">Publicatiedatum</li>
+  #     </ul>
+  #   </div>
+  # </li>
+  def header
+    out = "<li class=\"header\">"
+    out << "<div class=\"edit\">&nbsp;</div>"    
+    out << "<div class=\"draggable\">"
+    out << "<div class=\"content\">&nbsp;</div>"
+    out << "<ul class=\"meta\">"
+    self.heading_collection.each do |field|
+      out << "<li style=\"width: #{self.heading_size}\">#{field.singular_label}</li>"      
+    end
+    out << "</ul>"    
+    out << "</div><div class=\"clear\">&nbsp;</div>"
+    out << "</li>"
+    if self.options[:navigation] && stack.has_parent?
+      out << "<li class=\"up\">"+link_to(t(:up_one_level, :scope => [:content,:list]), :action => "list", :types => stack.url_types(:up => 1,:collection => true))+"</li>"
+    end
+    out
+  end  
+    
+  # <li class="even">
+  #   <span class="drag" ></span> 
+  #   <div class="edit">
+  #     <a href="#"><img src="/images/buttons/edit.gif?1197741337" alt="Edit"/></a>       
+  #     <a href="#"><img src="/images/buttons/delete.gif?1197741337" alt="Edit"/></a>               
+  #   </div>
+  #   <div class="draggable">
+  #     <div class="content">
+  #       <h3>Titel van dit artikel</h3>
+  #       <p>Some sub info.....</p>
+  #     </div>
+  #     <ul class="meta">
+  #       <li style="width: 50%">7 items (view)</li>
+  #       <li style="width: 50%">Publicatiedatum</li>
+  #     </ul>
+  #   </div>
+  # </li>  
+  def row(record)
+    return if record.new_record? # there can't be any new records in a list!
+    out = ""
+    out << "<span class=\"drag\">&nbsp;</span>" if fieldset.orderable?
+    out << content_tag("div",edit_button(record) + " " + delete_button(record),:class => "edit")
+    out << "<div class=\"draggable\">"
+    out << content(record)
+    out << meta(record)
+    out << "</div><div class=\"clear\">&nbsp;</div>"
+    content_tag("li",out,:class => cycle("odd","even") + " element", :id => "element_#{record.id}")
+  end
+  
+  def content(record)
+    out = "<div class=\"content\">"
+    title,opts = value(record,title_field)
+    out << "<h3>#{title}</h3>"
+    if subtitle_field
+      subtitle,opts = value(record,subtitle_field)
+      out << "<p>#{subtitle}</p>"
+    end
+    out << "</div>"    
+  end
+  
+  def meta(record)
+    out = "<ul class=\"meta\">"
+    self.heading_collection.each do |field|
+      v,rest = value(record,field)
+      out << "<li style=\"width: #{self.heading_size}\">#{v.blank? ? "&nbsp;" : v}</li>"
+    end
+    out << "</ul>"
+  end
+  
+  def heading_collection(fieldset=self.fieldset,cache=true)
+    return @heading_collection if @heading_collection && cache
+    @heading_collection = super.find_all{|f| ![self.title_field,self.subtitle_field].include?(f) }    
+  end
+  
+  # We have to use 99% as to fool IE
+  def heading_size
+    @heading_size ||= "#{(99 / self.heading_collection.size.to_f).to_i}%"
+  end
+  
+  # @deprecated: the use of title_column
+  def title_field
+    self.fieldset.fields[self.fieldset.settings.title_field || self.fieldset.settings.title_column || first_non_hidden_field]
+  end
+
+  # @deprecated: the use of subtitle_column
+  def subtitle_field
+    self.fieldset.settings.subtitle_field && self.fieldset.fields[self.fieldset.settings.subtitle_field] ||
+    self.fieldset.settings.subtitle_column && self.fieldset.fields[self.fieldset.settings.subtitle_column] || 
+    nil
+  end
+  
+  def first_non_hidden_field
+    self.fieldset.field_names.find{|f| self.fieldset.fields.has_key?(f) && !self.fieldset.fields[f].hidden_in(:list) }
+  end
+  
+end

data/app/helpers/skyline/presenters/presenter.rb

@@ -0,0 +1,127 @@
+# Use options[:collection] = collection_name to specify this list is sub-colleciton of
+# a parent object.
+
+class Skyline::Presenters::Presenter
+  class << self
+    def create(presenter,records,fieldset,template,options={})
+      klass = case presenter
+        when :article : Skyline::Presenters::ArticleList
+        else Skyline::Presenters::Table
+      end      
+      klass.new(records,fieldset,template,options)
+    end
+  end
+  
+  attr_accessor :collection,:options, :fieldset
+  def initialize(collection, fieldset,template, options={})
+    @collection = collection
+    @fieldset = fieldset
+    @template = template
+    options.reverse_merge!(:navigation => true)
+    @options = options
+    # Make sure we initialize the stack
+    self.stack
+  end
+  
+  # Delegate all missing methods (helpers) to the template
+  def method_missing(method,*params)
+    @template.send(method,*params)
+  end
+  # Speedup 
+  def content_tag(*params); @template.content_tag(*params); end # :nodoc:
+  
+  def output
+    [header,body,footer].join("\n")
+  end
+  
+  def header; ""; end
+  def body; ""; end
+  def footer; ""; end
+  
+  protected
+  
+  def edit_button(record)
+		link_to button_text(:edit),{:action => "edit", :types => stack.url_types(:down => [record.id]), :return_to  => url_for({:filter => params[:filter]})}, :class => "button small"
+  end
+  
+  def delete_button(record)
+    link_to_remote button_text(:delete),{ 
+                   :url => {:action => "delete",:types => stack.url_types(:down => [record.id]),:return_to  => url_for({})},
+                   :confirm => t(:confirm_deletion, :scope => [:content,:list], :class => self.fieldset.singular_name) }, :class => "button small red"
+  end
+
+    
+  # We have to create our own stack, since it may be possible that we're
+  # inline of some other screen. We have to add the collection we're listing to this stack
+  # this may mean we don't have to do anything at all because the main stack is aleady the right one
+  # Navigation within inlin lists is prohibited, because we do not support sub-list navigation on an inline list yet.
+  def stack
+    return @stack if @stack
+    @stack = @template.stack.dup
+    
+    if self.options[:collection] && !(@stack.collection_name == self.options[:collection])      
+      @stack.push(self.options[:collection])
+      self.options[:navigation] = false
+    end
+    @stack
+  end  
+
+  def heading_collection(fieldset=self.fieldset,cache=true)
+    return @heading_collection if @heading_collection && cache
+    
+    @heading_collection = []
+
+    fieldset.each_field do |field|
+      next if field.hidden_in :list
+      case field
+        when Skyline::Content::MetaData::Field       
+          @heading_collection << field
+        when Skyline::Content::MetaData::FieldGroup
+          @heading_collection += heading_collection(field,false)
+      end 
+    end
+
+    # Publishable
+    @heading_collection << Skyline::Content::MetaData::Field.new(:name => :published, :owner => fieldset, :editor => :publish) if fieldset.kind_of?(Class) && fieldset.publishable?  
+
+    @heading_collection        
+  end
+
+  def value(record,field)
+    if field.association?
+      case field.reflection.macro
+        when :has_many 
+			    link_to "#{record.send(field.reflection.name).count.to_s} items (view)", :action => "list", :types => stack.url_types(:down => [record.id,field.name])
+			  when :belongs_to
+          sub_record = record.send(field.reflection.name)
+			    sub_record && sub_record.human_id || ""
+		  end
+    else
+      begin
+      content = field.value(record)
+      end
+      
+      case field.editor
+        # :publish editor is temporary editor created by the presenter itself.
+        when :publish : [content ? image_tag("/skyline/images/icons/true.gif", :alt => t(:true, :scope => [:icons])) : image_tag("/skyline/images/icons/false.gif", :alt => t(:true, :scope => [:icons])),{:class => "center"}]
+        else normalize_content(content,field)          
+      end
+    end        
+  end
+  
+  def normalize_content(content,field=nil)
+    case content 
+      when /<.+?>/ : 
+        if field.filter_html == false
+          content.to_s
+        else
+          truncate(simple_format(strip_tags(content.gsub("<br />", "<br />\n").gsub("</p>", "</p>\n"))),150)
+        end
+      when String : truncate(content,150)
+      when TrueClass,FalseClass : [(content ? image_tag("icons/tick.png") : image_tag("icons/cross.png")),{:class => "center"}]
+      when Date,Time : l(content, :format => :long)
+      else content.to_s
+    end 
+  end
+  
+end