fesplugas-typus 0.9.0

data/lib/typus/configuration.rb

@@ -0,0 +1,92 @@
+module Typus
+
+  module Configuration
+
+    ##
+    # Default Typus options which can be overwritten from the initializer.
+    #
+    typus_options = { :app_name => 'Typus', 
+                      :config_folder => 'config/typus', 
+                      :email => 'admin@example.com', 
+                      :locales => [ [ "English", :en ] ], 
+                      :recover_password => false, 
+                      :root => 'admin', 
+                      :ssl => false, 
+                      :templates_folder => 'admin/templates',
+                      :user_class_name => 'TypusUser', 
+                      :user_fk => 'typus_user_id' }
+
+    ##
+    # Default model options which can be overwritten from the initializer.
+    #
+    model_options = { :default_action_on_item => 'edit', 
+                      :end_year => nil,
+                      :form_rows => 10, 
+                      :icon_on_boolean => true, 
+                      :index_after_save => false, 
+                      :minute_step => 5, 
+                      :nil => 'nil', 
+                      :per_page => 15, 
+                      :sidebar_selector => 5, 
+                      :start_year => nil, 
+                      :toggle => true }
+
+    @@options = typus_options.merge(model_options)
+
+    mattr_accessor :options
+
+    ##
+    # Read Typus Configuration files placed on <tt>config/typus/**/*.yml</tt>.
+    #
+    #   Typus::Configuration.config! overwrites @@config
+    #
+    def self.config!
+
+      files = Dir["#{Rails.root}/#{options[:config_folder]}/**/*.yml"].sort
+      files = files.delete_if { |x| x.include?('_roles.yml') }
+
+      @@config = {}
+      files.each do |file|
+        data = YAML.load_file(file)
+        @@config = @@config.merge(data) if data
+      end
+
+      return @@config
+
+    end
+
+    mattr_accessor :config
+
+    ##
+    # Read Typus Roles from configuration files placed on <tt>config/typus/**/*_roles.yml</tt>.
+    #
+    #   Typus::Configuration.roles! overwrites @@roles
+    #
+    def self.roles!
+
+      files = Dir["#{Rails.root}/#{options[:config_folder]}/**/*_roles.yml"].sort
+
+      @@roles = { options[:root] => {} }
+
+      files.each do |file|
+        data = YAML.load_file(file)
+        next unless data
+        data.each do |key, value|
+          next unless value
+          begin
+            @@roles[key] = @@roles[key].merge(value)
+          rescue
+            @@roles[key] = value
+          end
+        end
+      end
+
+      return @@roles.compact
+
+    end
+
+    mattr_accessor :roles
+
+  end
+
+end

data/lib/typus/format.rb

@@ -0,0 +1,56 @@
+module Typus
+
+  module Format
+
+    protected
+
+    def generate_html
+
+      items_count = @resource[:class].count(:joins => @joins, :conditions => @conditions)
+      items_per_page = @resource[:class].typus_options_for(:per_page).to_i
+
+      @pager = ::Paginator.new(items_count, items_per_page) do |offset, per_page|
+        data(:limit => per_page, :offset => offset)
+      end
+
+      @items = @pager.page(params[:page])
+
+      select_template :index
+
+    end
+
+    def generate_csv
+
+      require 'fastercsv'
+
+      fields = @resource[:class].typus_fields_for(:csv).collect { |i| i.first }
+      csv_string = FasterCSV.generate do |csv|
+        csv << fields.map { |f| _(f.humanize) }
+        data.each do |item|
+          csv << fields.map { |f| item.send(f) }
+        end
+      end
+
+      filename = "#{Time.now.strftime("%Y%m%d%H%M%S")}_#{@resource[:self]}.csv"
+      send_data(csv_string,
+               :type => 'text/csv; charset=utf-8; header=present',
+               :filename => filename)
+
+    rescue LoadError
+      render :text => _("FasterCSV is not installed.")
+    end
+
+    def generate_xml
+      fields = @resource[:class].typus_fields_for(:xml).collect { |i| i.first }
+      render :xml => data.to_xml(:only => fields)
+    end
+
+    def data(*args)
+      options = { :joins => @joins, :conditions => @conditions, :order => @order }
+      options.merge!(args.extract_options!)
+      @resource[:class].find(:all, options)
+    end
+
+  end
+
+end

