typus 3.0.2 → 3.0.4

data/lib/typus/configuration.rb

@@ -9,13 +9,14 @@ module Typus
       files = (application + plugins).reject { |f| f.include?("_roles.yml") }
 
       @@config = {}
+
       files.each do |file|
         if data = YAML::load_file(file)
           @@config.merge!(data)
         end
       end
 
-      return @@config
+      @@config
     end
 
     mattr_accessor :config
@@ -26,26 +27,27 @@ module Typus
       plugins = Dir[File.join("vendor", "plugins", "*", "config", "typus", "*_roles.yml").to_s]
       files = (application + plugins).sort
 
-      @@roles = { Typus.master_role => {} }
+      @@roles = {}
 
       files.each do |file|
-        data = YAML::load_file(file)
-        next unless data
-        data.each do |key, value|
-          next unless value
-          begin
-            @@roles[key].merge!(value)
-          rescue
-            @@roles[key] = value
+        if data = YAML::load_file(file)
+          data.compact.each do |key, value|
+            @@roles[key] ? @@roles[key].merge!(value) : (@@roles[key] = value)
           end
         end
       end
 
-      return @@roles.compact
+      @@roles
     end
 
     mattr_accessor :roles
 
+    def self.models_constantized!
+      @@models_constantized = config.map { |i| i.first }.inject({}) { |result, model| result[model] = model.constantize; result }
+    end
+
+    mattr_accessor :models_constantized
+
   end
 
 end

data/lib/typus/filters.rb

@@ -0,0 +1,12 @@
+module Typus
+
+  module Filters
+
+    def add_predefined_filter(filter, action, scope)
+      @predefined_filters ||= [["All", "index", "unscoped"]]
+      @predefined_filters << [filter, action, scope]
+    end
+
+  end
+
+end

data/lib/typus/format.rb

@@ -1,6 +1,8 @@
 if RUBY_VERSION >= '1.9'
   require 'csv'
   FasterCSV = CSV
+else
+  require 'fastercsv'
 end
 
 module Typus
@@ -10,15 +12,14 @@ module Typus
     protected
 
     def generate_html
-      items_count = @resource.count(:joins => @joins, :conditions => @conditions)
       items_per_page = @resource.typus_options_for(:per_page)
-      @items = data.paginate(:per_page => items_per_page, :page => params[:page])
+      @items = @items.paginate(:per_page => items_per_page, :page => params[:page])
     end
 
     #--
-    # TODO: Find in batches only works properly if it's used on
-    #       models, not controllers, so in this action does nothing.
-    #       We should find a way to be able to process data.
+    # TODO: Find in batches only works properly if it's used on models, not
+    #       controllers, so in this action does nothing. We should find a way
+    #       to be able to process large amounts of data.
     #++
     def generate_csv
       fields = @resource.typus_fields_for(:csv)
@@ -27,7 +28,7 @@ module Typus
 
       options = { :conditions => @conditions, :batch_size => 1000 }
 
-      FasterCSV.open(filename, 'w', :col_sep => ';') do |csv|
+      ::FasterCSV.open(filename, 'w', :col_sep => ';') do |csv|
         csv << fields.keys
         @resource.find_in_batches(options) do |records|
           records.each do |record|
@@ -58,15 +59,10 @@ module Typus
     end
 
     def export(format)
-      fields = @resource.typus_fields_for(format).collect { |i| i.first }
+      fields = @resource.typus_fields_for(format).map { |i| i.first }
       methods = fields - @resource.column_names
       except = @resource.column_names - fields
-      render format => data.send("to_#{format}", :methods => methods, :except => except)
-    end
-
-    def data
-      eager_loading = @resource.reflect_on_all_associations(:belongs_to).map { |i| i.name }
-      @resource.joins(@joins).where(@conditions).order(@order).includes(eager_loading)
+      render format => @items.send("to_#{format}", :methods => methods, :except => except)
     end
 
   end

data/lib/typus/i18n.rb

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

data/lib/typus/orm/active_record.rb

@@ -6,147 +6,130 @@ module Typus
 
       # Model fields as an <tt>ActiveSupport::OrderedHash</tt>.
       def model_fields
