typus 0.9.39 → 1.0.0.pre

data/app/helpers/admin/table_helper.rb

@@ -1,242 +1,249 @@
-module Admin::TableHelper
+module Admin
 
-  def build_typus_table(model, fields, items, link_options = {}, association = nil)
+  module TableHelper
 
-    returning(String.new) do |html|
-
-      html << <<-HTML
-<table class="typus">
-      HTML
-
-      html << typus_table_header(model, fields)
+    def build_table(model, fields, items, link_options = {}, association = nil)
+      render "admin/helpers/table/table",
+             :model => model,
+             :fields => fields,
+             :items => items,
+             :link_options => link_options,
+             :headers => table_header(model, fields)
+    end
 
-      items.each do |item|
+    def table_header(model, fields)
+      fields.map do |key, value|
 
-        html << <<-HTML
-<tr class="#{cycle('even', 'odd')} #{item.class.name.underscore}" id="#{item.to_dom}" name="item_#{item.id}">
-        HTML
+        key = key.gsub(".", " ") if key.match(/\./)
+        content = model.human_attribute_name(key)
 
-        fields.each do |key, value|
-          case value
-          when :boolean then           html << typus_table_boolean_field(key, item)
-          when :datetime then          html << typus_table_datetime_field(key, item, link_options)
-          when :date then              html << typus_table_datetime_field(key, item, link_options)
-          when :file then              html << typus_table_file_field(key, item, link_options)
-          when :time then              html << typus_table_datetime_field(key, item, link_options)
-          when :belongs_to then        html << typus_table_belongs_to_field(key, item)
-          when :tree then              html << typus_table_tree_field(key, item)
-          when :position then          html << typus_table_position_field(key, item)
-          when :has_and_belongs_to_many then
-            html << typus_table_has_and_belongs_to_many_field(key, item)
+        if params[:action] == "index"
+          association = model.reflect_on_association(key.to_sym)
+          order_by = association ? association.primary_key_name : key
+
+          if (model.model_fields.map(&:first).collect { |i| i.to_s }.include?(key) || model.reflect_on_all_associations(:belongs_to).map(&:name).include?(key.to_sym))
+            sort_order = case params[:sort_order]
+                         when 'asc' then ['desc', '&darr;']
+                         when 'desc' then ['asc', '&uarr;']
+                         else [nil, nil]
+                         end
+            switch = sort_order.last if params[:order_by].eql?(order_by)
+            options = { :order_by => order_by, :sort_order => sort_order.first }
+            message = [ content, switch ].compact
+            link_to raw(message.join(" ")), params.merge(options)
           else
-            html << typus_table_string_field(key, item, link_options)
+            content
           end
-        end
 
-        action = if model.typus_user_id? && !@current_user.is_root?
-                   # If there's a typus_user_id column on the table and logged user is not root ...
-                   item.owned_by?(@current_user) ? item.class.typus_options_for(:default_action_on_item) : 'show'
-                 elsif !@current_user.can_perform?(model, 'edit')
-                   'show'
-                 else
-                   item.class.typus_options_for(:default_action_on_item)
-                 end
-
-        content = link_to _(action.capitalize), :controller => "admin/#{item.class.name.tableize}", :action => action, :id => item.id
-        html << <<-HTML
-<td width="10px">#{content}</td>
-        HTML
-
-        ##
-        # This controls the action to perform. If we are on a model list we 
-        # will remove the entry, but if we inside a model we will remove the 
-        # relationship between the models.
-        #
-        # Only shown is the user can destroy/unrelate items.
-        #
-
-        trash = "<div class=\"sprite trash\">Trash</div>"
-        unrelate = "<div class=\"sprite unrelate\">Unrelate</div>"
-
-        case params[:action]
-        when 'index'
-          condition = if model.typus_user_id? && !@current_user.is_root?
-                        item.owned_by?(@current_user)
-                      else
-                        @current_user.can_perform?(model, 'destroy')
-                      end
-          perform = link_to trash, { :action => 'destroy', :id => item.id }, 
-                                     :title => _("Remove"), 
-                                     :confirm => _("Remove entry?"), 
-                                     :method => :delete if condition
-        when 'edit'
-          # If we are editing content, we can relate and unrelate always!
-          perform = link_to unrelate, { :action => 'unrelate', :id => params[:id], :resource => model, :resource_id => item.id }, 
-                                        :title => _("Unrelate"), 
-                                        :confirm => _("Unrelate {{unrelate_model}} from {{unrelate_model_from}}?", 
-                                        :unrelate_model => model.typus_human_name, 
-                                        :unrelate_model_from => @resource[:human_name])
-        when 'show'
-          # If we are showing content, we only can relate and unrelate if we are 
-          # the owners of the owner record.
-          # If the owner record doesn't have a foreign key (Typus.user_fk) we look
-          # each item to verify the ownership.
-          condition = if @resource[:class].typus_user_id? && !@current_user.is_root?
-                        @item.owned_by?(@current_user)
-                      end
-          perform = link_to unrelate, { :action => 'unrelate', :id => params[:id], :resource => model, :resource_id => item.id }, 
-                                        :title => _("Unrelate"), 
-                                        :confirm => _("Unrelate {{unrelate_model}} from {{unrelate_model_from}}?", 
-                                        :unrelate_model => model.typus_human_name, 
-                                        :unrelate_model_from => @resource[:human_name]) if condition
+        else
+          content
         end
 
