typus 0.9.17

data/generators/typus/typus_generator.rb

@@ -0,0 +1,122 @@
+class TypusGenerator < Rails::Generator::Base
+
+  def manifest
+
+    record do |m|
+
+      # Default name for our application.
+      application = Rails.root.basename
+
+      # To create <tt>application.yml</tt> and <tt>application_roles.yml</tt> 
+      # detect available AR models on the application.
+      models = Dir['app/models/*.rb'].collect { |x| File.basename(x).sub(/\.rb$/,'').camelize }
+      ar_models = []
+
+      models.each do |model|
+        begin
+          klass = model.constantize
+          active_record_model = klass.superclass.equal?(ActiveRecord::Base) && !klass.abstract_class?
+          active_record_model_with_sti = klass.superclass.superclass.equal?(ActiveRecord::Base)
+          ar_models << klass if active_record_model || active_record_model_with_sti
+        rescue Exception => error
+          puts "=> [typus] #{error.message} on '#{class_name}'."
+        end
+      end
+
+      # Configuration files
+      config_folder = Typus::Configuration.options[:config_folder]
+      Dir.mkdir(config_folder) unless File.directory?(config_folder)
+
+      configuration = { :base => '', :roles => '' }
+
+      ar_models.sort{ |x,y| x.class_name <=> y.class_name }.each do |model|
+
+        # Detect all relationships except polymorphic belongs_to using reflection.
+        relationships = [ :belongs_to, :has_and_belongs_to_many, :has_many, :has_one ].map do |relationship|
+                          model.reflect_on_all_associations(relationship).reject { |i| i.options[:polymorphic] }.map { |i| i.name.to_s }
+                        end.flatten.sort
+
+        # Remove foreign key and polymorphic type attributes
+        reject_columns = []
+        model.reflect_on_all_associations(:belongs_to).each do |i|
+          reject_columns << model.columns_hash[i.name.to_s + '_id']
+          reject_columns << model.columns_hash[i.name.to_s + '_type'] if i.options[:polymorphic]
+        end
+
+        model_columns = model.columns - reject_columns
+
+        # Don't show `text` fields and timestamps in lists.
+        list = model_columns.reject { |c| c.sql_type == 'text' || %w( created_at updated_at ).include?(c.name) }.map(&:name)
+        # Don't show timestamps in forms.
+        form = model_columns.reject { |c| %w( id created_at updated_at ).include?(c.name) }.map(&:name)
+        # Show all model columns in the show action.
+        show = model_columns.map(&:name)
+
+        # We want attributes of belongs_to relationships to be shown in our 
+        # field collections if those are not polymorphic.
+        [ list, form, show ].each do |fields|
+          fields << model.reflect_on_all_associations(:belongs_to).reject { |i| i.options[:polymorphic] }.map { |i| i.name.to_s }
+          fields.flatten!
+        end
+
+        configuration[:base] << <<-RAW
+#{model}:
+  fields:
+    list: #{list.join(', ')}
+    form: #{form.join(', ')}
+    show: #{show.join(', ')}
+  actions:
+    index:
+    edit:
+  order_by:
+  relationships: #{relationships.join(', ')}
+  filters:
+  search:
+  application: #{application}
+  description:
+
+        RAW
+
+        configuration[:roles] << <<-RAW
+  #{model}: create, read, update, delete
+        RAW
+
+      end
+
+      Dir["#{Typus.root}/generators/typus/templates/config/typus/*"].each do |f|
+        base = File.basename(f)
+        m.template "config/typus/#{base}", "#{config_folder}/#{base}", 
+                   :assigns => { :configuration => configuration }
+      end
+
+      # Initializer
+
+      [ 'config/initializers/typus.rb' ].each do |initializer|
+        m.template initializer, initializer, :assigns => { :application => application }
+      end
+
+      # Assets
+
+      [ 'public/stylesheets/admin', 
+        'public/javascripts/admin', 
+        'public/images/admin' ].each { |f| Dir.mkdir(f) unless File.directory?(f) }
+
+      [ 'public/stylesheets/admin/screen.css', 
+        'public/stylesheets/admin/reset.css', 
+        'public/javascripts/admin/application.js' ].each { |f| m.file f, f }
+
+      Dir["#{Typus.root}/generators/typus/templates/public/images/admin/*"].each do |f|
+        file = "public/images/admin/#{File.basename(f)}"
+        m.file file, file
+      end
+
+      # Migration file
+
+      m.migration_template 'db/create_typus_users.rb', 'db/migrate', 
+                            { :migration_file_name => 'create_typus_users' }
+
+    end
+
+  end
+
+end

data/generators/typus_update_schema_to_01/templates/config/typus.yml

