westarete-skylinecms 3.0.8.20100329

data/app/controllers/skyline/variant_current_editor_controller.rb

@@ -0,0 +1,37 @@
+class Skyline::VariantCurrentEditorController < Skyline::ApplicationController
+  layout false
+  
+  def poll
+    return render(:nothing => true) if session[:user_id].blank?
+    
+    response = {}
+    data = Skyline::Variant.find_current_editor_for(params[:variant_id])
+    current_user_is_editor = data["current_editor_id"].nil? || data["current_editor_id"].to_i == session[:user_id]
+
+    if current_user_is_editor || Skyline::Variant.editor_idle_time < (Time.zone.now - data["current_editor_timestamp"])
+      Skyline::Variant.update_current_editor(params[:variant_id],session[:user_id])
+      response[:current_editor] = true
+    else
+      u = Skyline::User.find_by_id(data["current_editor_id"])
+      response.update({
+        :current_editor => false,
+        :title => I18n.t(:dialog_title, :scope => [:variant_current_editor,:takeover]),
+        :message => render_to_string(:partial => "skyline/articles/takeover_action", :locals => {:current_editor => u})
+      })
+    end
+
+    
+    render :text => response.to_json
+  end
+  
+  def process(request,*args)
+    logger.silence(ActiveSupport::BufferedLogger::Severity::FATAL){ super }
+  end  
+  
+  protected
+
+  def protect?
+    false
+  end
+  
+end

data/app/controllers/skyline/variants_controller.rb

@@ -0,0 +1,71 @@
+class Skyline::VariantsController < Skyline::ApplicationController
+  insert_before_filter_after :authentication, :find_article
+
+  authorize :create, :by => Proc.new{|user,controller,action| user.allow?(controller.article, :variant_create)  }
+  authorize :destroy, :by => Proc.new{|user,controller,action| user.allow?(controller.article, :variant_delete)  }
+  authorize :force_edit, :by => "variant_force_edit"
+  
+  def create
+    return handle_unauthorized_user unless Skyline::Configuration.enable_multiple_variants
+    
+    if params[:variant_id]
+      variant_to_clone = @article.variants.find_by_id(params[:variant_id])
+      variant = variant_to_clone.clone
+      variant.save
+    else
+      variant = @article.variants.create
+    end
+    messages[:success] = t(:success, :scope => [:variant, :create, :flashes])
+    redirect_to edit_skyline_article_path(@article, :variant_id => variant.id)    
+  end
+  
+  def destroy
+    return handle_unauthorized_user unless Skyline::Configuration.enable_multiple_variants
+    
+    variant = @article.variants.find_by_id(params[:id])
+    if variant
+      if variant.published_variant?
+        messages[:error] = t(:error_variant_published, :scope => [:variant, :destroy, :flashes])
+        redirect_to edit_skyline_article_path(@article)
+      else        
+        variant.destroy 
+        if variant.article.frozen?
+          messages[:success] = t(:success_variant_and_page, :scope => [:variant, :destroy, :flashes, @article.class])
+          redirect_to skyline_articles_path(:type => @article.class.name.underscore)
+        else
+          messages[:success] = t(:success_variant, :scope => [:variant, :destroy, :flashes])
+          redirect_to edit_skyline_article_path(@article)
+        end
+      end
+    else
+      notifications[:error] = t(:error, :scope => [:variant, :destroy, :flashes])
+      redirect_to edit_skyline_article_path(@article)
+    end    
+  end
+  
+  # Updates just the current_editor timestamps
+  def force_edit
+    if variant = @article.variants.find_by_id(params[:id])
+      variant.edit_by!(current_user, :force => true)
+      if request.xhr?
+        render(:update){|p| p.redirect_to edit_skyline_article_path(@article,:variant_id => variant)}
+      else
+        redirect_to edit_skyline_article_path(@article,:variant_id => variant)
+      end
+    end
+  end
+  
+  
+  hide_action :article  
+  def article
+    @article
+  end
+  
+  protected
+  
+  def find_article
+    @article = Skyline::Article.find_by_id(params[:article_id])
+    return redirect_to(skyline_articles_path(:type => params[:article_type])) unless @article
+    return handle_unauthorized_user unless @article.editable_by?(current_user)
+  end
+end