-        html << <<-HTML
-<td width="10px">#{perform}</td>
-</tr>
-        HTML
-
       end
-
-      html << "</table>"
-
     end
 
-  end
-
-  ##
-  # Header of the table
-  #
-  def typus_table_header(model, fields)
-    returning(String.new) do |html|
-      headers = []
-      fields.each do |key, value|
-
-        content = model.human_attribute_name(key)
-        content += " (#{key})" if key.include?('_id')
-
-        if (model.model_fields.map(&:first).collect { |i| i.to_s }.include?(key) || model.reflect_on_all_associations(:belongs_to).map(&:name).include?(key.to_sym)) && params[:action] == 'index'
-          sort_order = case params[:sort_order]
-                       when 'asc'   then  ['desc', '&darr;']
-                       when 'desc'  then  ['asc', '&uarr;']
-                       else
-                         [nil, nil]
-                       end
-          order_by = model.reflect_on_association(key.to_sym).primary_key_name rescue key
-          switch = sort_order.last if params[:order_by].eql?(order_by)
-          options = { :order_by => order_by, :sort_order => sort_order.first }
-          content = (link_to "#{content} #{switch}", params.merge(options))
+    def table_fields_for_item(item, fields, link_options)
+      fields.map do |key, value|
+        case value
+        when :boolean then table_boolean_field(key, item)
+        when :datetime then table_datetime_field(key, item, link_options)
+        when :date then table_datetime_field(key, item, link_options)
+        when :file then table_file_field(key, item, link_options)
+        when :time then table_datetime_field(key, item, link_options)
+        when :belongs_to then table_belongs_to_field(key, item)
+        when :tree then table_tree_field(key, item)
+        when :position then table_position_field(key, item)
+        when :selector then table_selector(key, item)
+        when :transversal then table_transversal(key, item)
+        when :has_and_belongs_to_many then table_has_and_belongs_to_many_field(key, item)
+        else
+          table_string_field(key, item, link_options)
         end
-
-        headers << "<th>#{content}</th>"
-
       end
-      headers << "<th>&nbsp;</th>" if @current_user.can_perform?(model, 'delete')
-      html << <<-HTML
-<tr>
-#{headers.join("\n")}
-</tr>
-      HTML
     end
-  end
 
-  def typus_table_belongs_to_field(attribute, item)
-
-    action = item.send(attribute).class.typus_options_for(:default_action_on_item) rescue 'edit'
-
-    att_value = item.send(attribute)
-    content = if !att_value.nil?
-      if @current_user.can_perform?(att_value.class.name, action)
-        link_to item.send(attribute).typus_name, :controller => "admin/#{attribute.pluralize}", :action => action, :id => att_value.id
-      else
-        att_value.typus_name
-      end
+    def table_default_action(model, item)
+      action = if model.typus_user_id? && @current_user.is_not_root?
+                 # If there's a typus_user_id column on the table and logged user is not root ...
+                 item.owned_by?(@current_user) ? item.class.typus_options_for(:default_action_on_item) : "show"
+               elsif @current_user.cannot?("edit", model)
+                 'show'
+               else
+                 item.class.typus_options_for(:default_action_on_item)
+               end
+
+      options = { :controller => "admin/#{item.class.to_resource}",
+                  :action => action,
+                  :id => item.id }
+
+      link_to _(action.capitalize), options
     end
 
