typus 3.1.0.rc18 → 3.1.0.rc19

data/app/helpers/admin/base_helper.rb

@@ -10,11 +10,8 @@ module Admin::BaseHelper
   end
 
   def admin_title
-    if defined?(Admin::Setting)
-      Admin::Setting.admin_title || Typus.admin_title
-    else
-      Typus.admin_title
-    end
+    setting = defined?(Admin::Setting) && Admin::Setting.admin_title
+    setting || Typus.admin_title
   end
 
   def has_root_path?

data/app/helpers/admin/resources/data_types/belongs_to_helper.rb

@@ -10,31 +10,21 @@ module Admin::Resources::DataTypes::BelongsToHelper
               end
     related_fk = association.foreign_key
 
-    # TODO: Use the build_add_new method.
-    if admin_user.can?('create', related)
-      options = { :controller => "/admin/#{related.to_resource}",
-                  :action => 'new',
-                  :resource => @resource.model_name,
-                  :layout => 'admin/headless' }
-      # 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 New"), options, { :class => 'iframe' }
-    end
-
-    # By default the used template is ALWAYS `belongs_to` unless we have the
-    # `Typus.autocomplete` feature enabled.
-    template = Typus.autocomplete ? "belongs_to_with_autocomplete" : "belongs_to"
+    html_options = { :disabled => attribute_disabled?(attribute) }
+    label_text = @resource.human_attribute_name(attribute)
 
-    # If `Typus.autocomplete` is enabled we don't set the values as will be
-    # autocompleted.
-    if related.respond_to?(:roots)
-      values = expand_tree_into_select_field(related.roots, related_fk)
-    elsif !Typus.autocomplete
-      values = related.order(related.typus_order_by).map { |p| [p.to_label, p.id] }
+    label_text = @resource.human_attribute_name(attribute)
+    if (text = build_label_text_for_belongs_to(related, html_options))
+      label_text += "<small>#{text}</small>"
     end
 
-    render "admin/templates/#{template}",
+    values = if related.respond_to?(:roots)
+               expand_tree_into_select_field(related.roots, related_fk)
+             else
+               related.order(related.typus_order_by).map { |p| [p.to_label, p.id] }
+             end
+
+    render "admin/templates/belongs_to",
            :association => association,
            :resource => @resource,
            :attribute => attribute,
@@ -42,10 +32,9 @@ module Admin::Resources::DataTypes::BelongsToHelper
            :form => form,
            :related_fk => related_fk,
            :related => related,
-           :message => message,
-           :label_text => @resource.human_attribute_name(attribute),
+           :label_text => label_text.html_safe,
            :values => values,
-           :html_options => { :disabled => attribute_disabled?(attribute) },
+           :html_options => html_options,
            :options => { :include_blank => true }
   end
 
@@ -58,13 +47,13 @@ module Admin::Resources::DataTypes::BelongsToHelper
       end
     end
 
-    message || "&mdash;".html_safe
+    message || mdash
   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),
+                             :action => params[:action],
                              :id => data.id }
   end
 
@@ -77,4 +66,23 @@ module Admin::Resources::DataTypes::BelongsToHelper
     items += resource.order(resource.typus_order_by).map { |v| [v.to_label, v.id] }
   end
 
+  def build_label_text_for_belongs_to(klass, html_options)
+    if html_options[:disabled] == true
+      Typus::I18n.t("Read only")
+    elsif admin_user.can?('create', klass) && !headless_mode?
+      build_add_new_for_belongs_to(klass)
+    end
+  end
+
+  def build_add_new_for_belongs_to(klass)
+    options = { :controller => "/admin/#{klass.to_resource}",
+                :action => 'new',
+                :resource => @resource.model_name,
+                :layout => 'admin/headless' }
+    # 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])
+    link_to Typus::I18n.t("Add New"), options, { :class => 'iframe' }
+  end
+
 end

data/app/helpers/admin/resources/data_types/dragonfly_helper.rb

@@ -1,8 +1,7 @@
 module Admin::Resources::DataTypes::DragonflyHelper
 
   def table_dragonfly_field(attribute, item)
-    options = { :height => 25, :width => 25 }
-    typus_dragonfly_preview(item, attribute, options)
+    typus_dragonfly_preview(item, attribute)
   end
 
   def link_to_detach_attribute_for_dragonfly(attribute)
@@ -19,12 +18,26 @@ module Admin::Resources::DataTypes::DragonflyHelper
     end
   end
 
