typus 3.0.6 → 3.0.7

data/app/controllers/admin/session_controller.rb

@@ -4,7 +4,7 @@ class Admin::SessionController < Admin::BaseController
   skip_before_filter :authenticate
   skip_before_filter :set_locale
 
-  before_filter :create_an_account?, :except => [:destroy]
+  before_filter :create_an_account?, :only => [:new, :create]
 
   def new
   end

data/app/helpers/admin/base_helper.rb

@@ -7,7 +7,7 @@ module Admin
     end
 
     def header
-      render "admin/helpers/header"
+      render "admin/helpers/base/header"
     end
 
     def has_root_path?
@@ -15,18 +15,18 @@ module Admin
     end
 
     def apps
-      render "admin/helpers/apps"
+      render "admin/helpers/base/apps"
     end
 
     def login_info
       unless admin_user.is_a?(FakeUser)
-        render "admin/helpers/login_info"
+        render "admin/helpers/base/login_info"
       end
     end
 
     def display_flash_message(message = flash)
       if message.compact.any?
-        render "admin/helpers/flash_message",
+        render "admin/helpers/base/flash_message",
                :flash_type => message.keys.first,
                :message => message
       end

data/app/helpers/admin/dashboard_helper.rb

@@ -7,9 +7,7 @@ module Admin
     end
 
     def resources(admin_user)
-      available = Typus.resources.map do |resource|
-                    resource if admin_user.resources.include?(resource)
-                  end.compact
+      available = Typus.resources.delete_if { |r| !(admin_user.is_a?(FakeUser) || admin_user.resources.include?(r)) }
       render "admin/helpers/dashboard/resources", :resources => available
     end
 

data/app/helpers/admin/display_helper.rb

@@ -0,0 +1,49 @@
+module Admin
+  module DisplayHelper
+
+    def build_display(item, fields)
+      fields.map do |attribute, type|
+        value = if (type == :boolean) || (data = item.send(attribute))
+                  send("display_#{type}", item, attribute)
+                else
+                  "—".html_safe
+                end
+
+        [@resource.human_attribute_name(attribute), value]
+      end
+    end
+
+    def display_boolean(item, attribute)
+      data = item.send(attribute)
+      boolean_assoc = item.class.typus_boolean(attribute)
+      (data ? boolean_assoc.rassoc("true") : boolean_assoc.rassoc("false")).first
+    end
+
+    def display_belongs_to(item, attribute)
+      data = item.send(attribute)
+      link_to data.to_label, { :controller => data.class.to_resource,
+                               :action => data.class.typus_options_for(:default_action_on_item),
+                               :id => data.id }
+    end
+
+    def display_file(item, attribute)
+      typus_file_preview(item, attribute)
+    end
+
+    def display_selector(item, attribute)
+      item.mapping(attribute)
+    end
+
+    def display_datetime(item, attribute)
+      I18n.l(item.send(attribute), :format => @resource.typus_date_format(attribute))
+    end
+
+    def display_string(item, attribute)
+      item.send(attribute)
+    end
+
+    alias_method :display_text, :display_string
+    alias_method :display_position, :display_string
+
+  end
+end

data/app/helpers/admin/file_preview_helper.rb

@@ -25,40 +25,38 @@ module Admin
         message = Typus::I18n.t("Remove")
         label_text = <<-HTML
 #{attribute_i18n}
-<small>#{link_to message, { :action => 'detach', :id => @item.id, :attribute => attribute }, :confirm => Typus::I18n.t("Are you sure?")}</small>
+<small>#{link_to message, { :action => 'update', :id => @item.id, :attribute => attribute }, :confirm => Typus::I18n.t("Are you sure?")}</small>
         HTML
         label_text.html_safe
       end
     end
 
-    def typus_file_preview(item, attribute)
+    def typus_file_preview(item, attribute, options = {})
       if (attachment = item.send(attribute))
