typus 3.0.2 → 3.0.4

data/Gemfile

@@ -1,20 +1,31 @@
 source 'http://rubygems.org'
 
+gemspec
+
 gem "acts_as_list"
 gem "acts_as_tree"
-gem "paperclip"
-gem "fastercsv", "1.5.3" unless RUBY_VERSION >= '1.9'
-gem "paginator", "1.1.1"
+gem "dragonfly", "~>0.8.1"
+gem "factory_girl"
 
 group :test do
-  gem "capybara"
-  gem "factory_girl"
   gem "mysql"
-  gem "paperclip"
   gem "pg"
-  gem "rails", "3.0.0"
-  gem "shoulda"
-  gem "sqlite3-ruby"
+end
+
+gem "paperclip"
 
+gem "rack-cache", :require => "rack/cache"
+gem "rails", "~> 3.0"
+
+gem 'sqlite3-ruby', '1.2.1'
+
+# Keep this here because I use it as reference for development.
+gem "fastercsv", "1.5.3" if RUBY_VERSION < '1.9'
+gem "render_inheritable"
+gem "will_paginate", "~> 3.0.pre2"
+
+group :test do
+  gem "shoulda"
+  gem "tartare", :git => "https://github.com/fesplugas/rails-tartare.git", :require => false
   gem "mocha"
 end

data/Gemfile.lock

@@ -1,105 +1,129 @@
+GIT
+  remote: https://github.com/fesplugas/rails-tartare.git
+  revision: 3d74044310943023ec7d218d4c3c8b29c5b8ebed
+  specs:
+    tartare (1.0.0)
+      capybara (>= 0.4.0)
+      rails (>= 3.0.0)
+
+PATH
+  remote: .
+  specs:
+    typus (3.0.3)
+      fastercsv (= 1.5.3)
+      render_inheritable
+      will_paginate (~> 3.0.pre2)
+
 GEM
   remote: http://rubygems.org/
   specs:
     abstract (1.0.0)
-    actionmailer (3.0.0)
-      actionpack (= 3.0.0)
-      mail (~> 2.2.5)
-    actionpack (3.0.0)
-      activemodel (= 3.0.0)
-      activesupport (= 3.0.0)
+    actionmailer (3.0.3)
+      actionpack (= 3.0.3)
+      mail (~> 2.2.9)
+    actionpack (3.0.3)
+      activemodel (= 3.0.3)
+      activesupport (= 3.0.3)
       builder (~> 2.1.2)
       erubis (~> 2.6.6)
-      i18n (~> 0.4.1)
+      i18n (~> 0.4)
       rack (~> 1.2.1)
-      rack-mount (~> 0.6.12)
-      rack-test (~> 0.5.4)
+      rack-mount (~> 0.6.13)
+      rack-test (~> 0.5.6)
       tzinfo (~> 0.3.23)
-    activemodel (3.0.0)
-      activesupport (= 3.0.0)
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
       builder (~> 2.1.2)
-      i18n (~> 0.4.1)
-    activerecord (3.0.0)
-      activemodel (= 3.0.0)
-      activesupport (= 3.0.0)
-      arel (~> 1.0.0)
+      i18n (~> 0.4)
+    activerecord (3.0.3)
+      activemodel (= 3.0.3)
+      activesupport (= 3.0.3)
+      arel (~> 2.0.2)
       tzinfo (~> 0.3.23)
-    activeresource (3.0.0)
-      activemodel (= 3.0.0)
-      activesupport (= 3.0.0)
-    activesupport (3.0.0)
+    activeresource (3.0.3)
+      activemodel (= 3.0.3)
+      activesupport (= 3.0.3)
+    activesupport (3.0.3)
     acts_as_list (0.1.2)
     acts_as_tree (0.1.1)
-    arel (1.0.1)
-      activesupport (~> 3.0.0)
+    arel (2.0.7)
     builder (2.1.2)
-    capybara (0.3.9)
+    capybara (0.4.0)
+      celerity (>= 0.7.9)
       culerity (>= 0.2.4)
       mime-types (>= 1.16)
       nokogiri (>= 1.3.3)
       rack (>= 1.0.0)
       rack-test (>= 0.5.4)
