typus 3.1.0.rc6 → 3.1.0.rc7

data/app/helpers/admin/display_helper.rb

@@ -1,51 +0,0 @@
-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
-    alias_method :display_integer, :display_string
-    alias_method :display_decimal, :display_string
-
-  end
-end

data/app/helpers/admin/file_preview_helper.rb

@@ -1,80 +0,0 @@
-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 }.flatten.map { |i| i.to_s }
-
-      attachment = @item.send(attribute)
-
-      # We are here and we already know we are handling attachments, but
-      # `dragonfly` and `paperclip` have different behaviors.
-
-      if defined?(Paperclip)
-        present = case attachment
-                  when Paperclip::Attachment
-                    attachment.exists?
-                  else
-                    attachment.present?
-                  end
-      else
-        present = attachment.present?
-      end
-
-      field = case get_type_of_attachment(attachment)
-              when :dragonfly then attribute
-              when :paperclip then "#{attribute}_file_name"
-              end
-
-      if present && !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 => '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, options = {})
-      if (attachment = item.send(attribute))
-        adapter = get_type_of_attachment(attachment)
-        send("typus_file_preview_for_#{adapter}", attachment, options)
-      end
-    end
-
-    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,
-               :options => options
-      else
-        link_to attachment.name, attachment.url
-      end
-    end
-
-    def typus_file_preview_for_paperclip(attachment, options = {})
-      return unless attachment.exists?
-
-      styles = attachment.styles.keys
-      if attachment.content_type =~ /^image\/.+/ && 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),
-               :options => options
-      else
-        link_to attachment.original_filename, attachment.url(:original, false)
-      end
-    end
-
-  end
-end

data/app/helpers/admin/filters_helper.rb

@@ -1,94 +0,0 @@
-module Admin
-  module FiltersHelper
-
-    def build_filters(resource = @resource, params = params)
-      typus_filters = resource.typus_filters
-
-      return if typus_filters.empty?
-
-      filters = typus_filters.map do |key, value|
-                  items = case value
-                          when :boolean then boolean_filter(key)
-                          when :string then string_filter(key)
-                          when :date, :datetime, :timestamp 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
-
-      hidden_filters = params.dup
-
-      # Remove default params.
-      rejections = %w(controller action locale utf8 sort_order order_by)
-      hidden_filters.delete_if { |k, v| rejections.include?(k) }
-
-      # Remove also custom params.
-      rejections = filters.map { |i| i[:filter] }
-      hidden_filters.delete_if { |k, v| rejections.include?(k) }
-
-      render "admin/helpers/filters/filters", :filters => filters, :hidden_filters => hidden_filters
-    end
-
-    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.foreign_key
-      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] || filter.capitalize.camelize
-      resource = class_name.typus_constantize
-
-      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 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
-
-      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(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(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(filter)
-      values = set_context.send(filter.to_s).to_a
-
-      items = [[Typus::I18n.t("Show by %{attribute}", :attribute => @resource.human_attribute_name(filter).downcase), ""]]
-      array = values.first.is_a?(Array) ? values : values.map { |i| [i, i] }
-      items += array
-    end
-
-    def predefined_filters
-      @predefined_filters ||= []
-    end
-
-  end
-end

data/app/helpers/admin/form_helper.rb

@@ -1,78 +0,0 @@
-module Admin
-  module FormHelper
-
-    def build_form(fields, form)
-      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
-      end.html_safe
-    end
-
-    def typus_tree_field(attribute, form)
-      locals = { :attribute => attribute,
-                 :form => form,
-                 :label_text => @resource.human_attribute_name(attribute),
-                 :values => expand_tree_into_select_field(@resource.roots, "parent_id") }
-
-      render "admin/templates/tree", locals
-    end
-
-    def typus_relationships
-      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 << send("typus_form_#{association.macro}", relationship)
-        end
-      end.html_safe
-    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),
-                  :include_blank => true }
-
-      locals = { :resource => @resource,
-                 :attribute => attribute,
-                 :options => options,
-                 :html_options => {},
-                 :form => form,
-                 :label_text => @resource.human_attribute_name(attribute) }
-
-      render "admin/templates/#{template}", locals
-    end
-
-    def attribute_disabled?(attribute)
-      @resource.protected_attributes.include?(attribute)
-    end
-
-    ##
-    # Tree builder when model +acts_as_tree+
-    #
-    def expand_tree_into_select_field(items, attribute)
-      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
-    end
-
-  end
-end

data/app/helpers/admin/list_helper.rb

@@ -1,29 +0,0 @@
-module Admin
-  module ListHelper
-
-    def resources_actions
-      @resources_actions ||= []
-    end
-
-    def list_actions
-      resources_actions.map do |body, url, options|
-        if admin_user.can?(url[:action], @resource.name)
-          path = params.dup.merge!(url).compact.cleanup
-          link_to Typus::I18n.t(body), path, options
-        end
-      end.compact.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
-end