data/app/helpers/skyline/application_helper.rb

@@ -0,0 +1,82 @@
+module Skyline::ApplicationHelper  
+  # Place a tick or a cross depending on the value of bool
+  #
+  # ==== Parameters
+  # bool<Boolean>:: The value of the tick/cross
+  # options<Hash>:: Options will be passed to the image_tag method
+  # 
+  # --
+  def tick_image(bool,options={})
+    name = bool ? "true" : "false"
+    src = "/skyline/images/icons/#{name}.gif"
+    
+    options.reverse_merge! :alt => t(name, :scope => [:icons]) 
+    
+    image_tag(src,options)
+  end
+  
+  # You can use this method to place a message directly in your view. This also
+  # works directly from a render(:update) or an update_page block. 
+  # 
+  # ==== Parameters
+  # type<Symbol>:: The type of the message (:error,:notification,:success)
+  # message<String>:: The message to show
+  # optiosn<Hash>:: Options to be passed to the MessageGenerator (javascript)
+  #
+  # --
+  def message(type,message,options={})
+    MessageGenerator.new(type,message,options)
+  end
+
+  # You can use this method to place a notification directly in your view. This also
+  # works directly from a render(:update) or an update_page block. 
+  # 
+  # ==== Parameters
+  # type<Symbol>:: The type of the message (:error,:notification,:success)
+  # message<String>:: The message to show
+  # optiosn<Hash>:: Options to be passed to the MessageGenerator (javascript)
+  #
+  # --  
+  def notification(type,message,options={})
+    MessageGenerator.new(type,message,options)    
+  end
+  
+  def render_messages(options={})
+    _render_volatiles(self.messages,options)
+  end
+  
+  def render_notifications(options={})
+    _render_volatiles(self.notifications,options)
+  end
+  
+  def plugin_hook(name)
+    template = caller.first[/app\/views\/([^:]*):/,1]
+    raise "Cannot determine template from caller: #{caller}" unless template
+    plugin_template = template.sub(".html.erb", "_#{name}.html.erb")
+    
+    logger.debug "Looking for template #{plugin_template} in plugins..."
+    Dir[Rails.root + "vendor/skyline_plugins/*/app/views/#{plugin_template}"].each do |file|      
+      if RAILS_ENV == "development"
+        concat render(:inline => File.read(file), :layout => nil)
+      else
+        # render :file caches the file somehow, so only use it in production mode
+        concat render(:file => file, :layout => nil)
+      end
+    end    
+  end
+  
+  protected
+  
+  def _render_volatiles(messages_hash, options={})
+    return "" unless messages_hash.any?
+    options.reverse_merge! :generator => Skyline::MessageGenerator
+    generator = options.delete(:generator)
+    out = messages_hash.inject([]) do |acc,v|
+      type,messages = v[0],[v[1]].flatten
+      msg_options = messages.extract_options!
+      msg_options.reverse_merge! options
+      acc += messages.map{|msg| generator.new(type,msg,msg_options) }
+    end
+    javascript_tag out.join("\n")    
+  end
+end

data/app/helpers/skyline/button_helper.rb