-        case get_type_of_attachment(attachment)
-        when :dragonfly
-          typus_file_preview_for_dragonfly(attachment)
-        when :paperclip
-          typus_file_preview_for_paperclip(attachment)
-        end
+        adapter = get_type_of_attachment(attachment)
+        send("typus_file_preview_for_#{adapter}", attachment, options)
       end
     end
 
-    def typus_file_preview_for_dragonfly(attachment)
+    def typus_file_preview_for_dragonfly(attachment, options = {})
       if attachment.mime_type =~ /^image\/.+/
         render "admin/helpers/file_preview",
                :preview => attachment.process(:thumb, Typus.image_preview_size).url,
-               :thumb => attachment.process(:thumb, Typus.image_thumb_size).url
+               :thumb => attachment.process(:thumb, Typus.image_thumb_size).url,
+               :options => options
       else
         link_to attachment.name, attachment.url
       end
     end
 
-    def typus_file_preview_for_paperclip(attachment)
+    def typus_file_preview_for_paperclip(attachment, options = {})
       if attachment.exists?
         styles = attachment.styles.keys
         if styles.include?(Typus.file_preview) && styles.include?(Typus.file_thumbnail)
           render "admin/helpers/file_preview",
                  :preview => attachment.url(Typus.file_preview, false),
-                 :thumb => attachment.url(Typus.file_thumbnail, false)
+                 :thumb => attachment.url(Typus.file_thumbnail, false),
+                 :options => options
         else
           link_to attachment.original_filename, attachment.url(:original, false)
         end

data/app/helpers/admin/filters_helper.rb

@@ -87,7 +87,7 @@ module Admin
     end
 
     def predefined_filters
-      @predefined_filters ||= [["All", "index", "unscoped"]]
+      @predefined_filters ||= []
     end
 
   end

data/app/helpers/admin/form_helper.rb

@@ -30,24 +30,13 @@ module Admin
              :values => expand_tree_into_select_field(@resource.roots, "parent_id")
     end
 
-    # OPTIMIZE: Cleanup the case statement, using some meta-code.
     def typus_relationships
-      @back_to = url_for(:controller => params[:controller], :action => params[:action], :id => params[:id])
-
       String.new.tap do |html|
         @resource.typus_defaults_for(:relationships).each do |relationship|
           association = @resource.reflect_on_association(relationship.to_sym)
+          next if association.macro == :belongs_to
           next if admin_user.cannot?('read', association.class_name.typus_constantize)
-          html << case association.macro
-                  when :has_and_belongs_to_many
-                    typus_form_has_and_belongs_to_many(relationship)
-                  when :has_many
-                    typus_form_has_many(relationship)
-                  when :has_one
-                    typus_form_has_one(relationship)
-                  when :belongs_to
-                    ""
-                  end
+          html << send("typus_form_#{association.macro}", relationship)
         end
       end
     end

data/app/helpers/admin/list_helper.rb

@@ -9,10 +9,21 @@ module Admin
     def list_actions
       resources_actions.map do |body, url, options|
         if admin_user.can?(url[:action], @resource.name)
-          path = params.dup.merge!(url)
-          link_to Typus::I18n.t(body), path.cleanup, options # .merge(:target => "_parent")
+          path = params.dup.merge!(url).compact.cleanup
+          link_to Typus::I18n.t(body), path, options
         end
-      end.compact.join(" / ").html_safe
+      end.join(" / ").html_safe
+    end
+
+    #--
+    # 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, association_name = nil)
+      render "admin/#{resource}/list", :items => items
+    rescue ActionView::MissingTemplate
+      build_table(model, fields, items, link_options, association, association_name)
     end
 
   end

data/app/helpers/admin/relationships_helper.rb

@@ -7,34 +7,38 @@ module Admin
       @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_name = @reflection.through_reflection ? @reflection.name.to_s : @model_to_relate.model_name.tableize
+      @association_name = @reflection.through_reflection ? @reflection.name.to_s : @model_to_relate.model_name
     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
 