-  def typus_dragonfly_preview(item, attachment, options = {})
+  def typus_dragonfly_preview(item, attachment)
     data = item.send(attachment)
     return unless data
 
     if data.mime_type =~ /^image\/.+/
       render "admin/templates/dragonfly_preview",
+             :preview => data.process(:thumb, Typus.image_preview_size).url,
+             :thumb => data.process(:thumb, Typus.image_table_thumb_size).url
+    else
+      link_to data.name, data.url
+    end
+  end
+
+  def typus_dragonfly_form_preview(item, attachment, options = {})
+    data = item.send(attachment)
+    return unless data
+
+    if data.mime_type =~ /^image\/.+/
+      render "admin/templates/dragonfly_form_preview",
+             :attachment => data,
              :preview => data.process(:thumb, Typus.image_preview_size).url,
              :thumb => data.process(:thumb, Typus.image_thumb_size).url,
              :options => options

data/app/helpers/admin/resources/data_types/has_and_belongs_to_many_helper.rb

@@ -6,19 +6,51 @@ module Admin::Resources::DataTypes::HasAndBelongsToManyHelper
 
   alias_method :table_has_many_field, :table_has_and_belongs_to_many_field
 
-  def typus_form_has_and_belongs_to_many(field)
-    setup_relationship(field)
-    build_pagination
-
-    # TODO: Find a cleaner way to add these actions ...
-    @resource_actions = [["Edit", { :action => "edit", :layout => 'admin/headless' }, { :class => 'iframe' }],
-                         ["Unrelate", { :resource_id => @item.id,
-                                        :resource => @resource.model_name,
-                                        :action => "unrelate"},
-                                      { :confirm =>"Unrelate?" }]]
-
-    locals = { :association_name => @association_name, :add_new => build_add_new, :table => build_relationship_table }
-    render "admin/templates/has_n", locals
+  def typus_has_and_belongs_to_many_field(attribute, form)
+    klass = attribute.singularize.capitalize.constantize
+    resource_ids = "#{attribute.singularize}_ids"
+
+    html_options = { :disabled => attribute_disabled?(resource_ids.to_sym) }
+
+    label_text = @resource.human_attribute_name(attribute)
+    if (text = build_label_text_for_has_and_belongs_to_many(klass, html_options))
+      label_text += "<small>#{text}</small>"
+    end
+
+    locals = { :attribute => attribute,
+               :attribute_id => "#{@resource.table_name}_#{attribute}",
+               :related_klass => klass,
+               :related_items => klass.all,
+               :related_ids => "#{@resource.name.downcase}[#{resource_ids}][]",
+               :values => @item.send(attribute),
+               :form => form,
+               :label_text => label_text.html_safe,
+               :html_options => html_options }
+
+    render "admin/templates/has_and_belongs_to_many", locals
+  end
+
+  def build_label_text_for_has_and_belongs_to_many(klass, html_options)
+    if html_options[:disabled] == true
+      Typus::I18n.t("Read only")
+=begin
+    # TODO: Take this back at some point in the future. Adding a new item
+    #       using the pop-up should update the items on the selector. I know
+    #       this might be the most trivial thing in the world, but I don't
+    #       know how to do it.
+    elsif admin_user.can?('create', klass) && !headless_mode?
+      build_add_new_for_has_and_belongs_to_many(klass)
+=end
+    end
+  end
+
+  def build_add_new_for_has_and_belongs_to_many(klass)
+    options = { :controller => "/admin/#{klass.to_resource}",
+                :action => "new",
+                :layout => "admin/headless",
+                :return_to => request.path }
+
+    link_to Typus::I18n.t("Add New"), options, { :class => "iframe" }
   end
 
 end

data/app/helpers/admin/resources/data_types/has_many_helper.rb

@@ -14,30 +14,38 @@ module Admin::Resources::DataTypes::HasManyHelper
   def typus_form_has_many(field)
     setup_relationship(field)
 
-    options = @reflection.through_reflection ? {} : { @reflection.foreign_key => @item.id }
+    options = { @reflection.foreign_key => @item.id }
+
+    if @reflection.options && (as = @reflection.options[:as])
+      klass = @resource.is_sti? ? @resource.superclass : @resource
+      options.merge!("#{as}_type" => klass)
+    end
 
     count_items_to_relate = @model_to_relate.order(@model_to_relate.typus_order_by).count - @item.send(field).count
 
     build_pagination
