typus 3.0.2 → 3.0.4

data/app/helpers/admin/relationships_helper.rb

@@ -4,23 +4,28 @@ module Admin
 
     def setup_relationship(field)
       @field = field
-      @model_to_relate = @resource.reflect_on_association(field.to_sym).class_name.constantize
+      @model_to_relate = @resource.reflect_on_association(field.to_sym).class_name.typus_constantize
       @model_to_relate_as_resource = @model_to_relate.to_resource
       @reflection = @resource.reflect_on_association(field.to_sym)
-      @association = @reflection.macro
+      @association_name = @reflection.through_reflection ? @reflection.name.to_s : @model_to_relate.model_name.tableize
     end
 
     def typus_form_has_many(field)
-
       setup_relationship(field)
+      if @reflection.through_reflection
+        @items_to_relate = @model_to_relate.all - @item.send(field)
+      else
+        @items_to_relate = @model_to_relate.where(@reflection.primary_key_name => nil) - @item.send(field)
+      end
 
-      foreign_key = @reflection.through_reflection ? @reflection.primary_key_name.pluralize : @reflection.primary_key_name
-
-      @items_to_relate = @model_to_relate.send("find_all_by_#{foreign_key}", nil)
-      if set_condition && !@items_to_relate.empty?
+      if set_condition && @items_to_relate.any?
         form = build_relate_form
       end
 
+      unless @reflection.through_reflection
+        foreign_key = @reflection.primary_key_name
+      end
+
       options = { foreign_key => @item.id }
 
       build_pagination
@@ -28,19 +33,19 @@ module Admin
       render "admin/templates/has_n",
              :model_to_relate => @model_to_relate,
              :model_to_relate_as_resource => @model_to_relate_as_resource,
+             :association_name => @association_name,
              :foreign_key => foreign_key,
-             :add_new => raw(build_add_new(options)),
+             :add_new => build_add_new(options),
              :form => form,
              :table => build_relationship_table
-
     end
 
     def typus_form_has_and_belongs_to_many(field)
-
       setup_relationship(field)
 
-      @items_to_relate = (@model_to_relate.all - @item.send(field))
-      if set_condition && !@items_to_relate.empty?
+      @items_to_relate = @model_to_relate.all - @item.send(field)
+
+      if set_condition && @items_to_relate.any?
         form = build_relate_form
       end
 
@@ -49,23 +54,24 @@ module Admin
       render "admin/templates/has_n",
              :model_to_relate => @model_to_relate,
              :model_to_relate_as_resource => @model_to_relate_as_resource,
-             :add_new => raw(build_add_new),
+             :association_name => @association_name,
+             :add_new => build_add_new,
              :form => form,
              :table => build_relationship_table
-
     end
 
     def build_pagination
       options = { :order => @model_to_relate.typus_order_by, :conditions => set_conditions }
       items_per_page = @model_to_relate.typus_options_for(:per_page)
-      data = @resource.find(params[:id]).send(@field).all(options)
+      data = @resource.unscoped.find(params[:id]).send(@field).all(options)
       @items = data.paginate(:per_page => items_per_page, :page => params[:page])
     end
 
     def build_relate_form
       render "admin/templates/relate_form",
              :model_to_relate => @model_to_relate,
-             :items_to_relate => @items_to_relate
+             :items_to_relate => @items_to_relate,
+             :association_name => @association_name
     end
 
     def build_relationship_table
@@ -74,110 +80,89 @@ module Admin
                  @items,
                  @model_to_relate_as_resource,
                  {},
-                 @association)
+                 @reflection.macro,
+                 @association_name)
     end
 
     def build_add_new(options = {})
