brainsome_typus 4.0.0.beta1

data/app/controllers/concerns/admin/navigation.rb

@@ -0,0 +1,26 @@
+require 'active_support/concern'
+
+module Admin
+  module Navigation
+
+    extend ActiveSupport::Concern
+
+    included do
+      before_filter :set_resources_action_on_lists, :only => [:index, :trash]
+      before_filter :set_resources_action, :only => [:new, :create, :edit, :show]
+    end
+
+    def set_resources_action_on_lists
+      add_resources_action("Add", {:action => "new"})
+    end
+    private :set_resources_action_on_lists
+
+    def set_resources_action
+      unless params[:_popup] && !params[:_input]
+        add_resources_action('Back to list', {:action => 'index', :id => nil})
+      end
+    end
+    private :set_resources_action
+
+  end
+end

data/app/controllers/concerns/admin/trash.rb

@@ -0,0 +1,65 @@
+# Module designed to work with `rails-trash`.
+
+require 'active_support/concern'
+
+module Admin
+  module Trash
+
+    extend ActiveSupport::Concern
+
+    included do
+      before_filter :set_predefined_filter_for_trash, :only => [:index, :trash]
+    end
+
+    def set_predefined_filter_for_trash
+      if admin_user.can?('edit', @resource.model_name)
+        add_predefined_filter("Trash", "trash", "deleted")
+      end
+    end
+    private :set_predefined_filter_for_trash
+
+    def trash
+      set_deleted
+
+      get_objects
+
+      respond_to do |format|
+        format.html do
+          # Actions by resource.
+          add_resource_action 'Restore', { :action => 'restore' }, { :data => { :confirm => Typus::I18n.t("Restore %{resource}?", :resource => @resource.model_name.human) } }
+          add_resource_action 'Delete Permanently', { :action => 'wipe' }, { :data => { :confirm => Typus::I18n.t("Delete Permanently?") } }
+          # Generate and render.
+          get_paginated_data
+          render 'index'
+        end
+
+        format.csv { generate_csv }
+        format.json { export(:json) }
+        format.xml { export(:xml) }
+      end
+    end
+
+    def restore
+      begin
+        @resource.restore(params[:id])
+        message = "%{resource} recovered from trash."
+      rescue ActiveRecord::RecordNotFound
+        message = "%{resource} can't be recovered from trash."
+      end
+
+      redirect_to :back, :notice => Typus::I18n.t(message, :resource => @resource.model_name.human)
+    end
+
+    def wipe
+      item = @resource.find_in_trash(params[:id])
+      item.disable_trash { item.destroy }
+      redirect_to :back, :notice => Typus::I18n.t("%{resource} has been successfully removed from trash.", :resource => @resource.model_name.human)
+    end
+
+    def set_deleted
+      @resource = @resource.deleted
+    end
+    private :set_deleted
+
+  end
+end

data/app/helpers/admin/base_helper.rb

@@ -0,0 +1,59 @@
+module Admin::BaseHelper
+
+  def admin_title(page_title = nil)
+    if page_title
+      content_for(:title) { page_title }
+    else
+      setting = defined?(Admin::Setting) && Admin::Setting.admin_title
+      setting || Typus.admin_title
+    end
+  end
+
+  def admin_sign_out_path
+    case Typus.authentication
+    when :devise
+      send("destroy_#{Typus.user_class_name.underscore}_session_path")
+    else
+      destroy_admin_session_path
+    end
+  end
+
+  def admin_edit_user_path(user)
+    { :controller => "/admin/#{Typus.user_class.to_resource}",
+      :action => "edit",
+      :id => user.id }
+  end
+
+  def admin_display_flash_message
+    if flash.any?
+      String.new.tap do |html|
+        flash.each do |type, message|
+          if type == :notice
+            type = 'info'
+          end
+          html << content_tag(:div, message, :id => 'flash', :class => "alert alert-#{type}")
+        end
+      end.html_safe
+    end
+  end
+
+  def set_modal_options_for(klass)
+    { "data-toggle" => "modal",
+      "data-controls-modal" => "modal-from-dom-#{klass.model_name.param_key}",
+      "data-backdrop" => "true",
+      "data-keyboard" => "true",
+      "class" => "ajax-modal",
+      "url" => "override-this" }
+  end
+
+  def body_class
+    if params[:controller] == 'admin/dashboard'
+      "base dashboard #{params[:action].parameterize}"
+    else
+      classes = ['base', params[:action].parameterize]
+      classes << ['resource', @resource.model_name.param_key] if @resource 
+      classes.flatten.join(" ")
+    end
+  end
+
+end

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