data/lib/typus/generator.rb

@@ -0,0 +1,173 @@
+module Typus
+
+  def self.generator
+
+    logger = Logger.new("#{Rails.root}/log/#{Rails.env}.log")
+
+    # Create app/controllers/admin if doesn't exist.
+    admin_controllers_folder = "#{Rails.root}/app/controllers/admin"
+    Dir.mkdir(admin_controllers_folder) unless File.directory?(admin_controllers_folder)
+
+    # Get a list of all available app/controllers/admin
+    admin_controllers = Dir["#{Rails.root}/vendor/plugins/*/app/controllers/admin/*.rb", "#{Rails.root}/app/controllers/admin/*.rb"]
+    admin_controllers = admin_controllers.map { |i| File.basename(i) }
+
+    # Create app/views/admin if doesn't exist.
+    admin_views_folder = "#{Rails.root}/app/views/admin"
+    Dir.mkdir(admin_views_folder) unless File.directory?(admin_views_folder)
+
+    # Create test/functional/admin if doesn't exist.
+    if File.directory?("#{Rails.root}/test")
+      admin_controller_tests_folder = "#{Rails.root}/test/functional/admin"
+      Dir.mkdir(admin_controller_tests_folder) unless File.directory?(admin_controller_tests_folder)
+    end
+
+    # Get a list of all available functional test for admin.
+    admin_controller_tests = Dir["#{Rails.root}/vendor/plugins/*/test/functional/admin/*.rb", "#{Rails.root}/test/functional/admin/*.rb"]
+    admin_controller_tests = admin_controller_tests.map { |i| File.basename(i) }
+
+    # Generate unexisting controllers for resources which are not tied to
+    # a model.
+    resources.each do |resource|
+
+      controller_filename = "#{resource.underscore}_controller.rb"
+      controller_location = "#{admin_controllers_folder}/#{controller_filename}"
+
+      if !admin_controllers.include?(controller_filename)
+        controller = File.open(controller_location, "w+")
+        content = <<-RAW
+# Controller generated by Typus, use it to extend admin functionality.
+class Admin::#{resource}Controller < TypusController
+
+  ##
+  # This controller was generated because you have defined a resource 
+  # which is not tied to a model on your <tt>config/typus/XXXXXX_roles.yml</tt> 
+  # configuration file.
+  #
+  #     admin:
+  #       #{resource}: index
+  #
+
+  def index
+  end
+
+end
+      RAW
+
+        controller.puts(content)
+        controller.close
+        logger.info "=> [typus] Admin::#{resource}Controller successfully created."
+
+      end
+
+      # And now we create the view.
+      view_folder = "#{admin_views_folder}/#{resource.underscore}"
+      view_filename = "index.html.erb"
+
+      if !File.exists?("#{view_folder}/#{view_filename}")
+        Dir.mkdir(view_folder) unless File.directory?(view_folder)
+        view = File.open("#{view_folder}/#{view_filename}", "w+")
+        content = <<-RAW
+<!-- Sidebar -->
+
+<% content_for :sidebar do %>
+<%= typus_block :location => 'dashboard', :partial => 'sidebar' %>
+<% end %>
+
+<!-- Content -->
+
+<h2><%= link_to _('Dashboard'), admin_dashboard_path %> &rsaquo; #{resource.humanize}</h2>
+
+<p>And here we do whatever we want to ...</p>
+
+        RAW
+        view.puts(content)
+        view.close
+        logger.info "=> [typus] app/views/admin/#{resource.underscore}/index.html.erb successfully created."
+      end
+
+    end
+
+    # Generate unexisting controllers for resources which are tied to a 
+    # model.
+    models.each do |model|
+
+      # Controller app/controllers/admin/*
+      controller_filename = "#{model.tableize}_controller.rb"
+      controller_location = "#{admin_controllers_folder}/#{controller_filename}"
+
+      if !admin_controllers.include?(controller_filename)
+        controller = File.open(controller_location, "w+")
+
+        content = <<-RAW
+# Controller generated by Typus, use it to extend admin functionality.
+class Admin::#{model.pluralize}Controller < Admin::MasterController
+
+=begin
+
+  ##
+  # You can overwrite any Admin::MasterController methods.
+  #
+  def index
+  end
+
+=end
+
+=begin
+
+  ##
+  # You can extend Admin::MasterController with your methods.
+  #
+  # This actions have to be defined in <tt>config/typus/application.yml</tt>.
+  #
+  #   #{model}:
+  #     actions:
+  #       index: custom_action
+  #       edit: custom_action_for_an_item
+  #
+  def custom_action
+  end
+
+  def custom_action_for_an_item
+  end
+
+=end
+
+end
+        RAW
+
+        controller.puts(content)
+        controller.close
+        logger.info "=> [typus] Admin::#{model.pluralize}Controller successfully created."
+      end
+
+      # Test test/functional/admin/*_test.rb
+      test_filename = "#{model.tableize}_controller_test.rb"
+      test_location = "#{admin_controller_tests_folder}/#{test_filename}"
+
+      if !admin_controller_tests.include?(test_filename) && File.directory?("#{Rails.root}/test")
+        test = File.open(test_location, "w+")
+
+        content = <<-RAW
+require 'test_helper'
+
+class Admin::#{model.pluralize}ControllerTest < ActionController::TestCase
+
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+
+end
+        RAW
+
+        test.puts(content)
+        test.close
+        logger.info "=> [typus] Admin::#{model.pluralize}ControllerTest successfully created."
+      end
+
+    end
+
+  end
+
+end