-    <<-HTML
-<td>#{content}</td>
-    HTML
-
-  end
-
-  def typus_table_has_and_belongs_to_many_field(attribute, item)
-    <<-HTML
-<td>#{item.send(attribute).map { |i| i.typus_name }.join('<br />')}</td>
-    HTML
-  end
+    #--
+    # This controls the action to perform. If we are on a model list we
+    # will remove the entry, but if we inside a model we will remove the
+    # relationship between the models.
+    #
+    # Only shown is the user can destroy/unrelate items.
+    #++
+    def table_action(model, item)
+
+      condition = true
+
+      case params[:action]
+      when "index"
+        action = "trash"
+        options = { :action => 'destroy', :id => item.id }
+        method = :delete
+      when "edit", "show"
+        action = "unrelate"
+        options = { :action => 'unrelate', :id => params[:id], :resource => model, :resource_id => item.id }
+      end
 
-  def typus_table_string_field(attribute, item, link_options = {})
-    <<-HTML
-<td class="#{attribute}">#{h(item.send(attribute))}</td>
-    HTML
-  end
+      title = _(action.titleize)
+
+      case params[:action]
+      when 'index'
+        condition = if model.typus_user_id? && @current_user.is_not_root?
+                      item.owned_by?(@current_user)
+                    elsif (@current_user.id.eql?(item.id) && model.eql?(Typus.user_class))
+                      false
+                    else
+                      @current_user.can?('destroy', model)
+                    end
+        confirm = _("Remove %{resource}?", :resource => item.class.model_name.human)
+      when 'edit'
+        # If we are editing content, we can relate and unrelate always!
+        confirm = _("Unrelate %{unrelate_model} from %{unrelate_model_from}?",
+                    :unrelate_model => model.model_name.human,
+                    :unrelate_model_from => @resource.model_name.human)
+      when 'show'
+        # If we are showing content, we only can relate and unrelate if we are
+        # the owners of the owner record.
+        # If the owner record doesn't have a foreign key (Typus.user_fk) we look
+        # each item to verify the ownership.
+        condition = if @resource.typus_user_id? && @current_user.is_not_root?
+                      @item.owned_by?(@current_user)
+                    end
+        confirm = _("Unrelate %{unrelate_model} from %{unrelate_model_from}?",
+                    :unrelate_model => model.model_name.human,
+                    :unrelate_model_from => @resource.model_name.human)
+      end
 