@@ -0,0 +1,91 @@
+module Admin::Resources::DataTypes::BelongsToHelper
+
+  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.constantize
+    end
+
+    related_fk = association.foreign_key
+    html_options = {}
+    label_text = @resource.human_attribute_name(attribute)
+    options = { :attribute => "#{@resource.name.underscore}_#{related_fk}" }
+
+    label_text = @resource.human_attribute_name(attribute)
+    if (text = build_label_text_for_belongs_to(related, html_options, options))
+      label_text += " <small>#{text}</small>"
+    end
+
+    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
+
+    attribute_id = "#{@resource.name.underscore}_#{attribute}_id".gsub("/", "_")
+
+    render "admin/templates/belongs_to",
+           :attribute => attribute,
+           :attribute_id => attribute_id,
+           :form => form,
+           :related_fk => related_fk,
+           :related => related,
+           :label_text => label_text.html_safe,
+           :values => values,
+           :html_options => html_options,
+           :options => { :include_blank => true }
+  end
+
+  def table_belongs_to_field(attribute, item)
+    if att_value = item.send(attribute)
+      action = item.send(attribute).class.typus_options_for(:default_action_on_item)
+      message = att_value.to_label
+      if !params[:_popup] && admin_user.can?(action, att_value.class.name)
+        message = link_to(message, :controller => "/admin/#{att_value.class.to_resource}", :action => action, :id => att_value.id)
+      end
+    end
+
+    message || mdash
+  end
+
+  def display_belongs_to(item, attribute)
+    data = item.send(attribute)
+
+    options = {
+      :controller => data.class.to_resource,
+      :action => params[:action],
+      :id => data.id
+    }
+
+    params[:_popup] ? data.to_label : link_to(data.to_label, options)
+  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.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 build_label_text_for_belongs_to(klass, html_options, 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, options)
+    end
+  end
+
+  def build_add_new_for_belongs_to(klass, options)
+    html_options = set_modal_options_for(klass)
+    html_options["data-controls-modal"] = "modal-from-dom-#{options[:attribute]}"
+    html_options["url"] = "/admin/#{klass.to_resource}/new?_popup=true"
+
+    link_to Typus::I18n.t("Add"), { :anchor => html_options['data-controls-modal'] }, html_options
+  end
+
+end

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

@@ -0,0 +1,28 @@
+module Admin::Resources::DataTypes::BooleanHelper
+
+  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 table_boolean_field(attribute, item)
+    status = item.send(attribute)
+    boolean_assoc = item.class.typus_boolean(attribute)
+    human_boolean = (status ? boolean_assoc.rassoc("true") : boolean_assoc.rassoc("false")).first
+
+    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, :data => { :confirm => confirm }
+  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
+
+end

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

@@ -0,0 +1,16 @@
+module Admin::Resources::DataTypes::DateHelper
+
+  def date_filter(filter)
+    values = { :all_day => "Today",
+               :all_week => "This week",
+               :all_month => "This month",
+               :all_year => "This year" }
+
+    items = [[@resource.human_attribute_name(filter).capitalize, ""]]
+    items += values.map { |k, v| [Typus::I18n.t(v), k] }
+  end
+
+  alias_method :datetime_filter, :date_filter
+  alias_method :timestamp_filter, :date_filter
+
+end

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

@@ -0,0 +1,19 @@
+module Admin::Resources::DataTypes::DatetimeHelper
+
+  def table_datetime_field(attribute, item)
+    if field = item.send(attribute)
+      I18n.localize(field, :format => item.class.typus_date_format(attribute))
+    end
+  end
+
+  alias_method :table_date_field, :table_datetime_field
+  alias_method :table_time_field, :table_datetime_field
+  alias_method :table_timestamp_field, :table_datetime_field
+
+  def display_datetime(item, attribute)
+    I18n.l(item.send(attribute), :format => @resource.typus_date_format(attribute))
+  end
+
+  alias_method :display_date, :display_datetime
+
+end

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

@@ -0,0 +1,56 @@
+module Admin::Resources::DataTypes::DragonflyHelper
+
+  def table_dragonfly_field(attribute, item)
+    typus_dragonfly_preview(item, attribute)
+  end
+
+  def link_to_detach_attribute_for_dragonfly(attribute)
+    validators = @item.class.validators.delete_if { |i| i.class != ActiveModel::Validations::PresenceValidator }.map(&:attributes).flatten.map(&:to_s)
+    attachment = @item.send(attribute)
+
+    if attachment.present? && !validators.include?(attribute) && attachment
+      attribute_i18n = @item.class.human_attribute_name(attribute)
+      label_text = <<-HTML
+#{attribute_i18n}
+<small>#{link_to Typus::I18n.t("Remove"), { :action => 'update', :id => @item.id, :_nullify => attribute, :_continue => true }, { :data => { :confirm => Typus::I18n.t("Are you sure?") } } }</small>
+      HTML
+      label_text.html_safe
+    end
+  end
+
+  def typus_dragonfly_preview(item, attachment)
+    data = item.send(attachment)
+    return unless data
+
+    if data.mime_type =~ /^image\/.+/
+      render "admin/templates/dragonfly_preview",
+             :attachment => data,
+             :preview => data.process(:thumb, Typus.image_preview_size).url,
+             :thumb => data.process(:thumb, Typus.image_table_thumb_size).url,
+             :item => item,
+             :attribute => attachment
+    else
+      params[:_popup] ? data.name : 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,
+             :item => item,
+             :attribute => attachment
+    else
+      html = params[:_popup] ? data.name : link_to(data.name, data.url)
+      # OPTIMIZE: Generate the tag with Ruby.
+      "<p>#{html}</p>".html_safe
+    end
+  end
+
+end

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