+    set_has_many_resource_actions
+
+    locals = { :association_name => @association_name,
+               :add_new => build_add_new_for_has_many(@model_to_relate, field, options),
+               :table => build_relationship_table }
+
+    render "admin/templates/has_many", locals
+  end
+
+  def build_add_new_for_has_many(klass, field, options = {})
+    if admin_user.can?("create", klass)
+      default_options = { :controller => "/admin/#{klass.to_resource}",
+                          :action => "new",
+                          :layout => "admin/headless" }
+
+      link_to Typus::I18n.t("Add New"), default_options.merge(options), { :class => "iframe_with_reload" }
+    end
+  end
 
-    # If we are on a through_reflection set the association name!
-    @resource_actions = if @reflection.through_reflection
-                          [["Edit", { :action => "edit", :layout => 'admin/headless' }, { :class => 'iframe' }],
-                           ["Unrelate", { :resource_id => @item.id,
-                                          :resource => @resource.model_name,
-                                          :action => "unrelate",
-                                          :association_name => @association_name},
-                                        { :confirm => "Unrelate?" } ]]
-                        else
-                          [["Edit", { :action => "edit", :layout => 'admin/headless' }, { :class => 'iframe' }],
-                           ["Trash", { :resource_id => @item.id,
-                                       :resource => @resource.model_name,
-                                       :action => "destroy" },
-                                     { :confirm => "Trash?" } ]]
-                         end
-
-    locals = { :association_name => @association_name, :add_new => build_add_new(options), :table => build_relationship_table }
-    render "admin/templates/has_n", locals
+  def set_has_many_resource_actions
+    @resource_actions = [["Edit", { :action => "edit", :layout => 'admin/headless' }, { :class => 'iframe' }],
+                         ["Trash", { :action => "destroy" }, { :confirm => "Trash?" } ]]
   end
 
 end

data/app/helpers/admin/resources/data_types/has_one_helper.rb

@@ -3,21 +3,34 @@ module Admin::Resources::DataTypes::HasOneHelper
   def typus_form_has_one(field)
     setup_relationship(field)
 
-    @items = Array.new
-    if item = @item.send(field)
-      @items << item
+    related_items = @item.send(field)
+    @items =  related_items ? [related_items] : []
+
+    set_has_one_resource_actions
+
+    locals = { :association_name => @association_name, :table => build_relationship_table, :add_new => nil }
+
+    if @items.empty?
+      options = { :resource_id => nil, @reflection.foreign_key => @item.id }
+      locals[:add_new] = build_add_new_for_has_one(@model_to_relate, field, options)
     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?" }]]
+    render "admin/templates/has_one", locals
+  end
 
-    options = { :resource_id => nil, @reflection.foreign_key => @item.id }
+  def build_add_new_for_has_one(klass, field, options = {})
+    if admin_user.can?("create", klass)
+      default_options = { :controller => "/admin/#{klass.to_resource}",
+                          :action => "new",
+                          :layout => "admin/headless" }
+
+      link_to Typus::I18n.t("Add New"), default_options.merge(options), { :class => "iframe" }
+    end
+  end
 
-    render "admin/templates/has_one",
-           :association_name => @association_name,
-           :add_new => @items.empty? ? build_add_new(options) : nil,
-           :table => build_relationship_table
+  def set_has_one_resource_actions
+    @resource_actions = [["Edit", { :action => "edit" }, {}],
+                         ["Trash", { :action => "destroy" }, { :confirm => "Trash?" }]]
   end
 
 end

data/app/helpers/admin/resources/data_types/paperclip_helper.rb

@@ -1,7 +1,7 @@
 module Admin::Resources::DataTypes::PaperclipHelper
 
   def table_paperclip_field(attribute, item)
-    options = { :height => 25, :width => 25 }
+    options = { :width => 25 }
     typus_paperclip_preview(item, attribute, options)
   end
 

data/app/helpers/admin/resources/data_types/string_helper.rb

@@ -19,7 +19,7 @@ module Admin::Resources::DataTypes::StringHelper
   end
 
   def table_string_field(attribute, item)
-    (raw_content = item.send(attribute)).present? ? raw_content : "—".html_safe
+    (raw_content = item.send(attribute)).present? ? raw_content : mdash
   end
 
   alias_method :table_decimal_field, :table_string_field

data/app/helpers/admin/resources/data_types/text_helper.rb

@@ -1,7 +1,7 @@
 module Admin::Resources::DataTypes::TextHelper
 
   def table_text_field(attribute, item)
-    (raw_content = item.send(attribute)).present? ? truncate(raw_content) : "—".html_safe
+    (raw_content = item.send(attribute)).present? ? truncate(raw_content) : mdash
   end
 
 end