-      default_options = { :controller => @field, :action => "new",
-                          :resource => @resource.name, :resource_id => @item.id,
+      default_options = { :controller => "/admin/#{@model_to_relate.to_resource}", :action => "new",
+                          :resource => @resource.model_name, :resource_id => @item.id,
                           :back_to => @back_to }
 
-      return unless set_condition && current_user.can?("create", @model_to_relate)
-
-      link_to _t("Add new"), default_options.merge(options)
+      if set_condition && admin_user.can?("create", @model_to_relate)
+        link_to Typus::I18n.t("Add new"), default_options.merge(options)
+      end
     end
 
     def set_condition
-      if @resource.typus_user_id? && current_user.is_not_root?
-        @item.owned_by?(current_user)
+      if @resource.typus_user_id? && admin_user.is_not_root?
+        @item.owned_by?(admin_user)
       else
         true
       end
     end
 
     def set_conditions
-      if @model_to_relate.typus_options_for(:only_user_items) && current_user.is_not_root?
-        { Typus.user_fk => current_user }
+      if @model_to_relate.typus_options_for(:only_user_items) && admin_user.is_not_root?
+        { Typus.user_fk => admin_user }
       end
     end
 
-    #--
-    # TODO: Move html code to partial.
-    #++
     def typus_form_has_one(field)
-      html = ""
-
-      model_to_relate = @resource.reflect_on_association(field.to_sym).class_name.constantize
-      model_to_relate_as_resource = model_to_relate.to_resource
-
-      reflection = @resource.reflect_on_association(field.to_sym)
-      association = reflection.macro
-
-      html << <<-HTML
-<a name="#{field}"></a>
-<div class="box_relationships" id="#{model_to_relate_as_resource}">
-  <h2>
-  #{link_to model_to_relate.model_name.human, :controller => "admin/#{model_to_relate_as_resource}"}
-  </h2>
-      HTML
-      items = Array.new
-      items << @resource.find(params[:id]).send(field) unless @resource.find(params[:id]).send(field).nil?
-      unless items.empty?
-        options = { :back_to => @back_to, :resource => @resource.to_resource, :resource_id => @item.id }
-        html << build_list(model_to_relate,
-                           model_to_relate.typus_fields_for(:relationship),
-                           items,
-                           model_to_relate_as_resource,
-                           options,
-                           association)
-      else
-        message = _t("There are no %{records}.",
-                    :records => model_to_relate.model_name.human.downcase)
-        html << <<-HTML
-  <div id="flash" class="notice"><p>#{message}</p></div>
-        HTML
+      setup_relationship(field)
+
+      @items = Array.new
+      if item = @resource.find(params[:id]).send(field)
+        @items << item
       end
-      html << <<-HTML
-</div>
-      HTML
 
-      return html
+      render "admin/templates/has_one",
+             :model_to_relate => @model_to_relate,
+             :model_to_relate_as_resource => @model_to_relate_as_resource,
+             :add_new => @items.empty? ? build_add_new : nil,
+             :table => build_relationship_table
     end
 
     def typus_belongs_to_field(attribute, form)
-
       ##
-      # We only can pass parameters to 'new' and 'edit', so this hack makes
-      # the work to replace the current action.
+      # We can only pass parameters to 'new' and 'edit'. This hack replaces
+      # the current action.
       #
       params[:action] = (params[:action] == 'create') ? 'new' : params[:action]
 
       back_to = url_for(:controller => params[:controller], :action => params[:action], :id => params[:id])
 
-      related = @resource.reflect_on_association(attribute.to_sym).class_name.constantize
+      related = @resource.reflect_on_association(attribute.to_sym).class_name.typus_constantize
       related_fk = @resource.reflect_on_association(attribute.to_sym).primary_key_name
 
-      confirm = [ _t("Are you sure you want to leave this page?"),
-                  _t("If you have made any changes to the fields without clicking the Save/Update entry button, your changes will be lost."),
-                  _t("Click OK to continue, or click Cancel to stay on this page.") ]
+      if params[:action] == 'edit'
+        options = { :resource => @resource.model_name,
+                    :resource_id => @item.id }
+      else
+        options = { :resource => @resource.model_name }
+      end
+
+      default = { :controller => "/admin/#{related.to_resource}", :action => 'new', :back_to => back_to }
 
-      message = link_to _t("Add"), { :controller => "admin/#{related.to_resource}",
-                                    :action => 'new',
-                                    :back_to => back_to,
-                                    :selected => related_fk },
-                                    :confirm => confirm.join("\n\n") if current_user.can?('create', related)
+      if admin_user.can?('create', related)
+        message = link_to Typus::I18n.t("Add"), default.merge(options)
+      end
+
+      values = related.respond_to?(:roots) ?
+        expand_tree_into_select_field(related.roots, related_fk) :
+        related.order(related.typus_order_by).map { |p| [p.to_label, p.id] }
 
       render "admin/templates/belongs_to",
              :resource => @resource,
+             :attribute => attribute,
              :form => form,
              :related_fk => related_fk,
              :message => message,
              :label_text => @resource.human_attribute_name(attribute),
-             :values => related.all(:order => related.typus_order_by).collect { |p| [p.to_label, p.id] },
+             :values => values,
              # :html_options => { :disabled => attribute_disabled?(attribute) },
              :html_options => {},
              :options => { :include_blank => true }
-
     end
 
   end

data/app/helpers/admin/resources_helper.rb

@@ -2,48 +2,27 @@ module Admin
 
   module ResourcesHelper
 
-    include FiltersHelper
-    include FormHelper
-    include RelationshipsHelper
-    include PreviewHelper
-    include SearchHelper
-    include SidebarHelper
-    include TableHelper
+    include Admin::FiltersHelper
+    include Admin::FormHelper
+    include Admin::RelationshipsHelper
+    include Admin::FilePreviewHelper
+    include Admin::SearchHelper
+    include Admin::SidebarHelper
+    include Admin::TableHelper
 
     #--
     # If partial `list` exists we will use it. This partial will have available
     # the `@items` so we can do whatever we want there. Notice that pagination
     # is still available.
     #++
-    def build_list(model, fields, items, resource = @resource.to_resource, link_options = {}, association = nil)
+    def build_list(model, fields, items, resource = @resource.to_resource, link_options = {}, association = nil, association_name = nil)
       render "admin/#{resource}/list", :items => items
     rescue ActionView::MissingTemplate
-      build_table(model, fields, items, link_options, association)
+      build_table(model, fields, items, link_options, association, association_name)
     end
 
     def display_link_to_previous
-      return unless params[:back_to]
-
-      options = {}
-      options[:resource_from] = @resource.model_name.human
-      options[:resource_to] = params[:resource].classify.constantize.model_name.human 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}."
-                when editing
-                  "You're updating a %{resource_from}."
-                when params[:resource]
-                  "You're adding a new %{resource_from} to %{resource_to}."
-                else
-                  "You're adding a new %{resource_from}."
-                end
-      message = _t(message,
-                  :resource_from => options[:resource_from],
-                  :resource_to => options[:resource_to])
-
-      render File.join(path, "display_link_to_previous"), :message => message
+      render File.join(path, "display_link_to_previous") if params[:back_to]
     end
 
     private