-      if set_condition && @items_to_relate.any?
-        form = build_relate_form
-      end
+      options = @reflection.through_reflection ? {} : { @reflection.primary_key_name => @item.id }
 
-      unless @reflection.through_reflection
-        foreign_key = @reflection.primary_key_name
-      end
+      count_items_to_relate = @model_to_relate.order(@model_to_relate.typus_order_by).count - @item.send(field).count
 
-      options = { foreign_key => @item.id }
+      if set_condition && !count_items_to_relate.zero?
+        form = if count_items_to_relate > Typus.autocomplete
+                 build_relate_form('admin/templates/relate_form_with_autocomplete')
+               else
+                 @items_to_relate = @model_to_relate.order(@model_to_relate.typus_order_by) - @item.send(field)
+                 build_relate_form
+               end
+      end
 
       build_pagination
 
+      # If we are on a through_reflection set the association name!
+      @resource_actions = if @reflection.through_reflection
+                            [["Edit", {:action=>"edit"}, {}],
+                             ["Unrelate", {:resource_id=> @item.id, :resource=> @resource.model_name, :action=>"unrelate", :association_name => @association_name}, {:confirm=>"Unrelate?"}]]
+                          else
+                            [["Edit", {:action=>"edit"}, {}],
+                             ["Trash", {:resource_id=>@item.id, :resource=>@resource.model_name, :action=>"destroy"}, {:confirm=>"Trash?"}]]
+                           end
+
       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 => build_add_new(options),
              :form => form,
              :table => build_relationship_table
@@ -43,17 +47,24 @@ module Admin
     def typus_form_has_and_belongs_to_many(field)
       setup_relationship(field)
 
-      @items_to_relate = @model_to_relate.all - @item.send(field)
+      count_items_to_relate = @model_to_relate.order(@model_to_relate.typus_order_by).count - @item.send(field).count
 
-      if set_condition && @items_to_relate.any?
-        form = build_relate_form
+      if set_condition && !count_items_to_relate.zero?
+        form = if count_items_to_relate > Typus.autocomplete
+                 build_relate_form('admin/templates/relate_form_with_autocomplete')
+               else
+                 @items_to_relate = @model_to_relate.order(@model_to_relate.typus_order_by) - @item.send(field)
+                 build_relate_form
+               end
       end
 
       build_pagination
 
+      # TODO: Find a cleaner way to add these actions ...
+      @resource_actions = [["Edit", {:action=>"edit"}, {}],
+                           ["Unrelate", {:resource_id=> @item.id, :resource=> @resource.model_name, :action=>"unrelate"}, {:confirm=>"Unrelate?"}]]
+
       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,
              :add_new => build_add_new,
              :form => form,
@@ -61,17 +72,16 @@ module Admin
     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.unscoped.find(params[:id]).send(@field).all(options)
+      data = @item.send(@field).order(@model_to_relate.typus_order_by).where(set_conditions)
       @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,
-             :association_name => @association_name
+    def build_relate_form(template = "admin/templates/relate_form")
+      options = { :association_name => @association_name,
+                  :items_to_relate => @items_to_relate,
+                  :model_to_relate => @model_to_relate }
+      render template, options
     end
 
     def build_relationship_table
@@ -85,9 +95,10 @@ module Admin
     end
 
     def build_add_new(options = {})
-      default_options = { :controller => "/admin/#{@model_to_relate.to_resource}", :action => "new",
-                          :resource => @resource.model_name, :resource_id => @item.id,
-                          :back_to => @back_to }
+      default_options = { :controller => "/admin/#{@model_to_relate.to_resource}",
+                          :action => "new",
+                          :resource => @resource.model_name,
+                          :resource_id => @item.id }
 
       if set_condition && admin_user.can?("create", @model_to_relate)
         link_to Typus::I18n.t("Add new"), default_options.merge(options)
