typus 0.9.17

data/app/helpers/admin/master_helper.rb

@@ -0,0 +1,104 @@
+module Admin::MasterHelper
+
+  include TypusHelper
+
+  include Admin::SidebarHelper
+  include Admin::FormHelper
+  include Admin::TableHelper
+
+  def display_link_to_previous # (_params = params)
+
+    options = {}
+    options[:resource_from] = @resource[:class].typus_human_name
+    options[:resource_to] = params[:resource].classify.humanize if params[:resource]
+
+    editing = %w( edit update ).include?(params[:action])
+
+    message = case
+              when params[:resource] && editing
+                _("You're updating a {{resource_from}} for {{resource_to}}.", 
+                  :resource_from =>  options[:resource_from], 
+                  :resource_to => options[:resource_to])
+              when editing
+                _("You're updating a {{resource_from}}.", 
+                  :resource_from => options[:resource_from])
+              when params[:resource]
+                _("You're adding a new {{resource_from}} to {{resource_to}}.", 
+                  :resource_from => options[:resource_from], 
+                  :resource_to => options[:resource_to])
+              else
+                _("You're adding a new {{resource_from}}.", 
+                  :resource_from => options[:resource_from] )
+              end
+
+    returning(String.new) do |html|
+      html << <<-HTML
+<div id="flash" class="notice">
+  <p>#{message} #{link_to _("Do you want to cancel it?"), params[:back_to]}</p>
+</div>
+      HTML
+    end
+
+  end
+
+  def remove_filter_link(filter = request.env['QUERY_STRING'])
+    return unless filter && !filter.blank?
+    <<-HTML
+<small>#{link_to _("Remove filter")}</small>
+    HTML
+  end
+
+  ##
+  # If there's a partial with a "microformat" of the data we want to 
+  # display, this will be used, otherwise we use a default table which 
+  # it's build from the options defined on the yaml configuration file.
+  #
+  def build_list(model, fields, items, resource = @resource[:self], link_options = {}, association = nil)
+
+    template = "app/views/admin/#{resource}/_#{resource.singularize}.html.erb"
+
+    if File.exist?(template)
+      render :partial => template.gsub('/_', '/'), :collection => items, :as => :item
+    else
+      build_typus_table(model, fields, items, link_options, association)
+    end
+
+  end
+
+  def pagination(*args)
+    @options = args.extract_options!
+    render 'admin/shared/pagination' if @items.prev || @items.next
+  end
+
+  ##
+  # Simple and clean pagination links
+  #
+  def build_pagination(pager, options = {})
+
+    options[:link_to_current_page] ||= true
+    options[:always_show_anchors] ||= true
+
+    # Calculate the window start and end pages
+    options[:padding] ||= 2
+    options[:padding] = options[:padding] < 0 ? 0 : options[:padding]
+
+    page = params[:page].blank? ? 1 : params[:page].to_i
+    current_page = pager.page(page)
+
+    first = pager.first.number <= (current_page.number - options[:padding]) && pager.last.number >= (current_page.number - options[:padding]) ? current_page.number - options[:padding] : 1
+    last = pager.first.number <= (current_page.number + options[:padding]) && pager.last.number >= (current_page.number + options[:padding]) ? current_page.number + options[:padding] : pager.last.number
+
+    returning(String.new) do |html|
+      # Print start page if anchors are enabled
+      html << yield(1) if options[:always_show_anchors] and not first == 1
+      # Print window pages
+      first.upto(last) do |page|
+        (current_page.number == page && !options[:link_to_current_page]) ? html << page.to_s : html << (yield(page)).to_s
+      end
+      # Print end page if anchors are enabled
+      html << yield(pager.last.number).to_s if options[:always_show_anchors] and not last == pager.last.number
+    end
+
+  end
+
+end

data/app/helpers/admin/public_helper.rb