data/app/helpers/admin/search_helper.rb

@@ -3,15 +3,12 @@ module Admin
   module SearchHelper
 
     def search(resource = @resource)
-      typus_search = resource.typus_defaults_for(:search)
-      return if typus_search.empty?
-
-      search_by = typus_search.collect { |x| resource.human_attribute_name(x) }.to_sentence
-      search_params = params.dup
-      %w(action controller id search page utf8).each { |p| search_params.delete(p) }
-      hidden_params = search_params.map { |k, v| hidden_field_tag(k, v) }
-
-      render "admin/helpers/search/search", :hidden_params => hidden_params, :search_by => search_by
+      if (typus_search = resource.typus_defaults_for(:search)) && typus_search.any?
+        search_params = params.dup
+        %w(action controller id search page utf8).each { |p| search_params.delete(p) }
+        options = { :hidden_params => search_params.map { |k, v| hidden_field_tag(k, v) } }
+        render "admin/helpers/search/search", options
+      end
     end
 
   end

data/app/helpers/admin/sidebar_helper.rb

@@ -6,13 +6,13 @@ module Admin
       resources = ActiveSupport::OrderedHash.new
       app_name = @resource.typus_application
 
-      Typus.application(app_name).sort {|a,b| a.constantize.model_name.human <=> b.constantize.model_name.human}.each do |resource|
-        next unless current_user.resources.include?(resource)
-        klass = resource.constantize
+      Typus.application(app_name).sort {|a,b| a.typus_constantize.model_name.human <=> b.typus_constantize.model_name.human}.each do |resource|
+        next unless admin_user.resources.include?(resource)
+        klass = resource.typus_constantize
 
         resources[resource] = default_actions(klass)
-        resources[resource] += export(klass) if params[:action] == 'index'
         resources[resource] += custom_actions(klass)
+        resources[resource] += export(klass) if params[:action] == 'index'
 
         resources[resource].compact!
       end
@@ -21,31 +21,26 @@ module Admin
     end
 
     def default_actions(klass)
-      actions = []
-
-      if current_user.can?("create", klass)
-        actions << link_to_unless_current(_t("Add new"), :action => "new")
-      end
-
-      actions << link_to_unless_current(_t("List"), :action => "index")
-
-      return actions
-    end
-
-    def export(klass)
-      klass.typus_export_formats.map do |format|
-        link_to _t("Export as %{format}", :format => format.upcase), params.merge(:format => format)
+      Array.new.tap do |tap|
+        tap << link_to_unless_current(Typus::I18n.t("Add new"), :action => "new") if admin_user.can?("create", klass)
+        tap << link_to_unless_current(Typus::I18n.t("List"), :action => "index")
       end
     end
 
     def custom_actions(klass)
       klass.typus_actions_on(params[:action]).map do |action|
