typus 3.0.2 → 3.0.4

data/app/controllers/admin/session_controller.rb

@@ -1,8 +1,8 @@
 class Admin::SessionController < Admin::BaseController
 
   skip_before_filter :reload_config_and_roles
-  skip_before_filter :set_preferences
   skip_before_filter :authenticate
+  skip_before_filter :set_locale
 
   before_filter :create_an_account?, :except => [:destroy]
 
@@ -12,15 +12,14 @@ class Admin::SessionController < Admin::BaseController
   def create
     user = Typus.user_class.authenticate(params[:typus_user][:email], params[:typus_user][:password])
 
-    if user
-      session[:typus_user_id] = user.id
-      path = params[:back_to] || admin_dashboard_path
-    else
-      alert = _t("The email and/or password you entered is invalid.")
-      path = new_admin_session_path(:back_to => params[:back_to])
-    end
+    path = if user
+             session[:typus_user_id] = user.id
+             params[:back_to] || admin_dashboard_path
+           else
+             new_admin_session_path(:back_to => params[:back_to])
+           end
 
-    redirect_to path, :alert => alert
+    redirect_to path
   end
 
   def destroy

data/app/helpers/admin/base_helper.rb

@@ -2,16 +2,6 @@ module Admin
 
   module BaseHelper
 
-    def typus_render(*args)
-      options = args.extract_options!
-      options[:resource] ||= @resource.to_resource
-
-      template_file = Rails.root.join("app", "views", "admin", options[:resource], "_#{options[:partial]}.html.erb")
-      resource = File.exists?(template_file) ? options[:resource] : "resources"
-
-      render "admin/#{resource}/#{options[:partial]}", :options => options
-    end
-
     def title(page_title)
       content_for(:title) { page_title }
     end
@@ -20,33 +10,28 @@ module Admin
       render "admin/helpers/header"
     end
 
+    def has_root_path?
+      Rails.application.routes.routes.map(&:name).include?("root")
+    end
+
     def apps
       render "admin/helpers/apps"
     end
 
     def login_info
-      return if [:none, :http_basic].include?(Typus.authentication)
-
-      admin_edit_typus_user_path = { :controller => "/admin/#{Typus.user_class.to_resource}",
-                                     :action => 'edit',
-                                     :id => current_user.id }
-
-      message = _t("Are you sure you want to sign out and end your session?")
-
-      user_details = if current_user.can?('edit', Typus.user_class_name)
-                       link_to current_user.name, admin_edit_typus_user_path
-                     else
-                       current_user.name
-                     end
-
-      render "admin/helpers/login_info", :message => message, :user_details => user_details
+      unless admin_user.is_a?(FakeUser)
+        render "admin/helpers/login_info"
+      end
     end
 
     def display_flash_message(message = flash)
-      return if message.empty?
-      render "admin/helpers/flash_message", :flash_type => message.keys.first, :message => message
+      if message.compact.any?
+        render "admin/helpers/flash_message",
+               :flash_type => message.keys.first,
+               :message => message
+      end
     end
 
   end
 
-end
+end

data/app/helpers/admin/dashboard_helper.rb

@@ -3,20 +3,14 @@ module Admin
   module DashboardHelper
 
     def applications
-      render File.join(path, "applications")
+      render "admin/helpers/dashboard/applications"
     end
 
-    def resources(current_user)
+    def resources(admin_user)
       available = Typus.resources.map do |resource|
-                    resource if current_user.resources.include?(resource)
+                    resource if admin_user.resources.include?(resource)
                   end.compact
-      render File.join(path, "resources"), :resources => available
-    end
-
-    private
-
-    def path
-      "admin/helpers/dashboard"
+      render "admin/helpers/dashboard/resources", :resources => available
     end
 
   end

data/app/helpers/admin/file_preview_helper.rb

@@ -0,0 +1,70 @@
+module Admin
+
+  module FilePreviewHelper
+
+    def get_type_of_attachment(attachment)
+      if defined?(Paperclip) && attachment.is_a?(Paperclip::Attachment)
+        :paperclip
+      elsif defined?(Dragonfly) && attachment.is_a?(Dragonfly::ActiveModelExtensions::Attachment)
+        :dragonfly
+      end
+    end
+
+    def link_to_detach_attribute(attribute)
+      validators = @item.class.validators.delete_if { |i| i.class != ActiveModel::Validations::PresenceValidator }.map { |i| i.attributes.to_s }.flatten
+
+      attachment = @item.send(attribute)
+
+      field = case get_type_of_attachment(attachment)
+                 when :dragonfly then attribute
+                 when :paperclip then "#{attribute}_file_name"
+                 end
+
+      if !validators.include?(field) && attachment
+        attribute_i18n = @item.class.human_attribute_name(attribute)
+        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>
+        HTML
+        label_text.html_safe
+      end
+    end
+
+    def typus_file_preview(item, attribute)
+      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
+      end
+    end
+
+    def typus_file_preview_for_dragonfly(attachment)
+      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
+      else
+        link_to attachment.name, attachment.url
+      end
+    end
+
+    def typus_file_preview_for_paperclip(attachment)
+      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)
+        else
+          link_to attachment.original_filename, attachment.url(:original, false)
+        end
+      end
+    end
+
+  end
+
+end