@@ -0,0 +1,2 @@
+module Admin::Resources::DataTypes::FloatHelper
+end

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

@@ -0,0 +1,53 @@
+module Admin::Resources::DataTypes::HasAndBelongsToManyHelper
+
+  def table_has_and_belongs_to_many_field(attribute, item)
+    item.send(attribute).map(&:to_label).join(", ")
+  end
+
+  alias_method :table_has_many_field, :table_has_and_belongs_to_many_field
+
+  def typus_has_and_belongs_to_many_field(attribute, form)
+    klass = @resource.reflect_on_association(attribute.to_sym).class_name.constantize
+
+    resource_ids = "#{attribute.singularize}_ids"
+    html_options = {}
+    model = @resource.name.underscore.gsub("/", "_")
+    options = { :attribute => "#{model}_#{attribute}" }
+
+    label_text = @resource.human_attribute_name(attribute)
+    if (text = build_label_text_for_has_and_belongs_to_many(klass, html_options, options))
+      label_text += " <small>#{text}</small>"
+    end
+
+    locals = { :attribute => attribute,
+               :attribute_id => "#{model}_#{attribute}",
+               :related_klass => klass,
+               :related_items => @item.send(attribute),
+               :related_ids => "#{model}[#{resource_ids}][]",
+               :values => klass,
+               :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, options = {})
+    if html_options[:disabled] == true
+      Typus::I18n.t("Read only")
+    elsif admin_user.can?('create', klass) && !headless_mode?
+      build_add_new_for_has_and_belongs_to_many(klass, options)
+    end
+  end
+
+  def build_add_new_for_has_and_belongs_to_many(klass, options)
+    html_options = set_modal_options_for(klass)
+    html_options["url"] = url_for(:controller => "/admin/#{klass.to_resource}", :action => :new, :_popup => true)
+    html_options["data-controls-modal"] = "modal-from-dom-#{options[:attribute]}"
+
+    options = { :anchor => html_options["data-controls-modal"] }
+
+    link_to Typus::I18n.t("Add"), options, html_options
+  end
+
+end

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

@@ -0,0 +1,66 @@
+module Admin::Resources::DataTypes::HasManyHelper
+
+  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.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
+
+  alias_method :has_and_belongs_to_many_filter, :has_many_filter
+
+  def typus_form_has_many(field)
+    setup_relationship(field)
+
+    options = { "resource[#{@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
+
+    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)
+
+      html_options = set_modal_options_for(klass)
+      html_options["url"] = "/admin/#{klass.to_resource}/new?_popup=true"
+      html_options["url"] << "&" + options.to_param
+
+      link_to Typus::I18n.t("Add"), "##{html_options['data-controls-modal']}", html_options
+    end
+  end
+
+  def set_has_many_resource_actions
+    klass = @model_to_relate
+    @resource_actions = [set_has_many_resource_edit_action(klass),
+                         set_has_many_resource_show_action(klass),
+                         set_has_many_resource_destroy_action(klass)]
+  end
+
+  def set_has_many_resource_edit_action(klass)
+    html_options = set_modal_options_for(klass)
+    [ "Edit", { :action => 'edit', :anchor => html_options['data-controls-modal'] }, html_options ]
+  end
+
+  def set_has_many_resource_show_action(klass)
+    html_options = set_modal_options_for(klass)
+    [ "Show", { :action => 'show', :anchor => html_options['data-controls-modal'] }, html_options ]
+  end
+
+  def set_has_many_resource_destroy_action(klass)
+    [ "Trash", { :action => 'destroy' }, { :confirm => "Trash?" } ]
+  end
+
+end

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