data/lib/typus/hash.rb

@@ -0,0 +1,10 @@
+class Hash
+
+  ##
+  # Remove nil and empty keys.
+  #
+  def compact
+    delete_if { |key, value| value.nil? || value.empty? }
+  end
+
+end

data/lib/typus/locale.rb

@@ -0,0 +1,17 @@
+module Typus
+
+  module Locale
+
+    def set_locale
+      if params[:locale]
+        I18n.locale = params[:locale]
+        session[:typus_locale] = params[:locale]
+        redirect_to :back
+      else
+        I18n.locale = session[:typus_locale] || Typus.default_locale
+      end
+    end
+
+  end
+
+end

data/lib/typus/object.rb

@@ -0,0 +1,22 @@
+class Object
+
+  ##
+  # Instead of having to translate strings and defining a default value:
+  #
+  #     t('Hello World!', :default => 'Hello World!')
+  #
+  # We define this method to define the value only once:
+  #
+  #     _('Hello World!')
+  #
+  # Note that interpolation still works ...
+  #
+  #     _('Hello {{world}}!', :world => @world)
+  #
+  def _(msg, *args)
+    options = args.extract_options!
+    options[:default] = msg
+    I18n.t(msg, options)
+  end
+
+end

data/lib/typus/quick_edit.rb

@@ -0,0 +1,33 @@
+module Typus
+
+  module QuickEdit
+
+    def quick_edit
+
+      render :text => '' and return unless session[:typus_user_id]
+
+      url = url_for :controller => "admin/#{params[:resource]}", 
+                    :action => 'edit', 
+                    :id => params[:id]
+
+      @content = <<-HTML
+  var links = '';
+  links += '<div id="quick_edit">';
+  links += '<a href=\"#{url}\">#{params[:message]}</a>';
+  links += '</div>';
+  links += '<style type="text/css">';
+  links += '<!--';
+  links += '#quick_edit { font-size: 11px; float: right; position: fixed; right: 0px; background: #{params[:color]}; margin: 5px; padding: 3px 5px; }';
+  links += '#quick_edit a { color: #FFF; font-weight: bold; }'
+  links += '-->';
+  links += '</style>';
+  document.write(links);
+        HTML
+
+      render :text => @content
+
+    end
+
+  end
+
+end