@@ -0,0 +1,27 @@
+module Admin
+
+  module PublicHelper
+
+    ##
+    # Quick edit usage:
+    #
+    #     <%= quick_edit(:message => "Edit this article", :path => "articles/edit/#{@article.id}") %>
+    #
+    # If user is logged in Typus, a link will appear on the top/right of 
+    # the pages where you insert this helper.
+    #
+    def quick_edit(*args)
+
+      options = args.extract_options!
+
+      <<-HTML
+<script type="text/javascript">
+  document.write('<script type="text/javascript" src="#{admin_quick_edit_path}?#{options.to_query}" />');
+</script>
+      HTML
+
+    end
+
+  end
+
+end

data/app/helpers/admin/sidebar_helper.rb

@@ -0,0 +1,236 @@
+module Admin::SidebarHelper
+
+  def actions
+
+    returning(String.new) do |html|
+
+      html << <<-HTML
+#{build_typus_list(default_actions, :header => 'actions')}
+#{build_typus_list(previous_and_next, :header => 'go_to')}
+      HTML
+
+      html << <<-HTML
+#{build_typus_list(export, :header => 'export')}
+      HTML
+
+    end
+
+  end
+
+  def default_actions
+
+    items = []
+
+    case params[:action]
+    when 'index', 'edit', 'show', 'update'
+      if @current_user.can_perform?(@resource[:class], 'create')
+        items << (link_to _("Add entry"), :action => 'new')
+      end
+    end
+
+    case params[:action]
+    when 'show'
+      if @current_user.can_perform?(@resource[:class], 'update')
+        items << (link_to _("Edit entry"), :action => 'edit', :id => @item.id)
+      end
+    end
+
+    @resource[:class].typus_actions_for(params[:action]).each do |action|
+      if @current_user.can_perform?(@resource[:class], action)
+        items << (link_to _(action.humanize), params.merge(:action => action))
+      end
+    end
+
+    case params[:action]
+    when 'new', 'create', 'edit', 'show', 'update'
+      items << (link_to _("Back to list"), :action => 'index')
+    end
+
+    return items
+
+  end
+
+  def export
+    return [] unless params[:action] == 'index'
+    returning(Array.new) do |format|
+      @resource[:class].typus_export_formats.each do |f|
+        format << (link_to f.upcase, params.merge(:format => f))
+      end
+    end
+  end
+
+  def build_typus_list(items, *args)
+
+    options = args.extract_options!
+
+    header = if options[:header]
+               _(options[:header].humanize)
+             elsif options[:attribute]
+               @resource[:class].human_attribute_name(options[:attribute])
+             end
+
+    return String.new if items.empty?
+    returning(String.new) do |html|
+      html << "<h2>#{header}</h2>\n" unless header.nil?
+      next unless options[:selector].nil?
+      html << "<ul>\n"
+      items.each do |item|
+        html << "<li>#{item}</li>\n"
+      end
+      html << "</ul>\n"
+    end
+
+  end
+
+  def previous_and_next
+    return [] unless %w( edit show update ).include?(params[:action])
+    returning(Array.new) do |items|
+      items << (link_to _("Next"), params.merge(:id => @next.id)) if @next
+      items << (link_to _("Previous"), params.merge(:id => @previous.id)) if @previous
+    end
+  end
+
+  def search
+
+    typus_search = @resource[:class].typus_defaults_for(:search)
+    return if typus_search.empty?
+
+    search_by = typus_search.collect { |x| @resource[:class].human_attribute_name(x) }.to_sentence
+
+    search_params = params.dup
+    %w( action controller search page ).each { |p| search_params.delete(p) }
+
+    hidden_params = search_params.map { |key, value| hidden_field_tag(key, value) }
+
+    <<-HTML
+<h2>#{_("Search")}</h2>
+<form action="" method="get">
+<p><input id="search" name="search" type="text" value="#{params[:search]}"/></p>
+#{hidden_params.sort.join("\n")}
+</form>
+<p class="tip">#{_("Search by")} #{search_by.downcase}.</p>
+    HTML
+
+  end
+
+  def filters
+
+    typus_filters = @resource[:class].typus_filters
+    return if typus_filters.empty?
+
+    current_request = request.env['QUERY_STRING'] || []
+
+    returning(String.new) do |html|
+      typus_filters.each do |key, value|
+        case value
+        when :boolean then      html << boolean_filter(current_request, key)
+        when :string then       html << string_filter(current_request, key)
+        when :datetime then     html << datetime_filter(current_request, key)
+        when :belongs_to then   html << relationship_filter(current_request, key)
+        when :has_and_belongs_to_many then
+          html << relationship_filter(current_request, key, true)
+        else
+          html << "<p>#{_("Unknown")}</p>"
+        end
+      end
+    end
+
+  end
+
+  def relationship_filter(request, filter, habtm = false)
+
+    model = (habtm) ? filter.classify.constantize : filter.capitalize.camelize.constantize
+    related_fk = (habtm) ? filter : @resource[:class].reflect_on_association(filter.to_sym).primary_key_name
+
+    params_without_filter = params.dup
+    %w( controller action page ).each { |p| params_without_filter.delete(p) }
+    params_without_filter.delete(related_fk)
+
+    items = []
+
+    returning(String.new) do |html|
+      related_items = model.find(:all, :order => model.typus_order_by)
+      if related_items.size > model.typus_options_for(:sidebar_selector)
+        related_items.each do |item|
+          switch = request.include?("#{related_fk}=#{item.id}") ? 'selected' : ''
+          items << <<-HTML
+<option #{switch} value="#{url_for params.merge(related_fk => item.id, :page => nil)}">#{item.typus_name}</option>
+          HTML
+        end
+        model_pluralized = model.name.downcase.pluralize
+        form = <<-HTML
+<!-- Embedded JS -->
+<script>
+function surfto_#{model_pluralized}(form) {
+  var myindex = form.#{model_pluralized}.selectedIndex
+  if (form.#{model_pluralized}.options[myindex].value != "0") {
+    top.location.href = form.#{model_pluralized}.options[myindex].value;
+  }
+}
+</script>
+<!-- /Embedded JS -->
+<form class="form" action="#"><p>
+  <select name="#{model_pluralized}" onChange="surfto_#{model_pluralized}(this.form)">
+    <option value="#{url_for params_without_filter}">#{_("filter by")} #{_(model.typus_human_name)}</option>
+    #{items.join("\n")}
+  </select>
+</p></form>
+        HTML
+      else
+        related_items.each do |item|
+          switch = request.include?("#{related_fk}=#{item.id}") ? 'on' : 'off'
+          items << (link_to item.typus_name, params.merge(related_fk => item.id, :page => nil), :class => switch)
+        end
+      end
+
+      if form
+        html << build_typus_list(items, :attribute => filter, :selector => true)
+        html << form
+      else
+        html << build_typus_list(items, :attribute => filter)
+      end
+
+    end
+
+  end
+
+  ##
+  # Thinking in update datetime_filters to ...
+  #
+  #     %w( today last_few_days last_7_days last_30_days )
+  #
+  # ... which are the ones used by 'exception_logger'.
+  #
+  def datetime_filter(request, filter)
+    items = []
+    %w( today past_7_days this_month this_year ).each do |timeline|
+      switch = request.include?("#{filter}=#{timeline}") ? 'on' : 'off'
+      options = { filter.to_sym => timeline, :page => nil }
+      items << (link_to _(timeline.humanize), params.merge(options), :class => switch)
+    end
+    build_typus_list(items, :attribute => filter)
+  end
+
+  def boolean_filter(request, filter)
+    items = []
+    @resource[:class].typus_boolean(filter).each do |key, value|
+      switch = request.include?("#{filter}=#{key}") ? 'on' : 'off'
+      options = { filter.to_sym => key, :page => nil }
+      items << (link_to _(value), params.merge(options), :class => switch)
+    end
+    build_typus_list(items, :attribute => filter)
+  end
+
+  def string_filter(request, filter)
+    values = @resource[:class].send(filter)
+    items = []
+    values.each do |item|
+      link_name, link_filter = (values.first.kind_of?(Array)) ? [ item.first, item.last ] : [ item, item ]
+      switch = request.include?("#{filter}=#{link_filter}") ? 'on' : 'off'
+      options = { filter.to_sym => link_filter, :page => nil }
+      items << (link_to link_name.capitalize, params.merge(options), :class => switch)
+    end
+    build_typus_list(items, :attribute => filter)
+  end
+
+end