data/app/helpers/admin/filters_helper.rb

@@ -7,24 +7,19 @@ module Admin
 
       return if typus_filters.empty?
 
-      current_request = request.env['QUERY_STRING'] || []
-
       filters = typus_filters.map do |key, value|
-        filter, items, message = case value
-                                 when :boolean then boolean_filter(current_request, key)
-                                 when :string then string_filter(current_request, key)
-                                 when :date, :datetime then date_filter(current_request, key)
-                                 when :belongs_to then relationship_filter(current_request, key)
-                                 when :has_many, :has_and_belongs_to_many then
-                                   relationship_filter(current_request, key, true)
-                                 # when nil then
-                                     # Do nothing. This is ugly but for now it's ok.
-                                 else
-                                   string_filter(current_request, key)
-                                 end
-
-        items = items.to_a
-        items.insert(0, [message, ""])
+                  items = case value
+                          when :boolean then boolean_filter(key)
+                          when :string then string_filter(key)
+                          when :date, :datetime then date_filter(key)
+                          when :belongs_to then belongs_to_filter(key)
+                          when :has_many, :has_and_belongs_to_many then
+                            has_many_filter(key)
+                          else
+                            string_filter(key)
+                          end
+
+                  filter = set_filter(key, value)
 
         { :filter => filter, :items => items }
       end
@@ -32,46 +27,70 @@ module Admin
       render "admin/helpers/filters/filters", :filters => filters
     end
 
-    def relationship_filter(request, filter, habtm = false)
+    def set_filter(key, value)
+      case value
+      when :belongs_to
+        att_assoc = @resource.reflect_on_association(key.to_sym)
+        class_name = att_assoc.options[:class_name] || key.capitalize.camelize
+        resource = class_name.typus_constantize
+        att_assoc.primary_key_name
+      else
+        key
+      end
+    end
+
+    def belongs_to_filter(filter)
       att_assoc = @resource.reflect_on_association(filter.to_sym)
-      class_name = att_assoc.options[:class_name] || ((habtm) ? filter.classify : filter.capitalize.camelize)
-      model = class_name.constantize
-      related_fk = (habtm) ? filter : att_assoc.primary_key_name
+      class_name = att_assoc.options[:class_name] || filter.capitalize.camelize
+      resource = class_name.typus_constantize
 
-      params_without_filter = params.dup
-      %w(controller action page).each { |p| params_without_filter.delete(p) }
-      params_without_filter.delete(related_fk)
+      items = [[Typus::I18n.t("View belongs all %{attribute}", :attribute => @resource.human_attribute_name(filter).downcase.pluralize), ""]]
+      items += resource.order(resource.typus_order_by).map { |v| [v.to_label, v.id] }
+    end
 
-      items = model.all(:order => model.typus_order_by).collect{|v| [v.to_label, v.id] }
-      message = _t("View all %{attribute}", :attribute => @resource.human_attribute_name(filter).downcase.pluralize)
+    def has_many_filter(filter)
+      att_assoc = @resource.reflect_on_association(filter.to_sym)
+      class_name = att_assoc.options[:class_name] || filter.classify
+      resource = class_name.typus_constantize
 
-      return related_fk, items, message
+      items = [[Typus::I18n.t("View all %{attribute}", :attribute => @resource.human_attribute_name(filter).downcase.pluralize), ""]]
+      items += resource.order(resource.typus_order_by).map { |v| [v.to_label, v.id] }
     end
 
-    def date_filter(request, filter)
-      values  = %w(today last_few_days last_7_days last_30_days)
-      items = values.collect {|v| [_t(v.humanize), v ] }
-      message = _t("Show all dates")
-      return filter, items, message
+    def date_filter(filter)
+      values = %w(today last_few_days last_7_days last_30_days)
+      items = [[Typus::I18n.t("Show all dates"), ""]]
+      items += values.map { |v| [Typus::I18n.t(v.humanize), v] }
     end
 
-    def boolean_filter(request, filter)
-      items   = @resource.typus_boolean(filter)
-      message = _t("Show by %{attribute}", :attribute => @resource.human_attribute_name(filter).downcase)
-      return filter, items, message
+    def boolean_filter(filter)
+      values  = @resource.typus_boolean(filter)
+      items = [[Typus::I18n.t("Show by %{attribute}", :attribute => @resource.human_attribute_name(filter).downcase), ""]]
+      items += values.map { |k, v| [Typus::I18n.t(k.humanize), v] }
     end
 