-      selenium-webdriver (>= 0.0.3)
-    culerity (0.2.12)
+      selenium-webdriver (>= 0.0.27)
+      xpath (~> 0.1.2)
+    celerity (0.8.7)
+    childprocess (0.1.6)
+      ffi (~> 0.6.3)
+    culerity (0.2.14)
+    dragonfly (0.8.2)
+      rack
     erubis (2.6.6)
       abstract (>= 1.0.0)
-    factory_girl (1.3.2)
+    factory_girl (1.3.3)
     fastercsv (1.5.3)
     ffi (0.6.3)
       rake (>= 0.8.7)
-    hoe (2.6.2)
-      rake (>= 0.8.7)
-      rubyforge (>= 2.0.4)
-    i18n (0.4.1)
+    i18n (0.5.0)
     json_pure (1.4.6)
-    mail (2.2.5)
+    mail (2.2.14)
       activesupport (>= 2.3.6)
-      mime-types
-      treetop (>= 1.4.5)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
     mime-types (1.16)
-    mocha (0.9.8)
+    mocha (0.9.10)
       rake
     mysql (2.8.1)
-    nokogiri (1.4.3.1)
-    paginator (1.1.1)
-      hoe (>= 1.6.0)
-    paperclip (2.3.3)
+    nokogiri (1.4.4)
+    paperclip (2.3.8)
       activerecord
       activesupport
-    pg (0.9.0)
+    pg (0.10.0)
     polyglot (0.3.1)
     rack (1.2.1)
+    rack-cache (1.0)
+      rack (>= 0.4)
     rack-mount (0.6.13)
       rack (>= 1.0.0)
-    rack-test (0.5.4)
+    rack-test (0.5.7)
       rack (>= 1.0)
-    rails (3.0.0)
-      actionmailer (= 3.0.0)
-      actionpack (= 3.0.0)
-      activerecord (= 3.0.0)
-      activeresource (= 3.0.0)
-      activesupport (= 3.0.0)
-      bundler (~> 1.0.0)
-      railties (= 3.0.0)
-    railties (3.0.0)
-      actionpack (= 3.0.0)
-      activesupport (= 3.0.0)
-      rake (>= 0.8.4)
-      thor (~> 0.14.0)
+    rails (3.0.3)
+      actionmailer (= 3.0.3)
+      actionpack (= 3.0.3)
+      activerecord (= 3.0.3)
+      activeresource (= 3.0.3)
+      activesupport (= 3.0.3)
+      bundler (~> 1.0)
+      railties (= 3.0.3)
+    railties (3.0.3)
+      actionpack (= 3.0.3)
+      activesupport (= 3.0.3)
+      rake (>= 0.8.7)
+      thor (~> 0.14.4)
     rake (0.8.7)
-    rubyforge (2.0.4)
-      json_pure (>= 1.1.7)
+    render_inheritable (1.0.0)
+      rails (~> 3.0)
     rubyzip (0.9.4)
-    selenium-webdriver (0.0.28)
-      ffi (>= 0.6.1)
+    selenium-webdriver (0.1.2)
+      childprocess (~> 0.1.5)
+      ffi (~> 0.6.3)
       json_pure
       rubyzip
     shoulda (2.11.3)
-    sqlite3-ruby (1.3.1)
-    thor (0.14.0)
-    treetop (1.4.8)
+    sqlite3-ruby (1.2.1)
+    thor (0.14.6)
+    treetop (1.4.9)
       polyglot (>= 0.3.1)
-    tzinfo (0.3.23)
+    tzinfo (0.3.24)
+    will_paginate (3.0.pre2)
+    xpath (0.1.3)
+      nokogiri (~> 1.3)
 
 PLATFORMS
   ruby
@@ -107,14 +131,18 @@ PLATFORMS
 DEPENDENCIES
   acts_as_list
   acts_as_tree
-  capybara
+  dragonfly (~> 0.8.1)
   factory_girl
   fastercsv (= 1.5.3)
   mocha
   mysql
-  paginator (= 1.1.1)
   paperclip
   pg
-  rails (= 3.0.0)
+  rack-cache
+  rails (~> 3.0)
+  render_inheritable
   shoulda