@@ -112,56 +123,62 @@ module Admin
       setup_relationship(field)
 
       @items = Array.new
-      if item = @resource.find(params[:id]).send(field)
+      if item = @item.send(field)
         @items << item
       end
 
+      # TODO: Find a cleaner way to add these actions ...
+      @resource_actions = [["Edit", {:action=>"edit"}, {}],
+                           ["Trash", {:resource_id=>@item.id, :resource=>@resource.model_name, :action=>"destroy"}, {:confirm=>"Trash?"}]]
+
+      options = { :resource_id => nil, @reflection.primary_key_name => @item.id }
+
       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,
+             :association_name => @association_name,
+             :add_new => @items.empty? ? build_add_new(options) : nil,
              :table => build_relationship_table
     end
 
     def typus_belongs_to_field(attribute, form)
-      ##
-      # 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.typus_constantize
-      related_fk = @resource.reflect_on_association(attribute.to_sym).primary_key_name
-
-      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 }
+      association = @resource.reflect_on_association(attribute.to_sym)
+      related = association.class_name.typus_constantize
+      related_fk = association.primary_key_name
 
+      # TODO: Use the build_add_new method.
       if admin_user.can?('create', related)
-        message = link_to Typus::I18n.t("Add"), default.merge(options)
+        options = { :controller => "/admin/#{related.to_resource}",
+                    :action => 'new',
+                    :resource => @resource.model_name }
+        # Pass the resource_id only to edit/update because only there is where
+        # the record actually exists.
+        options.merge!(:resource_id => @item.id) if %w(edit update).include?(params[:action])
+        message = link_to Typus::I18n.t("Add"), 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",
+      # Set the template.
+      template = if related.respond_to?(:roots) || !(related.count > Typus.autocomplete)
+                   "admin/templates/belongs_to"
+                 else
+                   "admin/templates/belongs_to_with_autocomplete"
+                 end
+
+      # Set the values.
+      values = if related.respond_to?(:roots)
+                 expand_tree_into_select_field(related.roots, related_fk)
+               elsif !(related.count > Typus.autocomplete)
+                 related.order(related.typus_order_by).map { |p| [p.to_label, p.id] }
+               end
+
+      render template,
              :resource => @resource,
              :attribute => attribute,
              :form => form,
              :related_fk => related_fk,
+             :related => related,
              :message => message,
              :label_text => @resource.human_attribute_name(attribute),
              :values => values,
-             # :html_options => { :disabled => attribute_disabled?(attribute) },
-             :html_options => {},
+             :html_options => { :disabled => attribute_disabled?(attribute) },
              :options => { :include_blank => true }
     end
 

data/app/helpers/admin/resources_helper.rb

@@ -2,6 +2,7 @@ module Admin
 
   module ResourcesHelper
 
+    include Admin::DisplayHelper
     include Admin::ListHelper
     include Admin::FiltersHelper
     include Admin::FormHelper
@@ -11,25 +12,25 @@ module Admin
     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, association_name = nil)
-      render "admin/#{resource}/list", :items => items
-    rescue ActionView::MissingTemplate
-      build_table(model, fields, items, link_options, association, association_name)
-    end
+    def display_link_to_previous(params = params)
+      if params[:resource]
 
-    def display_link_to_previous
-      render File.join(path, "display_link_to_previous") if params[:back_to]
-    end
+        item_class = params[:resource].typus_constantize
+        url = { :controller => item_class.to_resource }
+
+        if params[:resource_id]
+          item = item_class.find(params[:resource_id])
+          url.merge!(:action => 'edit', :id => item.id)
+        else
+          url.merge!(:action => 'new')
+        end
 
-    private
+        body = Typus::I18n.t("Cancel adding a new %{resource}?", :resource => @resource.model_name.human.downcase)
 
-    def path
-      "admin/helpers/resources"
+        render "admin/helpers/resources/display_link_to_previous",
+               :body => body,
+               :url => url
+      end
     end
 
   end