@@ -0,0 +1,77 @@
+module Skyline::ButtonHelper
+  
+  def menu_button(title, options={}, &block)
+    options.reverse_merge! :id => Guid.new
+    
+    contents = capture(&block)
+    
+    concat <<-EOS
+    <dl class="menubutton" id="#{options[:id]}">
+      <dt>
+        <span class="label">#{title}</span>
+        <a class="toggle" href="#"><span><span>down</span></span></a>
+      </dt>
+      <dd>
+        #{contents}
+      </dd>
+    </dl>
+    <script type="text/javascript" charset="utf-8">
+      new Skyline.MenuButton('#{options[:id]}')
+    </script>
+    EOS
+  end
+  
+  # Translates the key if it's a symbol otherwise just places key
+  # --
+  def button_text(key)
+    key.kind_of?(Symbol) ? t(key, :scope => :buttons) : key
+  end
+  
+  # Places a <button type="submit">..</button> tag
+  #
+  # ==== Parameters
+  # src :: The location of the image relative to the locale directory
+  # options :: Options to pass through to content_tag
+  #
+  # ==== Options
+  # :value :: If value is a symbol, it will be translated in scope buttons
+  # --
+  def submit_button(label,options={})
+    convert_boolean_attributes!(options, %w( disabled ))
+    
+    options.reverse_merge! :type => "submit"
+    content_tag("button", button_text(label) ,options)
+  end
+  
+  def submit_button_to(label,options={},html_options={})
+    
+    html_options = html_options.stringify_keys
+    disabled = html_options[:disabled]
+    convert_boolean_attributes!(html_options, %w( disabled ))
+    
+    method_tag = ''
+    if (method = html_options.delete('method')) && %w{put delete}.include?(method.to_s)
+      method_tag = tag('input', :type => 'hidden', :name => '_method', :value => method.to_s)
+    end
+    
+    form_method = method.to_s == 'get' ? 'get' : 'post'
+    
+    request_token_tag = ''
+    if form_method == 'post' && protect_against_forgery?
+      request_token_tag = tag(:input, :type => "hidden", :name => request_forgery_protection_token.to_s, :value => form_authenticity_token)
+    end
+    
+    if confirm = html_options.delete("confirm")
+      html_options["onclick"] = "return #{confirm_javascript_function(confirm)};"
+    end
+    
+    url = options.is_a?(String) ? options : self.url_for(options)
+    name ||= url
+    
+    html_options.reverse_merge! :type => "submit"
+    
+    "<form method=\"#{form_method}\" action=\"#{escape_once url}\" class=\"button-to\"><div>" +
+      method_tag + content_tag("button", button_text(label) ,html_options) + request_token_tag + "</div></form>"    
+  end
+  
+end

data/app/helpers/skyline/content_helper.rb