data/app/helpers/admin/table_helper.rb

@@ -0,0 +1,227 @@
+module Admin::TableHelper
+
+  def build_typus_table(model, fields, items, link_options = {}, association = nil)
+
+    returning(String.new) do |html|
+
+      html << <<-HTML
+<table class="typus">
+      HTML
+
+      html << typus_table_header(model, fields)
+
+      items.each do |item|
+
+        html << <<-HTML
+<tr class="#{cycle('even', 'odd')}" id="item_#{item.id}">
+        HTML
+
+        fields.each do |key, value|
+          case value
+          when :boolean then           html << typus_table_boolean_field(key, item)
+          when :datetime then          html << typus_table_datetime_field(key, item, fields.keys.first, link_options)
+          when :date then              html << typus_table_datetime_field(key, item, fields.keys.first, link_options)
+          when :time then              html << typus_table_datetime_field(key, item, fields.keys.first, link_options)
+          when :belongs_to then        html << typus_table_belongs_to_field(key, item)
+          when :tree then              html << typus_table_tree_field(key, item)
+          when :position then          html << typus_table_position_field(key, item)
+          when :has_and_belongs_to_many then
+            html << typus_table_has_and_belongs_to_many_field(key, item)
+          else
+            html << typus_table_string_field(key, item, fields.keys.first, link_options)
+          end
+        end
+
+      ##
+      # This controls the action to perform. If we are on a model list we 
+      # will remove the entry, but if we inside a model we will remove the 
+      # relationship between the models.
+      #
+      # Only shown is the user can destroy items.
+      #
+
+      if @current_user.can_perform?(model, 'delete')
+
+        case params[:action]
+        when 'index'
+          perform = link_to image_tag('admin/trash.gif'), { :action => 'destroy', 
+                                                            :id => item.id }, 
+                                                            :confirm => _("Remove entry?"), 
+                                                            :method => :delete
+        else
+          perform = link_to image_tag('admin/trash.gif'), { :action => 'unrelate', 
+                                                            :id => params[:id], 
+                                                            :association => association, 
+                                                            :resource => model, 
+                                                            :resource_id => item.id }, 
+                                                            :confirm => _("Unrelate {{unrelate_model}} from {{unrelate_model_from}}?", 
+                                                                          :unrelate_model => model.typus_human_name, 
+                                                                          :unrelate_model_from => @resource[:class].typus_human_name)
+        end
+
+        html << <<-HTML
+<td width="10px">#{perform}</td>
+        HTML
+
+      end
+
+      html << <<-HTML
+</tr>
+      HTML
+
+    end
+
+      html << "</table>"
+
+    end
+
+  end
+
+  ##
+  # Header of the table
+  #
+  def typus_table_header(model, fields)
+    returning(String.new) do |html|
+      headers = []
+      fields.each do |key, value|
+
+        content = model.human_attribute_name(key)
+        content += " (#{key})" if key.include?('_id')
+
+        if (model.model_fields.map(&:first).collect { |i| i.to_s }.include?(key) || model.reflect_on_all_associations(:belongs_to).map(&:name).include?(key.to_sym)) && params[:action] == 'index'
+          sort_order = case params[:sort_order]
+                       when 'asc' then  'desc'
+                       when 'desc' then 'asc'
+                       end
+          order_by = model.reflect_on_association(key.to_sym).primary_key_name rescue key
+          switch = (params[:order_by] == key) ? sort_order : ''
+          options = { :order_by => order_by, :sort_order => sort_order }
+          content = (link_to "<div class=\"#{switch}\">#{content}</div>", params.merge(options))
+        end
+
+        headers << "<th>#{content}</th>"
+
+      end
+      headers << "<th>&nbsp;</th>" if @current_user.can_perform?(model, 'delete')
+      html << <<-HTML
+<tr>
+#{headers.join("\n")}
+</tr>
+      HTML
+    end
+  end
+
+  def typus_table_belongs_to_field(attribute, item)
+
+    action = item.send(attribute).class.typus_options_for(:default_action_on_item) rescue 'edit'
+
+    content = if !item.send(attribute).kind_of?(NilClass)
+                link_to item.send(attribute).typus_name, :controller => "admin/#{attribute.pluralize}", :action => action, :id => item.send(attribute).id
+              end
+
+    <<-HTML
+<td>#{content}</td>
+    HTML
+
+  end
+
+  def typus_table_has_and_belongs_to_many_field(attribute, item)
+    <<-HTML
+<td>#{item.send(attribute).map { |i| i.typus_name }.join('<br />')}</td>
+    HTML
+  end
+
+  ##
+  # When detection of the attributes is made a default attribute 
+  # type is set. From the string_field we display other content 
+  # types.
+  #
+  def typus_table_string_field(attribute, item, first_field, link_options = {})
+
+    action = item.class.typus_options_for(:default_action_on_item)
+
+    content = if first_field == attribute
+                link_to item.send(attribute) || item.class.typus_options_for(:nil), link_options.merge(:controller => "admin/#{item.class.name.tableize}", :action => action, :id => item.id)
+              else
+                item.send(attribute)
+              end
+    <<-HTML
+<td>#{content}</td>
+    HTML
+  end
+
+  def typus_table_tree_field(attribute, item)
+    <<-HTML
+<td>#{item.parent.typus_name if item.parent}</td>
+    HTML
+  end
+
+  def typus_table_position_field(attribute, item)
+
+    html_position = []
+
+    [['Up', 'move_higher'], ['Down', 'move_lower']].each do |position|
+
+      options = { :controller => item.class.name.tableize, 
+                  :action => 'position', 
+                  :id => item.id, 
+                  :go => position.last }
+
+      html_position << <<-HTML
+#{link_to _(position.first), params.merge(options)}
+      HTML
+
+    end
+
+    <<-HTML
+<td>#{html_position.join('/ ')}</td>
+    HTML
+
+  end
+
+  def typus_table_datetime_field(attribute, item, first_field = nil, link_options = {} )
+
+    action = item.class.typus_options_for(:default_action_on_item)
+
+    date_format = item.class.typus_date_format(attribute)
+    value = !item.send(attribute).nil? ? item.send(attribute).to_s(date_format) : item.class.typus_options_for(:nil)
+    content = if first_field == attribute
+                link_to value, link_options.merge(:controller => "admin/#{item.class.name.tableize}", :action => action, :id => item.id )
+              else
+                value
+              end
+
+    <<-HTML
+<td>#{content}</td>
+    HTML
+
+  end
+
+  def typus_table_boolean_field(attribute, item)
+
+    boolean_icon = item.class.typus_options_for(:icon_on_boolean)
+    boolean_hash = item.class.typus_boolean(attribute)
+
+    status = item.send(attribute)
+
+    link_text = unless item.send(attribute).nil?
+                  (boolean_icon) ? image_tag("admin/status_#{status}.gif") : boolean_hash["#{status}".to_sym]
+                else
+                  item.class.typus_options_for(:nil) # Content is nil, so we show nil.
+                end
+
+    options = { :controller => item.class.name.tableize, :action => 'toggle', :field => attribute.gsub(/\?$/,''), :id => item.id }
+
+    content = if item.class.typus_options_for(:toggle) && !item.send(attribute).nil?
+                link_to link_text, params.merge(options), :confirm => _("Change {{attribute}}?", :attribute => item.class.human_attribute_name(attribute).downcase)
+              else
+                link_text
+              end
+
+    <<-HTML
+<td align="center">#{content}</td>
+    HTML
+
+  end
+
+end