-    def string_filter(request, filter)
-      values  = @resource::const_get(filter.to_s.upcase)
-      items   = values.kind_of?(Hash) ? values : values.to_hash_with(values)
-      message = _t("Show by %{attribute}", :attribute => @resource.human_attribute_name(filter).downcase)
-      return filter, items, message
+    def string_filter(filter)
+      values = @resource::const_get(filter.to_s.upcase)
+
+      items = [[Typus::I18n.t("Show by %{attribute}", :attribute => @resource.human_attribute_name(filter).downcase), ""]]
+
+      array = case values
+              when Hash
+                values
+              when Array
+                if values.first.is_a?(Array)
+                  keys, values = values.map { |i| i.first }, values.map { |i| i.last }
+                  keys.to_hash_with(values)
+                else
+                  values.to_hash_with(values)
+                end
+              end
+
+      items += array.to_a
     end
 
-    def remove_filter_link(filter = request.env['QUERY_STRING'])
-      return unless filter && !filter.blank?
-      message = params.compact.include?(:search) ? "search" : "filter"
-      link_to _t("Remove #{message}")
+    def predefined_filters
+      @predefined_filters ||= [["All", "index", "unscoped"]]
     end
 
   end

data/app/helpers/admin/form_helper.rb

@@ -3,29 +3,23 @@ module Admin
   module FormHelper
 
     def build_form(fields, form)
-      html = ""
-
-      fields.each do |key, value|
-
-        if template = @resource.typus_template(key)
-          html << typus_template_field(key, template, form)
-          next
+      String.new.tap do |html|
+        fields.each do |key, value|
+          value = :template if (template = @resource.typus_template(key))
+          html << case value
+                  when :belongs_to
+                    typus_belongs_to_field(key, form)
+                  when :tree
+                    typus_tree_field(key, form)
+                  when :boolean, :date, :datetime, :file, :text, :time, :password, :selector
+                    typus_template_field(key, value, form)
+                  when :template
+                    typus_template_field(key, template, form)
+                  else
+                    typus_template_field(key, :string, form)
+                  end
         end
-
-        html << case value
-                when :belongs_to
-                  typus_belongs_to_field(key, form)
-                when :tree
-                  typus_tree_field(key, form)
-                when :boolean, :date, :datetime, :string, :text, :time,
-                     :file, :password, :selector
-                  typus_template_field(key, value, form)
-                else
-                  typus_template_field(key, :string, form)
-                end
       end
-
-      return html
     end
 
     def typus_tree_field(attribute, form)
@@ -36,44 +30,33 @@ module Admin
              :values => expand_tree_into_select_field(@resource.roots, "parent_id")
     end
 
-    # OPTIMIZE: Cleanup the case statement.
+    # 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])
 
-      html = ""
-
-      @resource.typus_defaults_for(:relationships).each do |relationship|
-
-        association = @resource.reflect_on_association(relationship.to_sym)
-
-        next if current_user.cannot?('read', association.class_name.constantize)
-
-        case association.macro
-        when :has_and_belongs_to_many
-          html << typus_form_has_and_belongs_to_many(relationship)
-        when :has_many
-          if association.options[:through]
-            # Here we will shot the relationship. Better this than raising an error.
-          else
-            html << typus_form_has_many(relationship)
-          end
-        when :has_one
-          html << typus_form_has_one(relationship)
+      String.new.tap do |html|
+        @resource.typus_defaults_for(:relationships).each do |relationship|
+          association = @resource.reflect_on_association(relationship.to_sym)
+          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
         end
-
       end
-
-      return html
-
     end
 
     def typus_template_field(attribute, template, form)
-
       options = { :start_year => @resource.typus_options_for(:start_year),
                   :end_year => @resource.typus_options_for(:end_year),
                   :minute_step => @resource.typus_options_for(:minute_step),
-                  # :disabled => attribute_disabled?(attribute),
+                  :disabled => attribute_disabled?(attribute),
                   :include_blank => true }
 
       render "admin/templates/#{template}",
@@ -83,30 +66,22 @@ module Admin
              :html_options => {},
              :form => form,
              :label_text => @resource.human_attribute_name(attribute)
-
     end
 
-=begin
-
-    # TODO: Take `attribute_disabled?(attribute)` back.
     def attribute_disabled?(attribute)
-      accessible = @resource.accessible_attributes
-      return accessible.nil? ? false : !accessible.include?(attribute)
+      @resource.protected_attributes.include?(attribute)
     end
-=end
 
     ##
     # Tree builder when model +acts_as_tree+
     #
     def expand_tree_into_select_field(items, attribute)
-      html = ""
-
-      items.each do |item|
-        html << %{<option #{"selected" if @item.send(attribute) == item.id} value="#{item.id}">#{"&nbsp;" * item.ancestors.size * 2} &#8627; #{item.to_label}</option>\n}
-        html << expand_tree_into_select_field(item.children, attribute) unless item.children.empty?
+      String.new.tap do |html|
+        items.each do |item|
+          html << %{<option #{"selected" if @item.send(attribute) == item.id} value="#{item.id}">#{"&nbsp;" * item.ancestors.size * 2} #{item.to_label}</option>\n}
+          html << expand_tree_into_select_field(item.children, attribute) unless item.children.empty?
+        end
       end
-
-      return html
     end
 
   end