-        if current_user.can?(action, klass)
-          link_to_unless_current(_t(action.humanize), params.merge(:action => action))
+        if admin_user.can?(action, klass)
+          link_to_unless_current(Typus::I18n.t(action.humanize), params.merge(:action => action))
         end
       end
     end
 
+    def export(klass, params = params)
+      klass.typus_export_formats.map do |format|
+        link_to Typus::I18n.t("Export as %{mime}", :mime => format.upcase), params.merge(:format => format)
+      end
+    end
+
  end
 
 end

data/app/helpers/admin/table_helper.rb

@@ -2,26 +2,27 @@ module Admin
 
   module TableHelper
 
-    def build_table(model, fields, items, link_options = {}, association = nil)
+    def build_table(model, fields, items, link_options = {}, association = nil, association_name = nil)
       render "admin/helpers/table/table",
              :model => model,
              :fields => fields,
              :items => items,
              :link_options => link_options,
-             :headers => table_header(model, fields)
+             :headers => table_header(model, fields),
+             :association_name => association_name
     end
 
-    def table_header(model, fields)
+    def table_header(model, fields, params = params)
       fields.map do |key, value|
 
         key = key.gsub(".", " ") if key.match(/\./)
         content = model.human_attribute_name(key)
 
-        if params[:action] == "index"
+        if params[:action].eql?('index') && model.typus_options_for(:sortable)
           association = model.reflect_on_association(key.to_sym)
           order_by = association ? association.primary_key_name : key
 
-          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))
+          if (model.model_fields.map(&:first).map { |i| i.to_s }.include?(key) || model.reflect_on_all_associations(:belongs_to).map(&:name).include?(key.to_sym))
             sort_order = case params[:sort_order]
                          when 'asc' then ['desc', '↓']
                          when 'desc' then ['asc', '↑']
@@ -29,8 +30,8 @@ module Admin
                          end
             switch = sort_order.last if params[:order_by].eql?(order_by)
             options = { :order_by => order_by, :sort_order => sort_order.first }
-            message = [ content, switch ].compact
-            link_to raw(message.join(" ")), params.merge(options)
+            message = [content, switch].compact.join(" ").html_safe
+            link_to message, params.merge(options)
           else
             content
           end
@@ -42,206 +43,114 @@ module Admin
       end
     end
 
-    def table_fields_for_item(item, fields, link_options)
-      fields.map do |key, value|
-        case value
-        when :boolean then table_boolean_field(key, item)
-        when :datetime then table_datetime_field(key, item, link_options)
-        when :date then table_datetime_field(key, item, link_options)
-        when :file then table_file_field(key, item, link_options)
-        when :time then table_datetime_field(key, item, link_options)
-        when :belongs_to then table_belongs_to_field(key, item)
-        when :tree then table_tree_field(key, item)
-        when :position then table_position_field(key, item)
-        when :selector then table_selector(key, item)
-        when :transversal then table_transversal(key, item)
-        when :has_and_belongs_to_many then table_has_and_belongs_to_many_field(key, item)
-        else
-          table_string_field(key, item, link_options)
-        end
-      end
+    def table_fields_for_item(item, fields)
+      fields.map { |k, v| send("table_#{v}_field", k, item) }
     end
 