data/app/helpers/admin/resources/data_types/transversal_helper.rb

@@ -2,7 +2,7 @@ module Admin::Resources::DataTypes::TransversalHelper
 
   def table_transversal_field(attribute, item)
     field_1, field_2 = attribute.split(".")
-    (related_item = item.send(field_1)) ? related_item.send(field_2) : "—".html_safe
+    (related_item = item.send(field_1)) ? related_item.send(field_2) : mdash
   end
 
 end

data/app/helpers/admin/resources/data_types/tree_helper.rb

@@ -1,7 +1,7 @@
 module Admin::Resources::DataTypes::TreeHelper
 
   def table_tree_field(attribute, item)
-    item.parent ? item.parent.to_label : "—".html_safe
+    item.parent ? item.parent.to_label : mdash
   end
 
   def typus_tree_field(attribute, form)

data/app/helpers/admin/resources/display_helper.rb

@@ -1,13 +1,13 @@
 module Admin::Resources::DisplayHelper
 
+  def mdash
+    "—".html_safe
+  end
+
   def build_display(item, fields)
     fields.map do |attribute, type|
-      value = if (type == :boolean) || (data = item.send(attribute)).present?
-                send("display_#{type}", item, attribute)
-              else
-                "—".html_safe
-              end
-
+      condition = (type == :boolean) || item.send(attribute).present?
+      value = condition ? send("display_#{type}", item, attribute) : mdash
       [@resource.human_attribute_name(attribute), value]
     end
   end
@@ -16,9 +16,10 @@ module Admin::Resources::DisplayHelper
     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.constantize)
-        html << send("typus_form_#{association.macro}", relationship)
+        macro, klass = association.macro, association.class_name.constantize
+        if [:has_many, :has_one].include?(macro) && admin_user.can?('read', klass)
+          html << send("typus_form_#{macro}", relationship)
+        end
       end
     end.html_safe
   end

data/app/helpers/admin/resources/filters_helper.rb

@@ -5,18 +5,11 @@ module Admin::Resources::FiltersHelper
       locals = {}
 
       locals[:filters] = typus_filters.map do |key, value|
-                           { :filter => set_filter(key, value), :items => send("#{value}_filter", key) }
+                           { :key => set_filter(key, value), :value => send("#{value}_filter", key) }
                          end
 
-      locals[:hidden_filters] = params.dup
-
-      # Remove default params.
-      rejections = %w(controller action locale utf8 sort_order order_by)
-      locals[:hidden_filters].delete_if { |k, v| rejections.include?(k) }
-
-      # Remove also custom params.
-      rejections = locals[:filters].map { |f| f[:filter] }
-      locals[:hidden_filters].delete_if { |k, v| rejections.include?(k) }
+      rejections = %w(controller action locale utf8 sort_order order_by) + locals[:filters].map { |f| f[:key] }
+      locals[:hidden_filters] = params.dup.delete_if { |k, v| rejections.include?(k) }
 
       render "helpers/admin/resources/filters", locals
     end

data/app/helpers/admin/resources/form_helper.rb

@@ -13,6 +13,8 @@ module Admin::Resources::FormHelper
                   typus_template_field(key, value, form)
                 when :template
                   typus_template_field(key, template, form)
+                when :has_and_belongs_to_many
+                  typus_has_and_belongs_to_many_field(key, form)
                 else
                   typus_template_field(key, :string, form)
                 end
@@ -29,13 +31,21 @@ module Admin::Resources::FormHelper
 
     html_options = attribute_disabled?(attribute) ? { :disabled => 'disabled' } : {}
 
+    label_text = @resource.human_attribute_name(attribute)
+
+=begin
+    if options[:disabled] == true
+      label_text += "<small>#{Typus::I18n.t("Read only")}</small>"
+    end
+=end
+
     locals = { :resource => @resource,
                :attribute => attribute,
                :attribute_id => "#{@resource.table_name}_#{attribute}",
                :options => options,
                :html_options => html_options,
                :form => form,
-               :label_text => @resource.human_attribute_name(attribute) }
+               :label_text => label_text.html_safe }
 
     render "admin/templates/#{template}", locals
   end
@@ -59,7 +69,7 @@ module Admin::Resources::FormHelper
 
   def save_options_for_headless_mode
     return unless headless_mode?
-    params[:resource] ? { "_saveandassign" => "Save and assign" } : { "_continue" => "Save and continue editing" }
+    { "_continue" => "Save and continue editing" }
   end
 
   def save_options_for_user_class