@@ -0,0 +1,160 @@
+# @private
+module Skyline::ContentHelper
+
+  # We need some preconditions to make automatic breadcrumbs work
+  # 1. The last part is never clickable
+  # 2. The part before last will be params[:return_to] if it's available
+  # 3. Only lists will appear in the breadcrumb as links (unless there is return_to)
+  def content_breadcrumb(stack)
+    links = []
+    return nil if stack.blank?
+    types = stack.types.dup
+    
+    if types.last.last.nil?
+      last = types.pop
+    end
+    
+    types.each_with_index do |type,i|
+      links << link_to(label_for(type), :action => "list", :types => stack.url_types(:up => (stack.types.size - i -1), :collection => true))
+      links << "<span>#{stack.object_for_type(type).human_id}</span>"
+    end
+    
+    links << "<span>#{label_for(last)}</span>" if last
+    
+    content_tag("div","#{t(:breadcrumb_prefix, :scope => :content)} " + links.join(" &raquo; "),:id => "breadcrumb")    
+  end
+  
+  def label_for(type)
+    obj = stack.object_for_type(type)
+    obj.class.plural_name
+  end
+  
+  def content_save_form(record_name,options={},&block)
+    record = instance_variable_get("@#{record_name}")
+    
+    options.symbolize_keys!
+    options.reverse_merge! :action => record.new_record? ? "create" : "edit"
+    
+    if record.class.publishable? || record.class.writable_fields.any?
+    else
+      
+    end
+    
+  end
+  
+  def url_options_for_record(record,options={})
+    options.symbolize_keys!
+    defaults = {}
+    defaults[:action] = (record.new_record? ? "create" : "edit")
+        
+    # Return to after save determination
+    if record.class.settings.return_to_self_after_save
+      defaults[:return_to] = "self"
+    elsif params[:return_to]
+      defaults[:return_to] = params[:return_to]
+    end
+    
+    options.reverse_merge defaults
+  end
+  
+  def content_form(record_name, options = {},&block)
+    record = instance_variable_get("@#{record_name}")
+    
+    options = options.symbolize_keys
+    url_options = url_options_for_record(record, {:action => options[:action]})
+    
+    contents = ''
+    contents << content_fields(record.class,record_name, record)
+    
+    contents << capture(&block) if block_given?
+		            
+    if record.class.publishable? || record.class.writable_fields.any?
+      contents << hidden_field_tag(:authenticity_token, form_authenticity_token)
+#      contents << hidden_field(record_name, :id) unless record.new_record?
+      contents << hidden_field_tag(:version,record.current_version)
+      
+      output = content_tag('form', contents, :id => "contentform", :action => object_url(record,url_options), :method => 'post', :enctype => options[:multipart] ? 'multipart/form-data': nil)
+               
+    else
+      output = content_tag('div', contents, :id => "contentform")
+    end
+    
+
+    # Postponed editors are editors like inline_list that should not be in the form but provide their own form/list
+    # functionality.
+    output << postponed_editors.map(&:output).join("\n") if postponed_editors.any?
+    
+    concat output
+  end  
+
+  def content_fields(fieldset,record_name, record)
+    out = ""
+
+    fieldset.each_field do |field|
+      next if (field.hidden_in(:edit) && !record.new_record?) || 
+              (field.hidden_in(:create) && record.new_record?)
+
+      case field
+        when Skyline::Content::MetaData::Field
+          out << content_field(fieldset, record_name, field, record) + "\n"
+        when Skyline::Content::MetaData::FieldGroup
+          out <<  render(:partial => "skyline/content/group", :locals => {:title => field.singular_title, :content => content_fields(field, record_name, record)})
+      end
+    end
+    out
+  end  
+  
+  def content_field(fieldset,record_name,field, record)
+    e = Skyline::Editors::Editor.create(field,[record_name],record,@template)
+    if e.postpone?
+      postponed_editors << e
+      ""
+    else
+      e.output
+    end
+  end
+
+  # Outputs an object list with the right presenter
+  # defaults to Table currently.
+  def presenter_for(records,fieldset)
+    Skyline::Presenters::Presenter.create(fieldset.settings.presenter,records,fieldset,@template).output
+  end
+  
+  # Postponed editors are editors like inline_list that should not be in the form but provide their own form/list
+  # functionality.  
+  def postponed_editors
+    @_postponed_editors ||= []
+  end
+    
+  def boolean_field(tag_name, record, field, options = {})
+    hidden_field_tag(tag_name, "0") + 
+    record_with_errors(
+      check_box_tag(tag_name, "1" , field.value(record), options),
+      record,
+      field)
+  end
+  
+  def record_with_errors(content, record, field)
+    if record.errors.on(field.attribute_name) 
+      content_tag("div", content, :class => "fieldWithErrors")
+    else
+      content
+    end
+  end
+   
+  def asset_url(path)
+    File.join(@implementation.assets_url.to_s, path.to_s)
+  end
+
+  def input_name(*parts)
+    parts = parts.flatten.compact.collect{|p| p.to_s}
+    name = parts.shift.dup
+    name << "[" + parts.join("][") + "]" unless parts.empty?
+    name
+  end 
+  
+  def input_id(*parts)
+    parts.flatten.compact.collect{|p| p.to_s}.join("_")
+  end  
+  
+end

data/app/helpers/skyline/dialog_helper.rb