-  sqlite3-ruby
+  sqlite3-ruby (= 1.2.1)
+  tartare!
+  typus!
+  will_paginate (~> 3.0.pre2)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2007-2010 Francesc Esplugas Marti
+Copyright (c) 2007-2011 Francesc Esplugas Marti
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,61 @@
+# Typus: Admin Panel for Ruby on Rails applications
+
+**Typus** is designed for a single activity:
+
+    Trusted users editing structured content.
+
+**Typus** doesn't try to be all the things to all the people but it's
+extensible enough to match lots of use cases.
+
+## Key Features
+
+- Built-in Authentication.
+- User Permissions by using Access Control Lists. (stored in yaml files)
+- CRUD and custom actions for your models on a clean interface.
+- Internationalized interface (Català, German, Greek, English, Español,
+Français, Magyar, Italiano, Portuguese, Russian, 中文)
+- Customizable and extensible templates.
+- Integrated [paperclip][1] and [dragonfly][2] attachments viewer.
+- Low memory footprint.
+- Works with `Rails 3.0`.
+- Tested with `Ruby 1.8.7-p300` and `Ruby 1.9.2-p136`.
+- Tested with SQLite, MySQL and PostgreSQL.
+- MIT License, the same as Rails.
+
+## Links
+
+- [Documentation](http://core.typuscms.com/)
+- [Demo](http://demo.typuscms.com/) ([Code][3])
+- [Source Code](http://github.com/fesplugas/typus)
+- [Mailing List](http://groups.google.com/group/typus)
+- [Gems](http://rubygems.org/gems/typus)
+- [Contributors List](http://github.com/fesplugas/typus/contributors)
+- [Continous Integration](http://ci.typuscms.com/)
+
+## Installing
+
+Add **Typus** to your `Gemfile`
+
+    gem 'typus', :git => 'https://github.com/fesplugas/typus.git'
+
+Update your bundle
+
+    $ bundle install
+
+Run the generator
+
+    $ rails generate typus
+
+Start the application server
+
+    $ rails server
+
+and go to <http://0.0.0.0:3000/admin>.
+
+## License
+
+Copyright © 2007-2011 Francesc Esplugas, released under the MIT license.
+
+[1]: http://rubygems.org/gems/paperclip
+[2]: http://rubygems.org/gems/dragonfly
+[3]: https://github.com/fesplugas/typus/tree/master/test/fixtures/rails_app

data/Rakefile

@@ -39,3 +39,8 @@ task :release => :build do
   system "gem push typus-#{Typus::VERSION}.gem"
   system "git clean -fd && rm -f typus-#{Typus::VERSION}.gem"
 end
+
+desc 'Deploy'
+task :deploy do
+  system "cd test/fixtures/rails_app && cap deploy"
+end

data/app/controllers/admin/account_controller.rb

@@ -3,20 +3,20 @@ class Admin::AccountController < Admin::BaseController
   layout 'admin/session'
 
   skip_before_filter :reload_config_and_roles
-  skip_before_filter :set_preferences
   skip_before_filter :authenticate
+  skip_before_filter :set_locale
 
   before_filter :sign_in?, :except => [:forgot_password, :show]
   before_filter :new?, :only => [:forgot_password]
 
   def new
-    flash[:notice] = _t("Enter your email below to create the first user.")
+    flash[:notice] = Typus::I18n.t("Enter your email below to create the first user.")
   end
 
   def create
     user = Typus.user_class.generate(:email => params[:typus_user][:email])
     user.status = true
-    redirect_to (user.save ? { :action => "show", :id => user.token } : { :action => :new })
+    redirect_to user.save ? { :action => "show", :id => user.token } : { :action => :new }
   end
 
   def forgot_password
@@ -25,20 +25,17 @@ class Admin::AccountController < Admin::BaseController
     if user = Typus.user_class.find_by_email(params[:typus_user][:email])
       url = admin_account_url(user.token)
       Admin::Mailer.reset_password_link(user, url).deliver
-      notice = _t("Password recovery link sent to your email.")
-      path = new_admin_session_path
+      redirect_to new_admin_session_path, :notice => Typus::I18n.t("Password recovery link sent to your email.")
     else
-      render :action => :forgot_password and return
+      render :action => :forgot_password
     end
-
-    redirect_to path, :notice => notice
   end
 
   def show
-    flash[:notice] = _t("Please set a new password.")
+    flash[:notice] = Typus::I18n.t("Please set a new password.")
     typus_user = Typus.user_class.find_by_token!(params[:id])
     session[:typus_user_id] = typus_user.id
-    redirect_to :controller => "admin/#{Typus.user_class.to_resource}", :action => "edit", :id => typus_user.id
+    redirect_to :controller => "/admin/#{Typus.user_class.to_resource}", :action => "edit", :id => typus_user.id
   end
 
   private

data/app/controllers/admin/base_controller.rb

@@ -1,14 +1,25 @@
 class Admin::BaseController < ActionController::Base
 
+  render_inheritable
+
   include Typus::Authentication::const_get(Typus.authentication.to_s.classify)
 
+  before_filter :set_models_constantized
   before_filter :reload_config_and_roles
   before_filter :authenticate
+  before_filter :set_locale
+
+  helper_method :admin_user
 
-  helper_method :current_user
+  def user_guide
+  end
 
   protected
 
+  def set_models_constantized
+    Typus::Configuration.models_constantized!
+  end
+
   def reload_config_and_roles
     Typus.reload! unless Rails.env.production?
   end
@@ -17,4 +28,8 @@ class Admin::BaseController < ActionController::Base
     @back_to || request.referer || admin_dashboard_path
   end
 
+  def set_locale
+    I18n.locale = admin_user.locale
+  end
+
 end

data/app/controllers/admin/resources_controller.rb

@@ -1,56 +1,42 @@
-require "typus/format"
-
 class Admin::ResourcesController < Admin::BaseController
 
+  include Typus::Actions
+  include Typus::Filters
   include Typus::Format
 
   before_filter :get_model
-
-  before_filter :get_object,
-                :only => [ :show,
-                           :edit, :update, :destroy, :toggle,
-                           :position, :relate, :unrelate,
-                           :detach ]
-
-  before_filter :check_resource_ownership,
-                :only => [ :edit, :update, :destroy, :toggle,
-                           :position, :relate, :unrelate ]
-
-  before_filter :check_if_user_can_perform_action_on_user,
-                :only => [ :edit, :update, :toggle, :destroy ]
+  before_filter :set_scope
+  before_filter :get_object, :only => [:show, :edit, :update, :destroy, :toggle, :position, :relate, :unrelate, :detach]
+  before_filter :check_resource_ownership, :only => [:edit, :update, :destroy, :toggle, :position, :relate, :unrelate ]
   before_filter :check_if_user_can_perform_action_on_resources
+  before_filter :set_order, :only => [:index]
+  before_filter :set_fields, :only => [:index, :new, :edit, :create, :update, :show, :detach]
 
-  before_filter :set_order,
-                :only => [ :index ]
-  before_filter :set_fields,
-                :only => [ :index, :new, :edit, :create, :update, :show ]
+  before_filter :check_if_we_can_add_a_new_item, :only => [:new, :create]
 
   ##
   # This is the main index of the model. With filters, conditions and more.
   #
-  # By default application can respond_to html, csv and xml, but you can add
+  # By default application can respond to html, csv and xml, but you can add
   # your formats.
   #
   def index
-    @conditions, @joins = @resource.build_conditions(params)
-    check_resource_ownerships if @resource.typus_options_for(:only_user_items)
+    add_action(:action_name => default_action.titleize, :action => default_action)
+    add_action(:action_name => "Trash", :action => "destroy", :confirm => "#{Typus::I18n.t("Trash")}?", :method => 'delete')
+
+    get_objects
 
     respond_to do |format|
-      format.html { generate_html and select_template }
+      format.html { generate_html }
       @resource.typus_export_formats.each { |f| format.send(f) { send("generate_#{f}") } }
     end
   end
 
   def new
-    check_ownership_of_referal_item
-
     item_params = params.dup
-    rejections = %w( controller action resource resource_id back_to selected )
+    rejections = %w(controller action resource resource_id back_to selected)
     item_params.delete_if { |k, v| rejections.include?(k) }
-
     @item = @resource.new(item_params)
-
-    select_template
   end
 
   ##
@@ -63,150 +49,160 @@ class Admin::ResourcesController < Admin::BaseController
 
     set_attributes_on_create
 
-    if @item.valid?
-      create_with_back_to and return if params[:back_to]
-      @item.save
-      redirect_on_success
+    if @item.save
+      params[:back_to] ? create_with_back_to : redirect_on_success
     else
-      select_template(:new)
+      render :new
     end
   end
 
   def edit
-    select_template
+    add_action(:action_name => default_action.titleize, :action => default_action)
+    add_action(:action_name => "Unrelate", :action => "unrelate", :confirm => "#{Typus::I18n.t("Unrelate")}?", :resource => @resource.model_name, :resource_id => @item.id)
   end
 
   def show
-    check_resource_ownership and return if @resource.typus_options_for(:only_user_items)
-    select_template
+    check_resource_ownership if @resource.typus_options_for(:only_user_items)
   end
 
   def update
-    if @item.update_attributes(params[@object_name])
-      set_attributes_on_update
-      reload_locales
+    respond_to do |format|
+      if @item.update_attributes(params[@object_name])
+        set_attributes_on_update
+        reload_locales
+        format.html { redirect_on_success }
+        format.json { render :json => @item }
+      else
+        format.html { render :edit }
+        format.json { render :json => @item.errors.full_messages }
+      end
+    end
+  end
+
+  def detach
+    if @item.update_attributes(params[:attribute] => nil)
       redirect_on_success
     else
-      select_template(:edit)
+      render :edit
     end
   end
 
   def destroy
-    @item.destroy
-    notice = _t("%{model} successfully removed.", :model => @resource.model_name.human)
-    redirect_to set_path, :notice => notice
+    if @item.destroy
+      notice = Typus::I18n.t("%{model} successfully removed.", :model => @resource.model_name.human)
+    else
+      alert = @item.errors.full_messages
+    end
+    redirect_to set_path, :notice => notice, :alert => alert
   end
 
   def toggle
     @item.toggle(params[:field])
     @item.save!
 
-    notice = _t("%{model} %{attribute} changed.",
-               :model => @resource.model_name.human,
-               :attribute => params[:field].humanize.downcase)
+    notice = Typus::I18n.t("%{model} successfully updated.", :model => @resource.model_name.human)
 
-    redirect_to set_path, :notice => notice
+    respond_to do |format|
+      format.html { redirect_to set_path, :notice => notice }
+      format.json { render :json => @item }
+    end
   end
 
   ##
-  # Change item position. This only works if acts_as_list is installed. We can
-  # then move items:
+  # Change item position:
   #
   #   params[:go] = 'move_to_top'
   #
   # Available positions are move_to_top, move_higher, move_lower, move_to_bottom.
   #
+  # NOTE: Only works if `acts_as_list` is installed.
+  #
   def position
     @item.send(params[:go])
-    notice = _t("Record moved %{to}.", :to => params[:go].gsub(/move_/, '').humanize.downcase)
+    notice = Typus::I18n.t("%{model} successfully updated.", :model => @resource.model_name.human)
     redirect_to set_path, :notice => notice
   end
 
   ##
-  # Relate a model object to another, this action is used only by the
-  # has_and_belongs_to_many and has_many relationships.
+  # Action to relate models which respond to:
+  #
+  #   - has_and_belongs_to_many
+  #   - has_many
+  #
+  # For example:
+  #
+  #   class Item < ActiveRecord::Base
+  #     has_many :line_items
+  #   end
+  #
+  #   class LineItem < ActiveRecord::Base
+  #     belongs_to :item
+  #   end
+  #
+  #   >> related_item = LineItem.find(params[:related][:id])
+  #   => ...
+  #   >> item = Item.find(params[:id])
+  #   => ...
+  #   >> item.line_items << related_item
+  #   => ...
   #
   def relate
-    resource_class = params[:related][:model].constantize
-    resource_tableized = params[:related][:model].tableize
+    resource_class = params[:related][:model].typus_constantize
+    association_name = params[:related][:association_name].tableize
 
-    if @item.send(resource_tableized) << resource_class.find(params[:related][:id])
-      flash[:notice] = _t("%{model_a} related to %{model_b}",
-                         :model_a => resource_class.model_name.human,
-                         :model_b => @resource.model_name.human)
-    else
-      flash[:alert] = _t("%{model_a} cannot be related to %{model_b}",
-                         :model_a => resource_class.model_name.human,
-                         :model_b => @resource.model_name.human)
+    if @item.send(association_name) << resource_class.find(params[:related][:id])
+      flash[:notice] = Typus::I18n.t("%{model} successfully updated.", :model => @resource.model_name.human)
     end
 
     redirect_to set_path
   end
 
   ##
-  # Remove relationship between models, this action never removes items!
+  # Action to unrelate models which respond to:
+  #
+  #   - has_and_belongs_to_many
+  #   - has_many
+  #   - has_one
   #
   def unrelate
 
-    resource_class = params[:resource].classify.constantize
-    resource_tableized = params[:resource].tableize
-    resource = resource_class.find(params[:resource_id])
+    ##
+    # Find the remote object which is named item!
+    #
 
-    # We consider that we are unrelating a has_many or has_and_belongs_to_many
+    item_class = params[:resource].typus_constantize
+    item = item_class.find(params[:resource_id])
 
-    reflection = @resource.reflect_on_association(resource_class.table_name.to_sym)
-    macro = reflection.try(:macro)
-    options = reflection.try(:options)
+    ##
+    # Detect which kind of relationship there's between both models.
+    #
+    #     item respect @item
+    #
 
-    case macro
-    # when :has_one
-    #   attribute = resource_tableized.singularize
-    #   saved_succesfully = @item.update_attribute attribute, nil
-    when :has_many
-      if options.has_key?(:as) # We are in a polymorphic relationship
-        interface = options[:as]
-        saved_succesfully = resource.update_attributes("#{interface}_type" => nil, "#{interface}_id" => nil)
-      else
-        # We have to verify we can unrelate. For example: A Category which has
-        # many posts and Post validates_presence_of Category should not be removed.
-        attribute = @resource.table_name.singularize
-        saved_succesfully = resource.update_attributes(attribute => nil)
-      end
-    when :has_and_belongs_to_many
-      attribute = resource_tableized
-      saved_succesfully = @item.send(attribute).delete(resource)
-    else
-      saved_succesfully = false
-    end
+    # This is not nil in case of a has_many :through association.
+    association_name = params[:association_name].to_sym unless params[:association_name].blank?
 
-    if saved_succesfully
-      flash[:notice] = _t("%{model_a} unrelated from %{model_b}",
-                         :model_a => resource_class.model_name.human,
-                         :model_b => @resource.model_name.human)
+    case item_class.relationship_with(@resource)
+    when :has_one
+      association_name = @resource.model_name.downcase.to_sym
+      worked = item.send(association_name).delete
     else
-      flash[:alert] = _t("%{model_a} cannot be unrelated from %{model_b}",
-                        :model_a => resource_class.model_name.human,
-                        :model_b => @resource.model_name.human)
+      association_name ||= @resource.model_name.tableize.to_sym
+      worked = item.send(association_name).delete(@item)
     end
 
-    redirect_to set_path
-
-  end
-
-  ##
-  # Remove file attachments.
-  #
-  def detach
-    message = if @item.update_attributes(params[:attachment] => nil)
-                "%{attachment} removed."
-              else
-                "%{attachment} can't be removed."
-              end
+    ##
+    # Finally delete the associated object. Depending on your models setup
+    # associated models will be removed or foreign_key will be set to nil.
+    #
 
-    attachment = @resource.human_attribute_name(params[:attachment])
-    notice = _t(message, :attachment => attachment)
+    if worked
+      notice = Typus::I18n.t("%{model} successfully updated.", :model => item_class.model_name.human)
+    else
+      alert = item.error.full_messages
+    end
 
-    redirect_to set_path, :notice => notice
+    redirect_to set_path, :notice => notice, :alert => alert
   end
 
   private
@@ -216,23 +212,39 @@ class Admin::ResourcesController < Admin::BaseController
     @object_name = ActiveModel::Naming.singular(@resource)
   end
 
+  def set_scope
+    @resource = @resource.unscoped
+  end
+
   def get_object
     @item = @resource.find(params[:id])
   end
 
-  def set_fields
-    mapping = case params[:action]
-              when "index" then :list
-              when "new", "edit", "create", "update" then :form
-              else params[:action]
-              end
+  def get_objects
+    eager_loading = @resource.reflect_on_all_associations(:belongs_to).reject { |i| i.options[:polymorphic] }.map { |i| i.name }
+
+    @resource.build_conditions(params).each do |condition|
+      @resource = @resource.where(condition)
+    end
+
+    @resource.build_joins(params).each do |join|
+      @resource = @resource.joins(join)
+    end
 
-    @fields = @resource.typus_fields_for(mapping)
+    if @resource.typus_options_for(:only_user_items)
+      check_resources_ownership
+    end
+
+    @items = @resource.order(set_order).includes(eager_loading)
+  end
+
+  def set_fields
+    @fields = @resource.typus_fields_for(params[:action].action_mapper)
   end
 
   def set_order
     params[:sort_order] ||= "desc"
-    @order = params[:order_by] ? "#{@resource.table_name}.#{params[:order_by]} #{params[:sort_order]}" : @resource.typus_order_by
+    params[:order_by] ? "#{@resource.table_name}.#{params[:order_by]} #{params[:sort_order]}" : @resource.typus_order_by
   end
 
   def redirect_on_success
@@ -242,64 +254,163 @@ class Admin::ResourcesController < Admin::BaseController
     when "create"
       path = { :action => action }
       path.merge!(:id => @item.id) unless action.eql?("index")
-      notice = _t("%{model} successfully created.", :model => @resource.model_name.human)
-    when "update"
+      notice = Typus::I18n.t("%{model} successfully created.", :model => @resource.model_name.human)
+    when "update", "detach"
       path = case action
              when "index"
                params[:back_to] ? "#{params[:back_to]}##{@resource.to_resource}" : { :action => action }
              else
-               { :action => action,
-                 :id => @item.id,
-                 :back_to => params[:back_to] }
+               { :action => action, :id => @item.id, :back_to => params[:back_to] }
              end
-      notice = _t("%{model} successfully updated.", :model => @resource.model_name.human)
+      notice = Typus::I18n.t("%{model} successfully updated.", :model => @resource.model_name.human)
     end
 
     redirect_to path, :notice => notice
   end
 
   ##
-  # When <tt>params[:back_to]</tt> is defined this action is used.
+  # Here what we basically do is to associate objects after they have been
+  # created. It's similar to calling `relate`.
   #
-  # - <tt>has_and_belongs_to_many</tt> relationships.
-  # - <tt>has_many</tt> relationships (polymorphic ones).
+  # We have two objects:
+  #
+  #   - @item: Which is the create object.
+  #   - item: Which is the object which be associated to.
+  #
+  # http://0.0.0.0:3000/admin/entries/new?back_to=%2Fadmin%2Fcategories%2Fedit%2F3&resource=categories&resource_id=3
   #
   def create_with_back_to
 
-    if params[:resource] && params[:resource_id]
-      resource_class = params[:resource].classify.constantize
-      resource_id = params[:resource_id]
-      resource = resource_class.find(resource_id)
-      association = @resource.reflect_on_association(params[:resource].to_sym).macro rescue :polymorphic
-    else
-      association = :has_many
-    end
-
-    case association
-    when :belongs_to
-      @item.save
+    #
+    # Find the remote object which is named item!
+    #
+
+    item_class = params[:resource].typus_constantize
+    item = item_class.find(params[:resource_id]) if params[:resource_id]
+
+    ##
+    # Detect which kind of relationship there's between both models.
+    #
+
+    ##
+    # Here we have something like:
+    #
+    # Eg 1.
+    #
+    #   - We are editing an Order and want to add a new Invoice.
+    #   - Click on "Add New" and we are redirected to the form.
+    #   - We want to know which kind of relationship there's between both
+    #     objects.
+    #
+    #         >> Order.relationship_with(Invoice)
+    #         => :has_one
+    #
+    # Eg 2.
+    #
+    #   - We are editing a Entry and want to add a new Attachment.
+    #   - Click on "Add New" and we are redirected to the form.
+    #   - We want to know which kind of relationship there's between both
+    #     objects.
+    #
+    #         >> Entry.relationship_with(Attachment)
+    #         => :has_and_belongs_to_many
+    #
+    # Eg 3.
+    #
+    #   - We are editing a Entry and want to add a new Comment.
+    #   - Click on "Add New" and we are redirected to the form.
+    #   - We want to know which kind of relationship there's between both
+    #     objects.
+    #
+    #         >> Entry.relationship_with(Comment)
+    #         => :has_many
+    #
+    # Eg 4.
+    #
+    #   - We are editing a Post (Entry) and want to add a new Attachment.
+    #   - Click on "Add New" and we are redirected to the form.
+    #   - We want to know which kind of relationship there's between both
+    #     objects.
+    #
+    #         >> Post.relationship_with(Attachment)
+    #         => :has_and_belongs_to_many
+    #
+
+    case item_class.relationship_with(@resource)
+    when :has_one
+      # Order#invoice = @item
+      association_name = @resource.model_name.downcase.to_sym
+      item.send("#{association_name}=", @item)
+      worked = true
     when :has_and_belongs_to_many
-      @item.save
-      @item.send(params[:resource]) << resource
-    when :has_many
-      @item.save
-      message = _t("%{model} successfully created.", :model => @resource.model_name.human)
-      path = "#{params[:back_to]}?#{params[:selected]}=#{@item.id}"
-    when :polymorphic
-      resource.send(@item.class.to_resource).create(params[@object_name])
+      # Attachment#entries.push(item)
+      association_name = @resource.model_name.tableize.to_sym
+      worked = item.send(association_name).push(@item)
+    when :belongs_to
+      # Entry#comments.push(item)
+      association_name = item_class.model_name.tableize.to_sym
+      if item
+        worked = @item.send(association_name).push(item)
+      end
     end
 
-    flash[:notice] = message || _t("%{model_a} successfully assigned to %{model_b}.",
-                                  :model_a => @item.class.model_name.human,
-                                  :model_b => resource_class.model_name.human)
+    association = @resource.reflect_on_association(association_name)
+
+    ##
+    # Set @back_to
+    #
+
+    @back_to = if item
+                 params[:back_to]
+               else
+                 "#{params[:back_to]}?#{association.primary_key_name}=#{@item.id}"
+               end
+
+    ##
+    # Finally delete the associated object. Depending on your models setup
+    # associated models will be removed or foreign_key will be set to nil.
+    #
+
+    if item
+      if worked
+        notice = Typus::I18n.t("%{model} successfully updated.", :model => item_class.model_name.human)
+      else
+        alert = @item.error.full_messages
+      end
+    end
 
-    redirect_to path || params[:back_to]
+    redirect_to set_path, :notice => notice, :alert => alert
+  end
 
+  def default_action
+    @resource.typus_options_for(:default_action_on_item)
   end
 
-  def select_template(action = params[:action], resource = @resource.to_resource)
-    folder = File.exist?("app/views/admin/#{resource}/#{action}.html.erb") ? resource : 'resources'
-    render "admin/#{folder}/#{action}"
+  ##
+  # If we are trying to create a new Invoice which belongs_to Order, we should
+  # verify before the the Order doesn't have an Invoice, otherwise we would
+  # have and Order with many Invoices which is something not desired.
+  #
+  # Eg:
+  #
+  #     @resource (Invoice)
+  #     params[:resource] = "Order"
+  #     params[:resource_id] = "1"
+  #
+  # Does this Order already has an Invoice. If true, redirect to back.
+  #
+  def check_if_we_can_add_a_new_item
+    if params[:resource] && params[:resource_id]
+      item_class = params[:resource].typus_constantize
+      item = item_class.find(params[:resource_id]) if params[:resource_id]
+
+      if item_class.relationship_with(@resource) == :has_one
+        association_name = @resource.model_name.downcase.to_sym
+        if item.send(association_name)
+          render :text => "Not allowed!", :status => :unprocessable_entity
+        end
+      end
+    end
   end
 
-end
+end