-        hash = ActiveSupport::OrderedHash.new
-        columns.map { |u| hash[u.name.to_sym] = u.type.to_sym }
-        return hash
+        ActiveSupport::OrderedHash.new.tap do |hash|
+          columns.map { |u| hash[u.name.to_sym] = u.type.to_sym }
+        end
       end
 
       # Model relationships as an <tt>ActiveSupport::OrderedHash</tt>.
       def model_relationships
-        hash = ActiveSupport::OrderedHash.new
-        reflect_on_all_associations.map { |i| hash[i.name] = i.macro }
-        return hash
+        ActiveSupport::OrderedHash.new.tap do |hash|
+          reflect_on_all_associations.map { |i| hash[i.name] = i.macro }
+        end
       end
 
       # Model description for admin panel.
       def typus_description
-        Typus::Configuration.config[self.name]['description']
+        read_model_config['description']
       end
 
       # Form and list fields
       def typus_fields_for(filter)
+        ActiveSupport::OrderedHash.new.tap do |fields_with_type|
+          data = read_model_config['fields']
+          fields = data[filter.to_s] || data['default'] || ""
 
-        fields_with_type = ActiveSupport::OrderedHash.new
-
-        begin
-          fields = Typus::Configuration.config[name]['fields'][filter.to_s]
-          fields = fields.extract_settings.collect { |f| f.to_sym }
-        rescue
-          return [] if filter == 'default'
-          filter = 'default'
-          retry
-        end
-
-        begin
-
-          fields.each do |field|
-
-            attribute_type = model_fields[field]
+          virtual_fields = instance_methods - model_fields.keys.map { |i| i.to_s }
 
+          fields.extract_settings.map { |f| f.to_sym }.each do |field|
             if reflect_on_association(field)
-              attribute_type = reflect_on_association(field).macro
+              fields_with_type[field.to_s] = reflect_on_association(field).macro
+              next
             end
 
             if typus_field_options_for(:selectors).include?(field)
-              attribute_type = :selector
+              fields_with_type[field.to_s] = :selector
+              next
             end
 
-            # Custom field_type depending on the attribute name.
-            case field.to_s
-              when 'parent', 'parent_id'  then attribute_type = :tree
-              when /password/             then attribute_type = :password
-              when 'position'             then attribute_type = :position
-              when /\./                   then attribute_type = :transversal
+            dragonfly = respond_to?(:dragonfly_apps_for_attributes) && dragonfly_apps_for_attributes.try(:has_key?, field)
+            paperclip = respond_to?(:attachment_definitions) && attachment_definitions.try(:has_key?, field)
+
+            if dragonfly || paperclip
+              fields_with_type[field.to_s] = :file
+              next
             end
 
-            if respond_to?(:attachment_definitions) && attachment_definitions.try(:has_key?, field)
-              attribute_type = :file
+            if virtual_fields.include?(field.to_s)
+              fields_with_type[field.to_s] = :virtual
             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
+            fields_with_type[field.to_s] = case field.to_s
+                                           when 'parent', 'parent_id' then :tree
+                                           when /password/            then :password
+                                           when 'position'            then :position
+                                           when /\./                  then :transversal
+                                           else
+                                             if fields_with_type[field.to_s]
+                                               fields_with_type[field.to_s]
+                                             else
+                                               model_fields[field]
+                                             end
+                                           end
 
           end
-
-        rescue
-          fields = Typus::Configuration.config[name]['fields']['default'].extract_settings
-          retry
         end
-
-        return fields_with_type
-
       end
 
       def typus_filters
-        fields_with_type = ActiveSupport::OrderedHash.new
-
-        data = Typus::Configuration.config[name]['filters']
-        return [] unless data
-        fields = data.extract_settings.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
+        ActiveSupport::OrderedHash.new.tap do |fields_with_type|
+          if data = read_model_config['filters']
+            data.extract_settings.map { |i| i.to_sym }.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
           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_on(filter)