@@ -0,0 +1,30 @@
+module Skyline::DialogHelper
+  
+  def dialog(title,*args,&block)   
+    options_for_render = args.extract_options!
+    options_for_render.reverse_merge! :width => "auto", :height => "auto"
+    
+    if args.any?
+      content = args.last 
+      options = options_for_render
+    else
+      options = options_for_render.slice!(:partial, :locals)
+      options.each do |k,v|
+        options[k] = case v
+          when String,Symbol : "'" + escape_javascript(v.to_s) + "'"
+          when Hash : options_for_javascript(v)
+          else v
+        end
+      end      
+      content = render(options_for_render)
+    end
+    
+    p =  "var s = function(){"
+    p << "var sd = new Skyline.Dialog(#{options_for_javascript(options)});"
+    p << "sd.setTitle('#{escape_javascript(title)}');"
+    p << "sd.setContent('#{escape_javascript(content)}');"
+    p << "sd.setup(); sd.show();"
+    p << "}()"
+  end
+  
+end

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

@@ -0,0 +1,6 @@
+class Skyline::Editors::Boolean < Skyline::Editors::Editor
+  def output_without_errors
+    check_box_tag(input_name(self.attribute_names), "1" , field.value(record)) +
+    hidden_field_tag(input_name(self.attribute_names), "0") + " " + field.singular_label   
+  end
+end

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

@@ -0,0 +1,54 @@
+class Skyline::Editors::CheckableList < Skyline::Editors::Editor
+  attr_reader :target_class
+  
+  def initialize(names,record,field,template)
+    super
+    
+    reflection = self.field.reflection
+    if reflection.macro == :has_and_belongs_to_many
+      @target_class = reflection.klass
+    else
+      raise "CheckableList can only be used with HABTM associations (was: #{@reflection.macro})"
+    end
+  end
+    
+  def output_without_errors
+    content_tag("div",
+      content_tag("ul",self.render_records),
+    :class => "checkable-list")
+  end
+  
+  protected
+  
+  def render_records
+    collection = @target_class.all
+    if collection.any?
+      collection.collect{|record| render_record(record)}.join("\n")
+    else
+      t(:blank, :scope => [:content,:editors, :checkable_list], :class => @target_class.plural_name.downcase)
+    end
+  end
+  
+  def render_record(row)
+    proxy_id = random_prefix(row)
+    
+    check_box = check_box_tag(input_name(self.attribute_names + [proxy_id,"_target_id"]), row.id, field.value(record).include?(row), :id => input_id(self.attribute_names + [proxy_id,"_target_id"]))
+    label = label_tag(input_name(self.attribute_names + [proxy_id,"_target_id"]), title_for(row))
+
+    content_tag("li", check_box + label, :class => "#{cycle("odd","even")}", :id => row_id(proxy_id))
+  end
+  
+  def random_prefix(row)
+    "n_" + row.id.to_s + "_n" + Time.now.to_i.to_s + Time.now.usec.to_s 
+  end
+  
+  def row_id(id)
+    input_id(self.attribute_names) + "_#{id}"
+  end
+    
+  def title_for(record)
+    raise "Must have title_field defined in settings for #{target_class}" unless tf = target_class.settings.title_field
+    raise "Title field #{tf} is not defined as field for #{target_class}" unless f = target_class.fields[tf]
+    f.value(record)
+  end  
+end    

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

@@ -0,0 +1,15 @@
+module Skyline::Editors
+  class Date < Editor
+    def output_without_errors
+      value = field.value(record)
+      value ||= ::Date.today
+      
+      year_options = field.year_options || {}
+      year_options.merge!({:field_name => "#{field.attribute_name}(1i)", :prefix => input_name(self.attribute_names[0..-2])})
+      
+      select_day(value, :field_name => "#{field.attribute_name}(3i)", :prefix => input_name(self.attribute_names[0..-2])) + 
+      select_month(value, :field_name => "#{field.attribute_name}(2i)", :prefix => input_name(self.attribute_names[0..-2])) + 
+      select_year(value, year_options)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+class Skyline::Editors::DateTime < Skyline::Editors::Editor
+  def output_without_errors
+    value = field.value(record)
+    value ||= Time.now
+    select_day(value, :field_name => "#{field.attribute_name}(3i)", :prefix => input_name(self.attribute_names[0..-2])) + 
+    select_month(value, :field_name => "#{field.attribute_name}(2i)", :prefix => input_name(self.attribute_names[0..-2])) + 
+    select_year(value, :field_name => "#{field.attribute_name}(1i)", :prefix => input_name(self.attribute_names[0..-2])) + " &mdash; " +
+    select_hour(value, :field_name => "#{field.attribute_name}(4i)", :prefix => input_name(self.attribute_names[0..-2])) + " : " +
+    select_minute(value, :field_name => "#{field.attribute_name}(5i)", :prefix => input_name(self.attribute_names[0..-2]))
+  end
+end

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