-  def typus_table_file_field(attribute, item, link_options = {})
-    <<-HTML
-<td>#{item.typus_preview_on_table(attribute)}</td>
-    HTML
-  end
+      message = %(<div class="sprite #{action}">#{_(action.titleize)}</div>)
 
-  def typus_table_tree_field(attribute, item)
-    <<-HTML
-<td>#{item.parent.typus_name if item.parent}</td>
-    HTML
-  end
+      if condition
+        link_to raw(message), options, :title => title, :confirm => confirm, :method => method
+      end
 
-  def typus_table_position_field(attribute, item)
+    end
 
-    html_position = []
+    def table_belongs_to_field(attribute, item)
+      att_value = item.send(attribute)
+      content = "&mdash;".html_safe
 
-    [['Up', 'move_higher'], ['Down', 'move_lower']].each do |position|
+      unless att_value.nil?
+        content = att_value.to_label
+        action = item.send(attribute).class.typus_options_for(:default_action_on_item)
+        if @current_user.can?(action, att_value.class.name)
+          content = link_to content, :controller => "admin/#{att_value.class.to_resource}", :action => action, :id => att_value.id
+        end
+      end
 
-      options = { :controller => item.class.name.tableize, 
-                  :action => 'position', 
-                  :id => item.id, 
-                  :go => position.last }
+      return content_tag(:td, content)
+    end
 
-      first_or_last = (item.respond_to?(:first?) && (position.last == 'move_higher' && item.first?)) || (item.respond_to?(:last?) && (position.last == 'move_lower' && item.last?))
-      html_position << link_to_unless(first_or_last, _(position.first), params.merge(options)) do |name|
-        %(<span class="inactive">#{name}</span>)
-      end
+    def table_has_and_belongs_to_many_field(attribute, item)
+      content = item.send(attribute).map { |i| i.to_label }.join(", ")
+      return content_tag(:td, content)
     end
 
-    <<-HTML
-<td>#{html_position.join(' / ')}</td>
-    HTML
+    def table_string_field(attribute, item, link_options = {})
+      raw_content = item.send(attribute)
+      content = raw_content.blank? ? "&#151;".html_safe : raw_content
+      return content_tag(:td, content, :class => attribute)
+    end
 
-  end
+    def table_selector(attribute, item)
+      raw_content = item.mapping(attribute)
+      return content_tag(:td, raw_content, :class => attribute)
+    end
 
-  def typus_table_datetime_field(attribute, item, link_options = {} )
+    def table_file_field(attribute, item, link_options = {})
+      file_preview = Typus.file_preview
+      file_thumbnail = Typus.file_thumbnail
+
+      has_file_preview = item.send(attribute).styles.member?(file_preview)
+      file_preview_is_image = item.send("#{attribute}_content_type") =~ /^image\/.+/
+
+      content = if has_file_preview && file_preview_is_image
+                  render "admin/helpers/preview",
+                         :attribute => attribute,
+                         :attachment => attribute,
+                         :content => item.send(attribute),
+                         :file_preview_is_image => file_preview_is_image,
+                         :has_file_preview => has_file_preview,
+                         :href => item.send(attribute).url(file_preview),
+                         :item => item
+                else
+                  link_to item.send(attribute), item.send(attribute).url
+                end
+
+      return content_tag(:td, content)
+    end
 
-    date_format = item.class.typus_date_format(attribute)
-    content = !item.send(attribute).nil? ? item.send(attribute).to_s(date_format) : item.class.typus_options_for(:nil)
+    def table_tree_field(attribute, item)
+      content = item.parent ? item.parent.to_label : "&#151;".html_safe
+      return content_tag(:td, content)
+    end
 
-    <<-HTML
-<td>#{content}</td>
-    HTML
+    def table_position_field(attribute, item)
+      html_position = []
 
-  end
+      { :move_higher => "Up", :move_lower => "Down" }.each do |key, value|
+        options = { :controller => item.class.to_resource, :action => "position", :id => item.id, :go => key }
+        first_or_last = (item.respond_to?(:first?) && (key == :move_higher && item.first?)) || (item.respond_to?(:last?) && (key == :move_lower && item.last?))
+        html_position << link_to_unless(first_or_last, _(value), params.merge(options)) do |name|
+          %(<span class="inactive">#{name}</span>)
+        end
+      end
 
-  def typus_table_boolean_field(attribute, item)
+      content = html_position.join(" / ").html_safe
+      return content_tag(:td, content)
+    end
 
-    boolean_hash = item.class.typus_boolean(attribute)
-    status = item.send(attribute)
-    link_text = !item.send(attribute).nil? ? boolean_hash["#{status}".to_sym] : item.class.typus_options_for(:nil)
+    def table_datetime_field(attribute, item, link_options = {} )
+      date_format = item.class.typus_date_format(attribute)
+      content = !item.send(attribute).nil? ? item.send(attribute).to_s(date_format) : item.class.typus_options_for(:nil)
 
-    options = { :controller => item.class.name.tableize, :action => 'toggle', :field => attribute.gsub(/\?$/,''), :id => item.id }
+      return content_tag(:td, content)
+    end
 
-    content = if item.class.typus_options_for(:toggle) && !item.send(attribute).nil?
-                link_to link_text, params.merge(options), 
-                                   :confirm => _("Change {{attribute}}?", 
-                                   :attribute => item.class.human_attribute_name(attribute).downcase)
-              else
-                link_text
-              end
+    def table_boolean_field(attribute, item)
+      boolean_hash = item.class.typus_boolean(attribute)
+      status = item.send(attribute)
+
+      content = if status.nil?
+                  Typus::Resources.human_nil
+                else
+                  message = _(boolean_hash["#{status}".to_sym])
+                  options = { :controller => "admin/#{item.class.to_resource}",
+                              :action => "toggle",
+                              :id => item.id,
+                              :field => attribute.gsub(/\?$/,'') }
+                  confirm = _("Change %{attribute}?",
+                              :attribute => item.class.human_attribute_name(attribute).downcase)
+                  link_to message, options, :confirm => confirm
+                end
+
+      return content_tag(:td, content)
+    end
 
-    <<-HTML
-<td align="center">#{content}</td>
-    HTML
+    def table_transversal(attribute, item)
+      _attribute, virtual = attribute.split(".")
+      return content_tag(:td, item.send(_attribute).send(virtual))
+    end
 
   end
 
-end
+end

data/app/helpers/admin_helper.rb

@@ -0,0 +1,56 @@
+module AdminHelper
+
+  def typus_block(resource = @resource.to_resource, partial = params[:action])
+    partials_path = "admin/#{resource}"
+    resources_partials_path = "admin/resources"
+
+    partials = ActionController::Base.view_paths.map do |view_path|
+      Dir["#{view_path}/#{partials_path}/*"].map { |f| File.basename(f, '.html.erb') }
+    end.flatten
+    resources_partials = Dir[Rails.root.join("app/views/#{resources_partials_path}/*").to_s].map do |file|
+                           File.basename(file, ".html.erb")
+                         end
+
+    path = if partials.include?("_#{partial}") then partials_path
+           elsif resources_partials.include?(partial) then resources_partials_path
+           end
+
+    render "#{path}/#{partial}" if path
+  end
+
+  def title(page_title)
+    content_for(:title) { page_title }
+  end
+
+  def header
+    render "admin/helpers/header"
+  end
+
+  def apps
+    render "admin/helpers/apps"
+  end
+
+  def login_info(user = @current_user)
+    return if user.kind_of?(Admin::FakeUser)
+
+    admin_edit_typus_user_path = { :controller => "/admin/#{Typus.user_class.to_resource}",
+                                   :action => 'edit',
+                                   :id => user.id }
+
+    message = _("Are you sure you want to sign out and end your session?")
+
+    user_details = if user.can?('edit', Typus.user_class_name)
+                     link_to user.name, admin_edit_typus_user_path
+                   else
+                     user.name
+                   end
+
+    render "admin/helpers/login_info", :message => message, :user_details => user_details
+  end
+
+  def display_flash_message(message = flash)
+    return if message.empty?
+    render "admin/helpers/flash_message", :flash_type => message.keys.first, :message => message
+  end
+
+end

data/app/mailers/admin/mailer.rb

@@ -0,0 +1,13 @@
+class Admin::Mailer < ActionMailer::Base
+
+  default :from => Typus.mailer_sender
+
+  def reset_password_link(user, url)
+    @user = user
+    @url = url
+
+    mail :to => user.email,
+         :subject => "[#{Typus.admin_title}] #{_("Reset password")}"
+  end
+
+end

data/app/models/admin/fake_user.rb

@@ -0,0 +1,38 @@
+module Admin
+
+  class FakeUser
+
+    def id
+      0
+    end
+
+    def can?(*args)
+      true
+    end
+
+    def cannot?(*args)
+      !can?(*args)
+    end
+
+    def is_root?
+      true
+    end
+
+    def is_not_root?
+      !is_root?
+    end
+
+    def resources
+      Typus::Configuration.roles[role].compact
+    end
+
+    def role
+      Typus.master_role
+    end
+
+    def name
+    end
+
+  end
+
+end

data/app/views/admin/account/forgot_password.html.erb

@@ -0,0 +1,21 @@
+<%
+  page_title = _("Forgot password")
+  title(page_title)
+%>
+
+<%= form_for :typus_user, :url => { :action => :forgot_password } do |form| %>
+
+  <ul>
+
+    <li>
+      <%= form.label :email, Typus.user_class.human_attribute_name(:email) %>
+      <%= form.text_field :email, :size => 20, :class => "text" %>
+    </li>
+
+    <li>
+      <%= submit_tag _("Submit"), :class => "button" %> <%= link_to _("I remember my password"), new_admin_session_path %>
+    </li>
+
+  </ul>
+
+<% end %>

data/app/views/admin/account/new.html.erb

@@ -0,0 +1,21 @@
+<%
+  page_title = _("Sign up")
+  title(page_title)
+%>
+
+<%= form_for :typus_user, :url => { :action => :create } do |form| %>
+
+  <ul>
+
+    <li>
+      <%= form.label :email, Typus.user_class.human_attribute_name(:email) %>
+      <%= form.text_field :email, :size => 20, :class => "text" %>
+    </li>
+
+    <li>
+      <%= submit_tag _("Sign up"), :class => "button" %>
+    </li>
+
+  </ul>
+
+<% end %>

data/app/views/admin/dashboard/_sidebar.html.erb

@@ -1,5 +1,5 @@
-<h2>Welcome to Typus!</h2>
+<h2>Welcome!</h2>
 
-<p>If you need help don't hesitate in joining the <%= link_to 'mailing list', 'http://groups.google.com/group/typus', :rel => 'external' %>.</p>
+<p>If you need help don't hesitate in joining the <%= link_to 'mailing list', 'http://groups.google.com/group/typus' %>.</p>
 
-<p>Replace this sidebar dropping a file named <code>_sidebar.html.erb</code> on the <code>app/views/admin/dashboard</code> folder.</p>
+<p>Replace this sidebar dropping a file named <code>_sidebar.html.erb</code> on the <code>app/views/admin/dashboard</code> folder.</p>

data/app/views/admin/dashboard/show.html.erb

@@ -0,0 +1,16 @@
+<%
+  page_title = _("Dashboard")
+  title(page_title)
+%>
+
+<% content_for :sidebar do %>
+  <%= render "sidebar" %>
+<% end %>
+
+<h2>
+  <%= page_title %>
+</h2>
+
+<%= applications %>
+
+<%= resources %>