data/app/helpers/admin/relationships_helper.rb

@@ -1,192 +0,0 @@
-module Admin
-  module RelationshipsHelper
-
-    def setup_relationship(field)
-      @field = field
-      @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.name.to_s
-    end
-
-    def typus_form_has_many(field)
-      setup_relationship(field)
-
-      options = @reflection.through_reflection ? {} : { @reflection.foreign_key => @item.id }
-
-      count_items_to_relate = @model_to_relate.order(@model_to_relate.typus_order_by).count - @item.send(field).count
-
-      if set_condition && !count_items_to_relate.zero?
-        form = if Typus.autocomplete && (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
-
-      locals = { :association_name => @association_name,
-                 :add_new => build_add_new(options),
-                 :form => form,
-                 :table => build_relationship_table }
-
-      render "admin/templates/has_n", locals
-    end
-
-    def typus_form_has_and_belongs_to_many(field)
-      setup_relationship(field)
-
-      count_items_to_relate = @model_to_relate.order(@model_to_relate.typus_order_by).count - @item.send(field).count
-
-      if set_condition && !count_items_to_relate.zero?
-        form = if Typus.autocomplete && (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?"}]]
-
-      locals = { :association_name => @association_name,
-                 :add_new => build_add_new,
-                 :form => form,
-                 :table => build_relationship_table }
-
-      render "admin/templates/has_n", locals
-    end
-
-    def build_pagination
-      items_per_page = @model_to_relate.typus_options_for(:per_page)
-      data = @item.send(@field).order(@model_to_relate.typus_order_by).where(set_conditions)
-      @items = data.page(params[:page]).per(items_per_page)
-    end
-
-    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
-      build_list(@model_to_relate,
-                 @model_to_relate.typus_fields_for(:relationship),
-                 @items,
-                 @model_to_relate_as_resource,
-                 {},
-                 @reflection.macro,
-                 @association_name)
-    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 }
-
-      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? && admin_user.is_not_root?
-        admin_user.owns?(@item)
-      else
-        true
-      end
-    end
-
-    def set_conditions
-      if @model_to_relate.typus_options_for(:only_user_items) && admin_user.is_not_root?
-        { Typus.user_foreign_key => admin_user }
-      end
-    end
-
-    def typus_form_has_one(field)
-      setup_relationship(field)
-
-      @items = Array.new
-      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.foreign_key => @item.id }
-
-      render "admin/templates/has_one",
-             :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)
-      association = @resource.reflect_on_association(attribute.to_sym)
-      related = if defined?(set_belongs_to_context)
-                  set_belongs_to_context.send(attribute.pluralize.to_sym)
-                else
-                  association.class_name.typus_constantize
-                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 }
-        # 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
-      end
-
-      # Set the template.
-      template = if Typus.autocomplete && (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 Typus.autocomplete && !(related.count > Typus.autocomplete)
-                 related.order(related.typus_order_by).map { |p| [p.to_label, p.id] }
-               end
-
-      render template,
-             :association => association,
-             :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) },
-             :options => { :include_blank => true }
-    end
-
-  end
-end

data/app/helpers/admin/search_helper.rb

@@ -1,16 +0,0 @@
-module Admin
-  module SearchHelper
-
-    def search(resource = @resource, params = params)
-      if (typus_search = resource.typus_defaults_for(:search)) && typus_search.any?
-
-        hidden_filters = params.dup
-        rejections = %w(controller action locale utf8 sort_order order_by search page)
-        hidden_filters.delete_if { |k, v| rejections.include?(k) }
-
-        render "admin/helpers/search/search", :hidden_filters => hidden_filters
-      end
-    end
-
-  end
-end

data/app/helpers/admin/sidebar_helper.rb

@@ -1,36 +0,0 @@
-module Admin
-  module SidebarHelper
-
-    def build_sidebar
-      resources = ActiveSupport::OrderedHash.new
-      app_name = @resource.typus_application
-
-      admin_user.application(app_name).sort {|a,b| a.typus_constantize.model_name.human <=> b.typus_constantize.model_name.human}.each do |resource|
-        klass = resource.typus_constantize
-
-        resources[resource] = default_actions(klass)
-        resources[resource] += custom_actions(klass)
-
-        resources[resource].compact!
-      end
-
-      render "admin/helpers/sidebar/sidebar", :resources => resources
-    end
-
-    def default_actions(klass)
-      Array.new.tap do |tap|
-        tap << link_to_unless_current(Typus::I18n.t("All #{klass.model_name.human.pluralize}"), :action => "index")
-        tap << link_to_unless_current(Typus::I18n.t("Add New"), :action => "new") if admin_user.can?("create", klass)
-      end
-    end
-
-    def custom_actions(klass)
-      klass.typus_actions_on(params[:action]).map do |action|
-        if admin_user.can?(action, klass)
-          link_to_unless_current(Typus::I18n.t(action.humanize), params.merge(:action => action))
-        end
-      end
-    end
-
- end
-end