@@ -0,0 +1,36 @@
+module Admin::Resources::DataTypes::HasOneHelper
+
+  def typus_form_has_one(field)
+    setup_relationship(field)
+
+    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[#{@reflection.foreign_key}]" => @item.id }
+      locals[:add_new] = build_add_new_for_has_one(@model_to_relate, field, options)
+    end
+
+    render "admin/templates/has_one", locals
+  end
+
+  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",
+                          :_popup => true }
+
+      link_to Typus::I18n.t("Add"), default_options.merge(options), { :class => "iframe_with_page_reload" }
+    end
+  end
+
+  def set_has_one_resource_actions
+    @resource_actions = [["Edit", { :action => "edit" }, {}],
+                         ["Trash", { :action => "destroy" }, { :data => { :confirm => Typus::I18n.t("Trash?") } }]]
+  end
+
+end

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

@@ -0,0 +1,10 @@
+module Admin::Resources::DataTypes::IntegerHelper
+
+  def integer_filter(filter)
+    values = set_context.send(filter.to_s.pluralize).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
+
+end

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

@@ -0,0 +1,36 @@
+module Admin::Resources::DataTypes::PaperclipHelper
+
+  def table_paperclip_field(attribute, item)
+    options = { :width => 25 }
+    typus_paperclip_preview(item, attribute, options)
+  end
+
+  def link_to_detach_attribute_for_paperclip(attribute)
+    validators = @item.class.validators.delete_if { |i| i.class != ActiveModel::Validations::PresenceValidator }.map(&:attributes).flatten.map(&:to_s)
+    attachment = @item.send(attribute)
+
+    if attachment.exists? && !validators.include?("#{attribute}_file_name") && attachment
+      attribute_i18n = @item.class.human_attribute_name(attribute)
+      label_text = <<-HTML
+#{attribute_i18n}
+<small>#{link_to Typus::I18n.t("Remove"), { :action => 'update', :id => @item.id, :_nullify => attribute, :_continue => true }, { :data => { :confirm => Typus::I18n.t("Are you sure?") } } }</small>
+      HTML
+      label_text.html_safe
+    end
+  end
+
+  def typus_paperclip_preview(item, attachment, options = {})
+    if (data = item.send(attachment)).exists?
+      styles = data.styles.keys
+      if data.content_type =~ /^image\/.+/ && styles.include?(Typus.file_preview) && styles.include?(Typus.file_thumbnail)
+        render "admin/templates/paperclip_preview",
+               :preview => data.url(Typus.file_preview, false),
+               :thumb => data.url(Typus.file_thumbnail, false),
+               :options => options
+      else
+        link_to data.original_filename, data.url(:original, false)
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,20 @@
+module Admin::Resources::DataTypes::PositionHelper
+
+  def table_position_field(attribute, item, connector = " / ")
+    locals = { :html_position => [], :connector => connector, :item => item }
+    positions = { :move_to_top => "Top", :move_higher => "Up", :move_lower => "Down", :move_to_bottom => "Bottom" }
+
+    positions.each do |key, value|
+      first_item = item.respond_to?(:first?) && ([:move_higher, :move_to_top].include?(key) && item.first?)
+      last_item = item.respond_to?(:last?) &&  ([:move_lower, :move_to_bottom].include?(key) && item.last?)
+
+      unless first_item || last_item
+        options = { :controller => "/admin/#{item.class.to_resource}", :action => "position", :id => item.id, :go => key }
+        locals[:html_position] << link_to(Typus::I18n.t(value), params.merge(options), { :class => Typus::I18n.t(value).downcase })
+      end
+    end
+
+    render "admin/templates/position", locals
+  end
+
+end

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

@@ -0,0 +1,11 @@
+module Admin::Resources::DataTypes::SelectorHelper
+
+  def table_selector_field(attribute, item)
+    item.mapping(attribute)
+  end
+
+  def display_selector(item, attribute)
+    item.mapping(attribute)
+  end
+
+end

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

@@ -0,0 +1,32 @@
+module Admin::Resources::DataTypes::StringHelper
+
+  def display_string(item, attribute)
+    item.send(attribute)
+  end
+
+  alias_method :display_decimal, :display_string
+  alias_method :display_float, :display_string
+  alias_method :display_integer, :display_string
+  alias_method :display_position, :display_string
+  alias_method :display_text, :display_string
+  alias_method :display_virtual, :display_string
+
+  def string_filter(filter)
+    values = set_context.send(filter.to_s.pluralize).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 table_string_field(attribute, item)
+    (raw_content = item.send(attribute)).present? ? raw_content : mdash
+  end
+
+  alias_method :table_decimal_field, :table_string_field
+  alias_method :table_float_field, :table_string_field
+  alias_method :table_integer_field, :table_string_field
+  alias_method :table_virtual_field, :table_string_field
+  alias_method :table_password_field, :table_string_field
+
+end

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

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

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

@@ -0,0 +1,8 @@
+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) : mdash
+  end
+
+end