@@ -0,0 +1,12 @@
+class Skyline::Editors::Display < Skyline::Editors::Editor
+  def output
+    heading.to_s + (self.value || l(:content,:editors,:display,:empty))
+  end
+  
+  def value
+    case value = field.value(record)
+      when Date,Time : value.to_formatted_s(:long)
+      else value
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+class Skyline::Editors::EditableList < Skyline::Editors::Editor
+
+  attr_reader :target_class, :reflection
+  
+  def initialize(names,record,field,template)
+    super
+#    @attribute_names[-1] = "skyline_#{@attribute_names[-1]}"
+    
+    @reflection = self.field.reflection
+    if @reflection.macro == :has_many
+      @target_class = reflection.klass
+    else
+      raise "EditableList can only be used with has_many associations (was: #{@reflection.macro})"
+    end
+  end
+  
+  def output_without_errors
+    out = ""
+    out << content_tag("ul",self.rows.join("\n"),:class => "editable-list", :id => js_object_name)
+    out << content_tag("div",add_new_link, :class => "add", :id => "#{js_object_name}_add")
+    out << hidden_field_tag(input_name(self.attribute_names << "-1"),"0")
+  end  
+  
+  def render_row(row)
+    field_id = row.new_record? ? random_prefix(row) : row.id
+    
+    edit = ""
+    edit << delete_button(field_id)
+    
+    header = content_tag("div",edit,:class => "tools")
+    header << "#{@target_class.singular_name} #{row.human_id}"
+    
+    out = ""
+    out << content_tag("div",header,:class => "head")
+    fields = content_fields(row.class,(self.attribute_names + [field_id]),row)
+    out << content_tag("div",fields,:class => "body") unless fields.blank?
+    content_tag("li",content_tag("div",out,:class => "section"),:id => row_id(field_id),:class => "#{cycle("odd","even")} element")
+  end  
+  
+  def js_object_name
+    "editable_list_#{input_id(self.attribute_names)}"
+  end  
+  
+  
+  protected
+  
+  def add_new_link
+    link_to_remote(t(:add_more, :scope => [:content], :class => @target_class.plural_name), {
+      :url => {:controller => "skyline/content/editors/editable_list", 
+               :action => "new", 
+               :source_type => self.record.class.to_s.demodulize.underscore, 
+               :source_id => self.record,
+               :association => self.field},
+			:loading => "Application.toggleSpin('#{js_object_name}_add','#{t(:loading, :scope => [:global])}')",
+			:complete => "Application.toggleSpin('#{js_object_name}_add')" 
+    }, :class => "add")
+  end
+  
+  
+  def random_prefix(row)
+    "n_" + row.id.to_s + "_n" + Time.now.to_i.to_s + Time.now.usec.to_s 
+  end  
+  
+  def records
+    @records ||= record.send(field.name)
+  end
+    
+  def row_id(id)
+    input_id(self.attribute_names) + "_#{id}"
+  end  
+  
+  def rows
+    records.collect{|row| render_row(row)}
+  end  
+
+  def delete_button(row_id)
+    link_to_function image_tag("/skyline/images/buttons/section-delete.gif", :alt => "remove"), 
+                   "$('#{row_id(row_id)}').dispose();"
+  end
+
+end