fesplugas-typus 0.9.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.db
+*.log
+_dashboard*
+rdoc/*
+*~
+*.gem
+SPECDOC

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007-2009 Francesc Esplugas Marti
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,80 @@
+= Typus: Effortless admin interface for your Rails application
+
+*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.
+
+- Project site and documentation http://intraducibles.com/projects/typus
+- Screenshoots http://intraducibles.com/projects/typus/screenshots
+- Plugin source http://github.com/fesplugas/typus/tree
+- Google Group http://groups.google.es/group/typus
+
+== For the impatients: Demo in 3 steps
+
+Step 1. Create a Rails application using a template.
+
+    $ rails example.com -m http://intraducibles.com/projects/typus/demo.txt
+
+Step 2. Start the server:
+
+    $ cd example.com && script/server
+
+Step 3. Go to the admin area and enjoy it!
+
+    http://0.0.0.0:3000/admin
+
+== Installing
+
+Install from GitHub the latest version which it's compatible with 
+Rails 2.3.2.
+
+    $ script/plugin install git://github.com/fesplugas/typus.git
+
+Once plugin is installed generate *Typus* files and migrate your 
+database (<tt>typus_users</tt> table is created)
+
+    $ script/generate typus
+    $ rake db:migrate
+
+To create the first user, start the application server, go to 
+http://0.0.0.0:3000/admin and follow the instructions.
+
+== Support Typus
+
+*Typus* is licensed under the MIT license. As an experiment we 
+encourage you to support this project by donating[http://intraducibles.com/projects/typus/donate] 
+90 euros if you are a developer or studio. Donations do allow us to spend more 
+time working and supporting the project. All contributions are much appreciated!
+
+Hire us to work on your next project. We build large and small websites.
+
+Contribute your patches to the community & support people on the 
+mailing list.
+
+Tell everybody about Typus, tell your friends and colleagues about 
+Typus and blog about Typus.
+
+== Contributors
+
+- Laia Gargallo (Lover and tea provider) http://azotacalles.net
+- Isaac Feliu (Codereview on first public release) http://www.vesne.com
+- Lluis Folch (Icons, feedback & crazy ideas) http://wet-floor.com
+- Sergio Espeja (Code) http://github.com/spejman
+- Eadz (Code) http://github.com/eadz
+- Anthony Underwood (Code) http://github.com/aunderwo
+- Felipe Talavera (Code) http://github.com/flype
+- Erik Tigerholm (Code) http://github.com/eriktigerholm
+- George Guimarães (Translation pt-br and code) http://github.com/georgeguimaraes
+- José Valim (Code) http://github.com/josevalim
+- Luqman Amjad (Code) http://github.com/snake
+
+== Acknowledgments
+
+- *Typus* uses "Paginator" by Bruce Williams http://codefluency.com.
+- *Typus* has been inspired by "Django Admin" http://www.djangoproject.com.
+
+Copyright (c) 2007-2009 Francesc Esplugas Marti, released under the 
+MIT license

data/Rakefile

@@ -0,0 +1,61 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the typus plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the typus plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_files.add ['README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Typus documentation'
+  rdoc.main = 'README.rdoc'
+  rdoc.options << '--charset=UTF-8'
+  rdoc.options << '--inline-source'
+  rdoc.options << '--line-numbers'
+end
+
+desc 'Generate specdoc-style documentation from tests'
+task :specs do
+
+  puts 'Started'
+  timer, count = Time.now, 0
+
+  File.open('SPECDOC', 'w') do |file|
+    Dir.glob('test/**/*_test.rb').each do |test|
+      test =~ /.*\/([^\/].*)_test.rb$/
+      file.puts "#{$1.gsub('_', ' ').capitalize} should:" if $1
+      File.read(test).map { |line| /test_(.*)$/.match line }.compact.each do |spec|
+        file.puts "- #{spec[1].gsub('_', ' ')}"
+        sleep 0.001; print '.'; $stdout.flush; count += 1
+      end
+      file.puts
+    end
+  end
+
+  puts "\nFinished in #{Time.now - timer} seconds.\n"
+  puts "#{count} specifications documented"
+
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "typus"
+    gemspec.summary = "Effortless backend interface for Ruby on Rails applications. (Admin scaffold generator.)"
+    gemspec.email = "francesc@intraducibles.com"
+    gemspec.homepage = "http://intraducibles.com/projects/typus"
+    gemspec.description = "Effortless backend interface for Ruby on Rails applications. (Admin scaffold generator.)"
+    gemspec.authors = ["Francesc Esplugas"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.9.0

data/app/controllers/admin/master_controller.rb

@@ -0,0 +1,324 @@
+class Admin::MasterController < ApplicationController
+
+  layout 'admin'
+
+  include Typus::Authentication
+  include Typus::Format
+  include Typus::Locale
+  include Typus::Reloader
+
+  if Typus::Configuration.options[:ssl]
+    include SslRequirement
+    ssl_required :index, :new, :create, :edit, :show, :update, :destroy, :toggle, :position, :relate, :unrelate
+  end
+
+  filter_parameter_logging :password
+
+  before_filter :reload_config_et_roles
+
+  before_filter :require_login
+
+  before_filter :set_locale
+
+  before_filter :set_resource
+  before_filter :find_item, 
+                :only => [ :show, :edit, :update, :destroy, :toggle, :position, :relate, :unrelate ]
+
+  before_filter :check_ownership_of_item, 
+                :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 :check_if_user_can_perform_action_on_resource
+
+  before_filter :set_order, 
+                :only => [ :index ]
+  before_filter :set_fields, 
+                :only => [ :index, :new, :edit, :create, :update, :show ]
+
+  ##
+  # 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 your formats.
+  #
+  def index
+
+    @conditions, @joins = @resource[:class].build_conditions(params)
+
+    respond_to do |format|
+      format.html { generate_html }
+      @resource[:class].typus_export_formats.each do |f|
+        format.send(f) { send("generate_#{f}") }
+      end
+    end
+
+  rescue Exception => error
+    error_handler(error)
+  end
+
+  def new
+
+    item_params = params.dup
+    %w( controller action resource resource_id back_to selected ).each do |param|
+      item_params.delete(param)
+    end
+
+    @item = @resource[:class].new(item_params.symbolize_keys)
+
+    select_template :new
+
+  end
+
+  ##
+  # Create new items. There's an special case when we create an 
+  # item from another item. In this case, after the item is 
+  # created we also create the relationship between these items. 
+  #
+  def create
+
+    @item = @resource[:class].new(params[:item])
+
+    if @item.attributes.include?(Typus.user_fk)
+      @item.attributes = { Typus.user_fk => session[:typus_user_id] }
+    end
+
+    if @item.valid?
+      create_with_back_to and return if params[:back_to]
+      @item.save
+      flash[:success] = _("{{model}} successfully created.", :model => @resource[:class].human_name)
+      if @resource[:class].typus_options_for(:index_after_save)
+        redirect_to :action => 'index'
+      else
+        redirect_to :action => @resource[:class].typus_options_for(:default_action_on_item), :id => @item.id
+      end
+    else
+      select_template :new
+    end
+
+  end
+
+  def edit
+    item_params = params.dup
+    %w( action controller model model_id back_to id resource resource_id ).each { |p| item_params.delete(p) }
+    # We assign the params passed trough the url
+    @item.attributes = item_params
+    @previous, @next = @item.previous_and_next(item_params)
+    select_template :edit
+  end
+
+  def show
+
+    @previous, @next = @item.previous_and_next
+
+    respond_to do |format|
+      format.html { select_template :show }
+      format.xml  { render :xml => @item }
+    end
+
+  end
+
+  def update
+    if @item.update_attributes(params[:item])
+      flash[:success] = _("{{model}} successfully updated.", :model => @resource[:class].human_name)
+      path = if @resource[:class].typus_options_for(:index_after_save)
+               params[:back_to] ? "#{params[:back_to]}##{@resource[:self]}" : { :action => 'index' }
+             else
+               { :action => @resource[:class].typus_options_for(:default_action_on_item), :id => @item.id }
+             end
+      redirect_to path
+    else
+      @previous, @next = @item.previous_and_next
+      select_template :edit
+    end
+  end
+
+  def destroy
+    @item.destroy
+    flash[:success] = _("{{model}} successfully removed.", :model => @resource[:class].human_name)
+    redirect_to :back
+  rescue Exception => error
+    error_handler(error, params.merge(:action => 'index', :id => nil))
+  end
+
+  def toggle
+    if @resource[:class].typus_options_for(:toggle)
+      @item.toggle!(params[:field])
+      flash[:success] = _("{{model}} {{attribute}} changed.", 
+                          :model => @resource[:class].human_name, 
+                          :attribute => params[:field].humanize.downcase)
+    else
+      flash[:notice] = _("Toggle is disabled.")
+    end
+    redirect_to :back
+  end
+
+  ##
+  # Change item position. This only works if acts_as_list is 
+  # installed. We can then move items:
+  #
+  #   params[:go] = 'move_to_top'
+  #
+  # Available positions are move_to_top, move_higher, move_lower, 
+  # move_to_bottom.
+  #
+  def position
+    @item.send(params[:go])
+    flash[:success] = _("Record moved {{to}}.", :to => params[:go].gsub(/move_/, '').humanize.downcase)
+    redirect_to :back
+  end
+
+  ##
+  # Relate a model object to another, this action is used only by the 
+  # has_and_belongs_to_many relationships.
+  #
+  def relate
+
+    resource_class = params[:related][:model].constantize
+    resource_tableized = params[:related][:model].tableize
+
+    @item.send(resource_tableized) << resource_class.find(params[:related][:id])
+
+    flash[:success] = _("{{model_a}} related to {{model_b}}.", 
+                        :model_a => resource_class.human_name, 
+                        :model_b => @resource[:class].human_name)
+
+    redirect_to :action => @resource[:class].typus_options_for(:default_action_on_item), 
+                :id => @item.id, 
+                :anchor => resource_tableized
+
+  end
+
+  ##
+  # Remove relationship between models.
+  #
+  def unrelate
+
+    resource_class = params[:resource].classify.constantize
+    resource = resource_class.find(params[:resource_id])
+
+    case params[:association]
+    when 'has_and_belongs_to_many'
+      @item.send(resource_class.table_name).delete(resource)
+      message = "{{model_a}} unrelated from {{model_b}}."
+    when 'has_many', 'has_one'
+      resource.destroy
+      message = "{{model_a}} removed from {{model_b}}."
+    end
+
+    flash[:success] = _(message, :model_a => resource_class.human_name, :model_b => @resource[:class].human_name)
+
+    redirect_to :controller => @resource[:self], 
+                :action => @resource[:class].typus_options_for(:default_action_on_item), 
+                :id => @item.id, 
+                :anchor => resource_class.table_name
+
+  end
+
+private
+
+  def set_resource
+    resource = params[:controller].split('/').last
+    @resource = { :self => resource, :class => resource.classify.constantize }
+  rescue Exception => error
+    error_handler(error)
+  end
+
+  ##
+  # Find model when performing an edit, update, destroy, relate, 
+  # unrelate ...
+  #
+  def find_item
+    @item = @resource[:class].find(params[:id])
+  end
+
+  ##
+  # If item is owned by another user, we only can perform a 
+  # show action on the item. Updated item is also blocked.
+  #
+  #   before_filter :check_ownership_of_item, :only => [ :edit, :update, :destroy ]
+  #
+  def check_ownership_of_item
+
+    # If current_user is a root user, by-pass.
+    return if @current_user.is_root?
+
+    # If the current model doesn't include a key which relates it with the
+    # current_user, by-pass.
+    return unless @item.respond_to?(Typus.user_fk)
+
+    # If item is owned by the user ...
+    unless @item.send(Typus.user_fk) == session[:typus_user_id]
+      flash[:notice] = _("Record owned by another user.")
+      redirect_to :action => 'show', :id => @item.id
+    end
+
+  end
+
+  def set_fields
+    @fields = case params[:action]
+              when 'index'
+                @resource[:class].typus_fields_for(:list)
+              when 'new', 'edit', 'create', 'update'
+                @resource[:class].typus_fields_for(:form)
+              else
+                @resource[:class].typus_fields_for(params[:action])
+              end
+  end
+
+  def set_order
+    params[:sort_order] ||= 'desc'
+    @order = params[:order_by] ? "#{@resource[:class].table_name}.#{params[:order_by]} #{params[:sort_order]}" : @resource[:class].typus_order_by
+  end
+
+  def select_template(template, resource = @resource[:self])
+    folder = (File.exists?("app/views/admin/#{resource}/#{template}.html.erb")) ? resource : 'resources'
+    render :template => "admin/#{folder}/#{template}"
+  end
+
+  ##
+  # When <tt>params[:back_to]</tt> is defined this action is used.
+  #
+  # - <tt>has_and_belongs_to_many</tt> relationships.
+  # - <tt>has_many</tt> relationships (polymorphic ones).
+  #
+  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[:class].reflect_on_association(params[:resource].to_sym).macro rescue :polymorphic
+    else
+      association = :has_many
+    end
+
+    case association
+    when :belongs_to
+      @item.save
+    when :has_and_belongs_to_many
+      @item.save
+      @item.send(params[:resource]) << resource
+    when :has_many
+      @item.save
+      message = _("{{model}} successfully created.", :model => @resource[:class].human_name)
+      path = "#{params[:back_to]}?#{params[:selected]}=#{@item.id}"
+    when :polymorphic
+      resource.send(@item.class.name.tableize).create(params[:item])
+    end
+
+    flash[:success] = message || _("{{model_a}} successfully assigned to {{model_b}}.", 
+                                 :model_a => @item.class, 
+                                 :model_b => resource_class.name)
+    redirect_to path || "#{params[:back_to]}##{@resource[:self]}"
+
+  end
+
+  def error_handler(error, path = admin_dashboard_path)
+    raise error unless Rails.env.production?
+    flash[:error] = "#{error.message} (#{@resource[:class]})"
+    redirect_to path
+  end
+
+end

data/app/controllers/typus_controller.rb

@@ -0,0 +1,127 @@
+class TypusController < ApplicationController
+
+  layout :select_layout
+
+  include Typus::Authentication
+  include Typus::Locale
+  include Typus::QuickEdit
+  include Typus::Reloader
+
+  if Typus::Configuration.options[:ssl]
+    include SslRequirement
+    ssl_required :sign_in, :sign_out, 
+                 :dashboard, 
+                 :recover_password, :reset_password
+  end
+
+  filter_parameter_logging :password
+
+  before_filter :set_locale
+
+  before_filter :reload_config_et_roles
+  before_filter :require_login, 
+                :except => [ :sign_up, :sign_in, :sign_out, 
+                             :recover_password, :reset_password, 
+                             :quick_edit ]
+
+  before_filter :check_if_user_can_perform_action_on_resource_without_model, 
+                :except => [ :sign_up, :sign_in, :sign_out, 
+                             :dashboard, 
+                             :recover_password, :reset_password, 
+                             :quick_edit, :set_locale ]
+
+  before_filter :recover_password_disabled?, 
+                :only => [ :recover_password, :reset_password ]
+
+  def dashboard
+    flash[:notice] = _("There are not defined applications in config/typus/*.yml.") if Typus.applications.empty?
+  end
+
+  def sign_in
+
+    redirect_to admin_sign_up_path and return if Typus.user_class.count.zero?
+
+    if request.post?
+      if user = Typus.user_class.authenticate(params[:user][:email], params[:user][:password])
+        session[:typus_user_id] = user.id
+        redirect_to params[:back_to] || admin_dashboard_path
+      else
+        flash[:error] = _("The email and/or password you entered is invalid.")
+        redirect_to admin_sign_in_path
+      end
+    end
+
+  end
+
+  def sign_out
+    session[:typus_user_id] = nil
+    redirect_to admin_sign_in_path
+  end
+
+  def recover_password
+    if request.post?
+      if user = Typus.user_class.find_by_email(params[:user][:email])
+        ActionMailer::Base.default_url_options[:host] = request.host_with_port
+        TypusMailer.deliver_reset_password_link(user)
+        flash[:success] = _("Password recovery link sent to your email.")
+        redirect_to admin_sign_in_path
+      else
+        redirect_to admin_recover_password_path
+      end
+    end
+  end
+
+  ##
+  # Available if Typus::Configuration.options[:recover_password] is enabled.
+  #
+  def reset_password
+    @user = Typus.user_class.find_by_token!(params[:token])
+    if request.post?
+      @user.password = params[:user][:password]
+      @user.password_confirmation = params[:user][:password_confirmation]
+      if @user.save
+        flash[:success] = _("You can login with your new password.")
+        redirect_to admin_sign_in_path
+      else
+        flash[:error] = _("Passwords don't match.")
+        redirect_to admin_reset_password_path(:token => params[:token])
+      end
+    end
+  end
+
+  def sign_up
+
+    redirect_to admin_sign_in_path and return unless Typus.user_class.count.zero?
+
+    if request.post?
+
+      email, password = params[:user][:email], 'columbia'
+      user = Typus.user_class.generate(email, password)
+
+      if user.save
+        session[:typus_user_id] = user.id
+        flash[:notice] = _("Password set to \"{{password}}\".", :password => password)
+        redirect_to admin_dashboard_path
+      else
+        flash[:error] = _("That doesn't seem like a valid email address.")
+      end
+
+    else
+
+      flash[:notice] = _("Enter your email below to create the first user.")
+
+    end
+
+  end
+
+private
+
+  def recover_password_disabled?
+    redirect_to admin_sign_in_path unless Typus::Configuration.options[:recover_password]
+  end
+
+  def select_layout
+    [ 'sign_up', 'sign_in', 'sign_out', 'recover_password', 'reset_password' ].include?(action_name) ? 'typus' : 'admin'
+  end
+
+end