@@ -0,0 +1,14 @@
+TypusUser:
+  fields:
+    list: email, role, status
+    form: first_name, last_name, role, email, password, password_confirmation
+    options:
+      selectors: role
+      booleans:
+        status: Active, Inactive
+  filters: status, role
+  search: first_name, last_name, email, role
+  application: Typus
+  description: System Users Administration
+  options:
+    icon_on_boolean: false

data/generators/typus_update_schema_to_01/templates/migration.rb

@@ -0,0 +1,11 @@
+class UpdateTypusSchemaTo01 < ActiveRecord::Migration
+
+  def self.up
+    rename_column :typus_users, :roles, :role
+  end
+
+  def self.down
+    rename_column :typus_users, :role, :roles
+  end
+
+end

data/generators/typus_update_schema_to_01/typus_update_schema_to_01_generator.rb

@@ -0,0 +1,19 @@
+class TypusUpdateSchemaTo01Generator < Rails::Generator::Base
+
+  def manifest
+
+    record do |m|
+
+      config_folder = Typus::Configuration.options[:config_folder]
+      Dir["#{Typus.root}/generators/typus_update_schema_to_01/templates/config/*"].each do |f|
+        base = File.basename(f)
+        m.template "config/#{base}", "#{config_folder}/#{base}"
+      end
+
+      m.migration_template 'migration.rb', 'db/migrate', { :migration_file_name => 'update_typus_schema_to_01' }
+
+    end
+
+  end
+
+end

data/lib/typus.rb

@@ -0,0 +1,122 @@
+module Typus
+
+  class << self
+
+    def version
+      @@version ||= File.read("#{root}/VERSION").strip
+    end
+
+    def root
+      File.dirname(__FILE__) + '/../'
+    end
+
+    def locales
+      Typus::Configuration.options[:locales]
+    end
+
+    def default_locale
+      locales.map(&:last).first
+    end
+
+    def applications
+      Typus::Configuration.config.collect { |i| i.last['application'] }.compact.uniq.sort
+    end
+
+    # List of the modules of an application.
+    def application(name)
+      Typus::Configuration.config.collect { |i| i.first if i.last['application'] == name }.compact.uniq.sort
+    end
+
+    def models
+      Typus::Configuration.config.map { |i| i.first }.sort
+    end
+
+    def models_on_header
+      models.collect { |m| m if m.constantize.typus_options_for(:on_header) }.compact
+    end
+
+    # List of resources, which are tableless models.
+    def resources(models = get_model_names)
+
+      all_resources = Typus::Configuration.roles.keys.map do |key|
+                        Typus::Configuration.roles[key].keys
+                      end.flatten.sort.uniq
+
+      all_resources.delete_if { |x| models.include?(x) || x == 'TypusUser' } rescue []
+
+    end
+
+    def get_model_names
+      Dir[ "#{Rails.root}/app/models/**/*.rb", 
+           "#{Rails.root}/vendor/plugins/**/app/models/**/*.rb" ].collect { |m| File.basename(m).sub(/\.rb$/,'').camelize }
+    end
+
+    def user_class
+      Typus::Configuration.options[:user_class_name].constantize
+    end
+
+    def user_fk
+      Typus::Configuration.options[:user_fk]
+    end
+
+    def testing?
+      Rails.env.test? && Dir.pwd == "#{Rails.root}/vendor/plugins/typus"
+    end
+
+    def plugin?
+      File.exist?("#{Rails.root}/vendor/plugins/typus")
+    end
+
+    def boot!
+
+      # return unless File.exists?("#{Rails.root}/config/initializers/typus.rb") || testing?
+      return if %w( script/generate script/destroy ).include?($0)
+
+      if testing?
+        Typus::Configuration.options[:config_folder] = 'vendor/plugins/typus/test/config/working'
+      end
+
+      # Ruby Extensions
+      require 'typus/hash'
+      require 'typus/object'
+      require 'typus/string'
+
+      # Load configuration and roles.
+      Typus::Configuration.config!
+      Typus::Configuration.roles!
+
+      # Load translation files from the plugin or the gem.
+      if plugin?
+        I18n.load_path += Dir[File.join(root, 'config', 'locales', '**', '*.{rb,yml}')]
+      else
+        Gem.path.each { |g| I18n.load_path += Dir[File.join("#{g}/gems/*typus-#{version}/config/locales/**/*.{rb,yml}")] }
+      end
+
+      # Require the test/models on when testing.
+      require File.dirname(__FILE__) + '/../test/models' if testing?
+
+      # Rails Extensions.
+      require 'typus/active_record'
+      require 'typus/extensions/routes'
+
+      # Mixins.
+      require 'typus/authentication'
+      require 'typus/format'
+      require 'typus/generator'
+      require 'typus/locale'
+      require 'typus/reloader'
+      require 'typus/quick_edit'
+      require 'typus/user'
+
+      # Vendor.
+      require 'vendor/active_record'
+      require 'vendor/paginator'
+
+      # Run controllers generator ...
+      generator unless testing? || Rails.env.production?
+
+    end
+
+  end
+
+end