-    def table_default_action(model, item)
-      action = if model.typus_user_id? && current_user.is_not_root?
-                 # If there's a typus_user_id column on the table and logged user is not root ...
-                 item.owned_by?(current_user) ? item.class.typus_options_for(:default_action_on_item) : "show"
-               elsif current_user.cannot?("edit", model)
-                 'show'
-               else
-                 item.class.typus_options_for(:default_action_on_item)
-               end
-
-      options = { :controller => "admin/#{item.class.to_resource}",
-                  :action => action,
-                  :id => item.id }
-
-      link_to _t(action.capitalize), options
-    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/unrelate items.
-    #++
-    def table_action(model, item)
-
-      condition = true
-
-      case params[:action]
-      when "index"
-        action = "trash"
-        options = { :action => 'destroy', :id => item.id }
-        method = :delete
-      when "edit", "show"
-        action = "unrelate"
-        options = { :action => 'unrelate', :id => params[:id], :resource => model, :resource_id => item.id }
-      end
-
-      title = _t(action.titleize)
-
-      case params[:action]
-      when 'index'
-        condition = if model.typus_user_id? && current_user.is_not_root?
-                      item.owned_by?(current_user)
-                    elsif (current_user.id.eql?(item.id) && model.eql?(Typus.user_class))
-                      false
-                    else
-                      current_user.can?('destroy', model)
-                    end
-        confirm = _t("Remove %{resource}?", :resource => item.class.model_name.human)
-      when 'edit'
-        # If we are editing content, we can relate and unrelate always!
-        confirm = _t("Unrelate %{unrelate_model} from %{unrelate_model_from}?",
-                    :unrelate_model => model.model_name.human,
-                    :unrelate_model_from => @resource.model_name.human)
-      when 'show'
-        # If we are showing content, we only can relate and unrelate if we are
-        # the owners of the owner record.
-        # If the owner record doesn't have a foreign key (Typus.user_fk) we look
-        # each item to verify the ownership.
-        condition = if @resource.typus_user_id? && current_user.is_not_root?
-                      @item.owned_by?(current_user)
-                    end
-        confirm = _t("Unrelate %{unrelate_model} from %{unrelate_model_from}?",
-                    :unrelate_model => model.model_name.human,
-                    :unrelate_model_from => @resource.model_name.human)
-      end
-
-      message = %(<div class="sprite #{action}">#{_t(action.titleize)}</div>)
-
-      if condition
-        link_to raw(message), options, :title => title, :confirm => confirm, :method => method
-      end
+    def actions
+      @actions ||= []
+    end
 
+    def table_actions(model, item, association_name = nil)
+      actions.map do |action|
+        if admin_user.can?(action[:action], model.name)
+          link_to Typus::I18n.t(action[:action_name]),
+                  { :controller => model.to_resource, :action => action[:action], :id => item.id, :resource => action[:resource], :resource_id => action[:resource_id], :association_name => association_name },
+                  { :confirm => action[:confirm], :method => action[:method], :target => "_parent" }
+        end
+      end.compact.join(" / ").html_safe
     end
 
     def table_belongs_to_field(attribute, item)
-      att_value = item.send(attribute)
-      content = "&mdash;".html_safe
-
-      unless att_value.nil?
-        content = att_value.to_label
+      if att_value = item.send(attribute)
         action = item.send(attribute).class.typus_options_for(:default_action_on_item)
-        if current_user.can?(action, att_value.class.name)
-          content = link_to content, :controller => "admin/#{att_value.class.to_resource}", :action => action, :id => att_value.id
+        if admin_user.can?(action, att_value.class.name)
+          link_to att_value.to_label, :controller => "/admin/#{att_value.class.to_resource}", :action => action, :id => att_value.id
+        else
+          att_value.to_label
         end
+      else
+        "&mdash;".html_safe
       end
-
-      return content_tag(:td, content)
     end
 
     def table_has_and_belongs_to_many_field(attribute, item)
-      content = item.send(attribute).map { |i| i.to_label }.join(", ")
-      return content_tag(:td, content)
+      item.send(attribute).map { |i| i.to_label }.join(", ")
     end
 
-    def table_string_field(attribute, item, link_options = {})
-      raw_content = item.send(attribute)
-      content = raw_content.blank? ? "&#151;".html_safe : raw_content
-      return content_tag(:td, content, :class => attribute)
-    end
+    alias :table_has_many_field :table_has_and_belongs_to_many_field
 
-    def table_selector(attribute, item)
-      raw_content = item.mapping(attribute)
-      return content_tag(:td, raw_content, :class => attribute)
+    def table_string_field(attribute, item)
+      (raw_content = item.send(attribute)).present? ? truncate(raw_content) : "&mdash;".html_safe
     end
 
-    def table_file_field(attribute, item, link_options = {})
-      file_preview = Typus.file_preview
-      file_thumbnail = Typus.file_thumbnail
+    alias :table_text_field :table_string_field
 
-      has_file_preview = item.send(attribute).styles.member?(file_preview)
-      file_preview_is_image = item.send("#{attribute}_content_type") =~ /^image\/.+/
+    def table_generic_field(attribute, item)
+      (raw_content = item.send(attribute)).present? ? raw_content : "&mdash;".html_safe
+    end
 
-      content = if has_file_preview && file_preview_is_image
-                  render "admin/helpers/preview",
-                         :attribute => attribute,
-                         :attachment => attribute,
-                         :content => item.to_label,
-                         :file_preview_is_image => file_preview_is_image,
-                         :has_file_preview => has_file_preview,
-                         :href => item.send(attribute).url(file_preview),
-                         :item => item
-                else
-                  link_to item.send(attribute), item.send(attribute).url
-                end
+    alias :table_float_field :table_generic_field
+    alias :table_integer_field :table_generic_field
+    alias :table_decimal_field :table_generic_field
+    alias :table_virtual_field :table_generic_field
 
-      return content_tag(:td, content)
+    def table_selector_field(attribute, item)
+      item.mapping(attribute)
+    end
+
+    def table_file_field(attribute, item)
+      typus_file_preview(item, attribute)
     end
 
     def table_tree_field(attribute, item)
-      content = item.parent ? item.parent.to_label : "&#151;".html_safe
-      return content_tag(:td, content)
+      item.parent ? item.parent.to_label : "&mdash;".html_safe
     end
 
-    def table_position_field(attribute, item)
+    def table_position_field(attribute, item, connector = " / ")
       html_position = []
 
-      { :move_higher => "Up", :move_lower => "Down" }.each do |key, value|
-        options = { :controller => item.class.to_resource, :action => "position", :id => item.id, :go => key }
-        first_or_last = (item.respond_to?(:first?) && (key == :move_higher && item.first?)) || (item.respond_to?(:last?) && (key == :move_lower && item.last?))
-        html_position << link_to_unless(first_or_last, _t(value), params.merge(options)) do |name|
-          %(<span class="inactive">#{name}</span>)
+      [ [:move_to_top, "Top"],
+        [:move_higher,  "Up"],
+        [:move_lower,   "Down"],
+        [:move_to_bottom, "Bottom"] ].each do |key, value|
+
+        options = { :controller => "/admin/#{item.class.to_resource}", :action => "position", :id => item.id, :go => key }
+        should_be_inactive = (item.respond_to?(:first?) && ([:move_higher, :move_to_top].include?(key) && item.first?)) ||
+                             (item.respond_to?(:last?) &&  ([:move_lower, :move_to_bottom].include?(key) && item.last?))
+        html_position << link_to_unless(should_be_inactive, Typus::I18n.t(value), params.merge(options)) do |name|
+          %w(<span class="inactive">#{name}</span>)
         end
       end
 
-      content = html_position.join(" / ").html_safe
-      return content_tag(:td, content)
+      "#{item.position}<br/><br/>#{html_position.compact.join(connector)}".html_safe
     end
 
-    def table_datetime_field(attribute, item, link_options = {} )
-      date_format = item.class.typus_date_format(attribute)
-      content = !item.send(attribute).nil? ? item.send(attribute).to_s(date_format) : item.class.typus_options_for(:nil)
-
-      return content_tag(:td, content)
+    def table_datetime_field(attribute, item)
+      if field = item.send(attribute)
+        I18n.localize(field, :format => item.class.typus_date_format(attribute))
+      end
     end
 
+    alias :table_date_field :table_datetime_field
+    alias :table_time_field :table_datetime_field
+
     def table_boolean_field(attribute, item)
-      boolean_hash = item.class.typus_boolean(attribute).invert
       status = item.send(attribute)
+      boolean_hash = item.class.typus_boolean(attribute).invert
+      human_boolean = status ? boolean_hash["true"] : boolean_hash["false"]
+
+      options = { :controller => "/admin/#{item.class.to_resource}",
+                  :action => "toggle",
+                  :id => item.id,
+                  :field => attribute.gsub(/\?$/, '') }
+      confirm = Typus::I18n.t("Change %{attribute}?", :attribute => item.class.human_attribute_name(attribute).downcase)
+      link_to Typus::I18n.t(human_boolean), options, :confirm => confirm
+    end
 
-      content = if status.nil?
-                  Typus::Resources.human_nil
-                else
-                  message = _t(boolean_hash[status.to_s])
-                  options = { :controller => "admin/#{item.class.to_resource}",
-                              :action => "toggle",
-                              :id => item.id,
-                              :field => attribute.gsub(/\?$/,'') }
-                  confirm = _t("Change %{attribute}?",
-                              :attribute => item.class.human_attribute_name(attribute).downcase)
-                  link_to message, options, :confirm => confirm
-                end
-
-      return content_tag(:td, content)
-    end
-
-    def table_transversal(attribute, item)
-      _attribute, virtual = attribute.split(".")
-      return content_tag(:td, item.send(_attribute).send(virtual))
+    def table_transversal_field(attribute, item)
+      field_1, field_2 = attribute.split(".")
+      item.send(field_1).send(field_2)
     end
 
   end