-        Typus::Configuration.config[name]['actions'][filter.to_s].extract_settings
-      rescue
-        []
+        actions = read_model_config['actions']
+        actions && actions[filter.to_s] ? actions[filter.to_s].extract_settings : []
       end
 
       # Used for +search+, +relationships+
       def typus_defaults_for(filter)
-        data = Typus::Configuration.config[name][filter.to_s]
-        return data.try(:extract_settings) || []
+        read_model_config[filter.to_s].try(:extract_settings) || []
       end
 
       def typus_search_fields
-        data = typus_defaults_for(:search)
-
-        search = {}
-
-        data.each do |field|
-          if field.starts_with?("=")
-            field.slice!(0)
-            search[field] = "="
-          elsif field.starts_with?("^")
-            field.slice!(0)
-            search[field] = "^"
-          else
-            search[field] = "@"
+        Hash.new.tap do |search|
+          typus_defaults_for(:search).each do |field|
+            if field.starts_with?("=")
+              field.slice!(0)
+              search[field] = "="
+            elsif field.starts_with?("^")
+              field.slice!(0)
+              search[field] = "^"
+            else
+              search[field] = "@"
+            end
           end
         end
-
-        return search
       end
 
       def typus_application
-        Typus::Configuration.config[name]["application"] || "Unknown"
+        read_model_config['application'] || 'Unknown'
       end
 
       def typus_field_options_for(filter)
-        Typus::Configuration.config[name]['fields']['options'][filter.to_s].extract_settings.collect { |i| i.to_sym }
-      rescue
-        []
+        options = read_model_config['fields']['options']
+        options && options[filter.to_s] ? options[filter.to_s].extract_settings.map { |i| i.to_sym } : []
       end
 
       #--
-      # Options are defined for all resources on the initializer:
+      # With Typus::Resources we some application defaults.
       #
       #     Typus::Resources.setup do |config|
       #       config.per_page = 15
       #     end
       #
-      # But sometimes we need to define theme by model:
+      # If for any reason we need a better default for an specific resource we
+      # we override it on `application.yaml`.
       #
       #     Post:
       #       ...
@@ -154,17 +137,17 @@ module Typus
       #         per_page: 15
       #++
       def typus_options_for(filter)
-        data = Typus::Configuration.config[name]
+        options = read_model_config['options']
 
-        unless data['options'].nil?
-          value = data['options'][filter.to_s] unless data['options'][filter.to_s].nil?
+        unless options.nil? || options[filter.to_s].nil?
+          options[filter.to_s]
+        else
+          Typus::Resources.send(filter)
         end
-
-        value || Typus::Resources.send(filter)
       end
 
       def typus_export_formats
-        Typus::Configuration.config[name]['export'].try(:extract_settings) || []
+        read_model_config['export'].try(:extract_settings) || []
       end
 
       def typus_order_by
@@ -185,20 +168,27 @@ module Typus
       #
       #++
       def typus_boolean(attribute = :default)
-        boolean = Typus::Configuration.config[name]['fields']['options']['booleans'][attribute.to_s]
-        boolean = boolean.extract_settings
+        options = read_model_config['fields']['options']
+
+        boolean = if options && options['booleans'] && boolean = options['booleans'][attribute.to_s]
+                    boolean.is_a?(String) ? boolean.extract_settings : boolean
+                  else
+                    ["True", "False"]
+                  end
+
         { boolean.first => "true", boolean.last => "false" }
-      rescue
-        { "True" => "true", "False" => "false" }
       end
 
       #--
       # Custom date formats.
       #++
       def typus_date_format(attribute = :default)
-        Typus::Configuration.config[name]['fields']['options']['date_formats'][attribute.to_s].to_sym
-      rescue
-        :db
+        options = read_model_config['fields']['options']
+        if options && options['date_formats'] && options['date_formats'][attribute.to_s]
+          options['date_formats'][attribute.to_s].to_sym
+        else
+          :default
+        end
       end
 
       #--
@@ -214,113 +204,24 @@ module Typus
       # Templates are stored on <tt>app/views/admin/templates</tt>.
       #++
       def typus_template(attribute)