data/lib/typus/active_record.rb

@@ -0,0 +1,307 @@
+module Typus
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    # Return model fields as a OrderedHash
+    def model_fields
+      hash = ActiveSupport::OrderedHash.new
+      columns.map { |u| hash[u.name.to_sym] = u.type.to_sym }
+      return hash
+    end
+
+    def model_relationships
+      hash = ActiveSupport::OrderedHash.new
+      reflect_on_all_associations.map { |i| hash[i.name] = i.macro }
+      return hash
+    end
+
+    ##
+    # This method is used to change a Rails behavior.
+    #
+    #   typus $ script/console
+    #   Loading development environment (Rails 2.3.2)
+    #   >> TypusUser.human_name
+    #   => "Typususer"
+    #   >> TypusUser.typus_human_name
+    #   => "Typus user"
+    #
+    def typus_human_name
+      human_name(:default => self.name.underscore.humanize)
+    end
+
+    def typus_description
+      Typus::Configuration.config[self.name]['description']
+    end
+
+    # Form and list fields
+    def typus_fields_for(filter)
+
+      fields_with_type = ActiveSupport::OrderedHash.new
+
+      begin
+        fields = Typus::Configuration.config[name]['fields'][filter.to_s]
+        fields = fields.split(', ').collect { |f| f.to_sym }
+      rescue
+        return [] if filter == 'list'
+        filter = 'list'
+        retry
+      end
+
+      begin
+
+        fields.each do |field|
+
+          attribute_type = model_fields[field]
+
+          # Custom field_type depending on the attribute name.
+          case field.to_s
+            when 'parent_id' then       attribute_type = :tree
+            when /file_name/ then       attribute_type = :file
+            when /password/ then        attribute_type = :password
+            when 'position' then        attribute_type = :position
+          end
+
+          if reflect_on_association(field)
+            attribute_type = reflect_on_association(field).macro
+          end
+
+          if typus_field_options_for(:selectors).include?(field)
+            attribute_type = :selector
+          end
+
+          if typus_tiny_mce_fields.include?(field.to_s)
+            attribute_type = :tiny_mce
+          end
+
+          # And finally insert the field and the attribute_type 
+          # into the fields_with_type ordered hash.
+          fields_with_type[field.to_s] = attribute_type
+
+        end
+
+      rescue
+        fields = Typus::Configuration.config[name]['fields']['list'].split(', ')
+        retry
+      end
+
+      return fields_with_type
+
+    end
+
+    # Return tiny_mce options of the model merged into the default options
+    def typus_tiny_mce_options
+      typus_options_for(:tiny_mce).merge(Typus::Configuration.config[name]['fields']['options']['tiny_mce']['options'].symbolize_keys.delete_if { |key,value| value == nil})
+    rescue
+      typus_options_for(:tiny_mce)
+    end
+
+    # Tiny_mce fields of the model
+    def typus_tiny_mce_fields
+      Typus::Configuration.config[name]['fields']['options']['tiny_mce']['fields'].split(', ')
+    rescue
+      []
+    end
+
+    # Typus sidebar filters.
+    def typus_filters
+
+      fields_with_type = ActiveSupport::OrderedHash.new
+
+      data = Typus::Configuration.config[name]['filters']
+      return [] unless data
+      fields = data.split(', ').collect { |i| i.to_sym }
+
+      fields.each do |field|
+        attribute_type = model_fields[field.to_sym]
+        if reflect_on_association(field.to_sym)
+          attribute_type = reflect_on_association(field.to_sym).macro
+        end
+        fields_with_type[field.to_s] = attribute_type
+      end
+
+      return fields_with_type
+
+    end
+
+    # Extended actions for this model on Typus.
+    def typus_actions_for(filter)
+      Typus::Configuration.config[name]['actions'][filter.to_s].split(', ')
+    rescue
+      []
+    end
+
+    # Used for +search+, +relationships+
+    def typus_defaults_for(filter)
+      data = Typus::Configuration.config[name][filter.to_s]
+      return (!data.nil?) ? data.split(', ') : []
+    end
+
+    def typus_field_options_for(filter)
+      Typus::Configuration.config[name]['fields']['options'][filter.to_s].split(', ').collect { |i| i.to_sym }
+    rescue
+      []
+    end
+
+    # We should be able to overwrite options by model.
+    def typus_options_for(filter)
+
+      data = Typus::Configuration.config[name]
+      unless data['options'].nil?
+        value = data['options'][filter.to_s] unless data['options'][filter.to_s].nil?
+      end
+
+      return (!value.nil?) ? value : Typus::Configuration.options[filter.to_sym]
+
+    end
+
+    def typus_export_formats
+      data = Typus::Configuration.config[name]
+      !data['export'].nil? ? data['export'].split(', ') : []
+    end
+
+    # Used for `order_by`.
+    def typus_order_by
+
+      fields = typus_defaults_for(:order_by)
+      return "#{table_name}.id ASC" if fields.empty?
+
+      order = fields.map do |field|
+                (field.include?('-')) ? "#{table_name}.#{field.delete('-')} DESC" : "#{table_name}.#{field} ASC"
+              end.join(', ')
+
+      return order
+
+    end
+
+    # We are able to define our own booleans.
+    def typus_boolean(attribute = :default)
+
+      boolean = Typus::Configuration.config[name]['fields']['options']['booleans'][attribute.to_s] rescue nil
+      boolean = 'true, false' if boolean.nil?
+
+      hash = ActiveSupport::OrderedHash.new
+
+      if boolean.kind_of?(Array)
+        hash[:true] = boolean.first.humanize
+        hash[:false] = boolean.last.humanize
+      else
+        hash[:true] = boolean.split(', ').first.humanize
+        hash[:false] = boolean.split(', ').last.humanize
+      end
+
+      return hash
+
+    end
+
+    # We are able to define how to display dates on Typus
+    def typus_date_format(attribute = :default)
+      date_format = Typus::Configuration.config[name]['fields']['options']['date_formats'][attribute.to_s].to_sym rescue nil
+      date_format = :db if date_format.nil?
+      return date_format
+    end
+
+    # We are able to define which template to use to render the attribute 
+    # within the form
+    def typus_template(attribute)
+      Typus::Configuration.config[name]['fields']['options']['templates'][attribute.to_s]
+    rescue
+      nil
+    end
+
+    def build_conditions(params)
+
+      conditions, joins = merge_conditions, []
+
+      query_params = params.dup
+      %w( action controller ).each { |param| query_params.delete(param) }
+
+      # If a search is performed.
+      if query_params[:search]
+        search = typus_defaults_for(:search).map do |s|
+                   ["LOWER(#{s}) LIKE '%#{ActiveRecord::Base.connection.quote_string(query_params[:search].downcase)}%'"]
+                 end
+        conditions = merge_conditions(conditions, search.join(' OR '))
+      end
+
+      query_params.each do |key, value|
+
+        filter_type = model_fields[key.to_sym] || model_relationships[key.to_sym]
+
+        ##
+        # Sidebar filters:
+        #
+        # - Booleans: true, false
+        # - Datetime: today, past_7_days, this_month, this_year
+        # - Integer & String: *_id and "selectors" (p.ej. category_id)
+        #
+        case filter_type
+        when :boolean
+          condition = { key => (value == 'true') ? true : false }
+          conditions = merge_conditions(conditions, condition)
+        when :datetime
+          interval = case value
+                     when 'today' then         Time.new.midnight..Time.new.midnight.tomorrow
+                     when 'past_7_days' then   6.days.ago.midnight..Time.new.midnight.tomorrow
+                     when 'this_month' then    Time.new.midnight.last_month..Time.new.midnight.tomorrow
+                     when 'this_year' then     Time.new.midnight.last_year..Time.new.midnight.tomorrow
+                     end
+          condition = ["#{key} BETWEEN ? AND ?", interval.first.to_s(:db), interval.last.to_s(:db)]
+          conditions = merge_conditions(conditions, condition)
+        when :integer, :string
+          condition = { key => value }
+          conditions = merge_conditions(conditions, condition)
+        when :has_and_belongs_to_many
+          condition = { key => { :id => value } }
+          conditions = merge_conditions(conditions, condition)
+          joins << key.to_sym
+        end
+
+      end
+
+      return conditions, joins
+
+    end
+
+  end
+
+  module InstanceMethods
+
+    def previous_and_next(condition = {}, klass = self.class)
+
+      previous_conditions = "#{klass.primary_key} < #{id}"
+      next_conditions = "#{klass.primary_key} > #{id}"
+
+      if !condition.empty?
+        conditions, joins = klass.build_conditions(condition)
+        previous_conditions += " AND #{conditions}"
+        next_conditions += " AND #{conditions}"
+      end
+
+      previous_ = klass.find :first, 
+                             :select => [klass.primary_key], 
+                             :order => "#{klass.primary_key} DESC", 
+                             :conditions => previous_conditions
+
+      next_ = klass.find :first, 
+                         :select => [klass.primary_key], 
+                         :order => "#{klass.primary_key} ASC", 
+                         :conditions => next_conditions
+
+      return previous_, next_
+
+    end
+
+    def typus_name
+      respond_to?(:name) ? name : "#{self.class}##{id}"
+    end
+
+  end
+
+end
+
+ActiveRecord::Base.send :include, Typus
+ActiveRecord::Base.send :include, Typus::InstanceMethods