data/lib/typus/reloader.rb

@@ -0,0 +1,17 @@
+module Typus
+
+  module Reloader
+
+    ##
+    # Reload config and roles when app is running in development.
+    #
+    def reload_config_et_roles
+      return if Rails.env.production?
+      logger.info "=> [typus] Configuration files have been reloaded."
+      Typus::Configuration.roles!
+      Typus::Configuration.config!
+    end
+
+  end
+
+end

data/lib/typus/string.rb

@@ -0,0 +1,11 @@
+class String
+
+  def typus_actions_for(filter)
+    Typus::Configuration.config[self]['actions'][filter.to_s].split(', ') rescue []
+  end
+
+  def typus_defaults_for(filter)
+    Typus::Configuration.config[self][filter.to_s].split(', ') rescue []
+  end
+
+end

data/lib/typus/user.rb

@@ -0,0 +1,137 @@
+module Typus
+
+  module EnableAsTypusUser
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def enable_as_typus_user
+
+        extend ClassMethodsMixin
+
+        attr_accessor :password
+
+        validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/
+        validates_presence_of :email
+        validates_uniqueness_of :email
+
+        validates_confirmation_of :password, :if => :password_required?
+        validates_length_of :password, :within => 8..40, :if => :password_required?
+        validates_presence_of :password, :if => :password_required?
+
+        validates_presence_of :role
+
+        before_save :initialize_salt, :encrypt_password, :initialize_token
+
+        include InstanceMethods
+
+      end
+
+    end
+
+    module ClassMethodsMixin
+
+      def role
+        Typus::Configuration.roles.keys.sort
+      end
+
+      def authenticate(email, password)
+        user = find_by_email_and_status(email, true)
+        user && user.authenticated?(password) ? user : nil
+      end
+
+      def generate(email, password, role = Typus::Configuration.options[:root], status = true)
+        new :email => email, 
+            :password => password, 
+            :password_confirmation => password, 
+            :role => role, 
+            :status => status
+      end
+
+    end
+
+    module InstanceMethods
+
+      def full_name(*args)
+        options = args.extract_options!
+        full_name = (!first_name.empty? && !last_name.empty?) ? "#{first_name} #{last_name}" : email
+        full_name << " (#{role})" if options[:display_role]
+        return full_name
+      end
+
+     def authenticated?(password)
+        crypted_password == encrypt(password)
+      end
+
+      def resources
+        Typus::Configuration.roles[role].compact
+      end
+
+      def can_perform?(resource, action, options = {})
+
+        if options[:special]
+          _action = action
+        else
+          _action = case action
+                    when 'new', 'create':       'create'
+                    when 'index', 'show':       'read'
+                    when 'edit', 'update':      'update'
+                    when 'position':            'update'
+                    when 'toggle':              'update'
+                    when 'relate', 'unrelate':  'update'
+                    when 'destroy':             'delete'
+                    else
+                      action
+                    end
+        end
+
+        # OPTIMIZE: We should not use a rescue.
+        resources[resource.to_s].split(', ').include?(_action) rescue false
+
+      end
+
+      def is_root?
+        role == Typus::Configuration.options[:root]
+      end
+
+    protected
+
+      def generate_hash(string)
+        Digest::SHA1.hexdigest(string)
+      end
+
+      def encrypt_password
+        return if password.blank?
+        self.crypted_password = encrypt(password)
+      end
+
+      def encrypt(string)
+        generate_hash("--#{salt}--#{string}")
+      end
+
+      def initialize_salt
+        self.salt = generate_hash("--#{Time.now.utc.to_s}--#{email}--") if new_record?
+      end
+
+      def initialize_token
+        generate_token if new_record?
+      end
+
+      def generate_token
+        self.token = encrypt("--#{Time.now.utc.to_s}--#{password}--").first(12)
+      end
+
+      def password_required?
+        crypted_password.blank? || !password.blank?
+      end
+
+    end
+
+  end
+
+end
+
+ActiveRecord::Base.send :include, Typus::EnableAsTypusUser