-        Typus::Configuration.config[name]['fields']['options']['templates'][attribute.to_s]
-      rescue
-        nil
-      end
-
-      #--
-      # Sidebar filters:
-      #
-      # - Booleans: true, false
-      # - Datetime: today, last_few_days, last_7_days, last_30_days
-      # - Integer & String: *_id and "selectors" (p.ej. category_id)
-      #++
-      def build_conditions(params)
-
-        adapter = ActiveRecord::Base.configurations[Rails.env]['adapter']
-
-        conditions, joins = merge_conditions, []
-
-        query_params = params.dup
-        %w(action controller).each { |param| query_params.delete(param) }
-
-        # Remove from params those with empty string.
-        query_params.delete_if { |k, v| v.empty? }
-
-        # If a search is performed.
-        if query_params[:search]
-          query = ActiveRecord::Base.connection.quote_string(query_params[:search].downcase)
-          search = []
-          typus_search_fields.each do |key, value|
-            _query = case value
-                     when "=" then query
-                     when "^" then "#{query}%"
-                     when "@" then "%#{query}%"
-                     end
-            key = "LOWER(TEXT(#{key}))" if adapter == 'postgresql'
-            search << "#{key} LIKE '#{_query}'"
-          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]
-
-          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.zone.now.beginning_of_day..Time.zone.now.beginning_of_day.tomorrow
-                       when 'last_few_days' then 3.days.ago.beginning_of_day..Time.zone.now.beginning_of_day.tomorrow
-                       when 'last_7_days'   then 6.days.ago.beginning_of_day..Time.zone.now.beginning_of_day.tomorrow
-                       when 'last_30_days'  then Time.zone.now.beginning_of_day.prev_month..Time.zone.now.beginning_of_day.tomorrow
-                       end
-            condition = ["#{key} BETWEEN ? AND ?", interval.first.to_s(:db), interval.last.to_s(:db)]
-            conditions = merge_conditions(conditions, condition)
-          when :date
-            if value.kind_of?(Hash)
-              date_format = Date::DATE_FORMATS[typus_date_format(key)]
-
-              begin
-                unless value["from"].blank?
-                  date_from = Date.strptime(value["from"], date_format)
-                  conditions = merge_conditions(conditions, ["#{key} >= ?", date_from])
-                end
-
-                unless value["to"].blank?
-                  date_to = Date.strptime(value["to"], date_format)
-                  conditions = merge_conditions(conditions, ["#{key} <= ?", date_to])
-                end
-              rescue
-              end
-            else
-              # TODO: Improve and test filters.
-              interval = case value
-                         when 'today'         then nil
-                         when 'last_few_days' then 3.days.ago.to_date..Date.tomorrow
-                         when 'last_7_days'   then 6.days.ago.beginning_of_day..Date.tomorrow
-                         when 'last_30_days'  then (Date.today << 1)..Date.tomorrow
-                         end
-              if interval
-                condition = ["#{key} BETWEEN ? AND ?", interval.first, interval.last]
-              elsif value == 'today'
-                condition = ["#{key} = ?", Date.today]
-              end
-              conditions = merge_conditions(conditions, condition)
-            end
-          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
-
+        options = read_model_config['fields']['options']
+        if options && options['templates'] && options['templates'][attribute.to_s]
+          options['templates'][attribute.to_s]
         end
+      end
 
-        return conditions, joins
-
+      def adapter
+        @adapter ||= ActiveRecord::Base.configurations[Rails.env]['adapter']
       end
 
       def typus_user_id?
         columns.map { |u| u.name }.include?(Typus.user_fk)
       end
 
+      def read_model_config
+        Typus::Configuration.config[name] or raise "No typus configuration specified for #{name}"
+      end
+
     end
 
     module InstanceMethods
@@ -336,6 +237,8 @@ module Typus
 end
 
 if defined?(ActiveRecord)
+  require 'typus/orm/active_record/search'
   ActiveRecord::Base.extend Typus::Orm::ClassMethods
+  ActiveRecord::Base.extend Typus::Orm::ClassMethods::Search
   ActiveRecord::Base.send :include, Typus::Orm::InstanceMethods
 end