typus 0.9.39 → 1.0.0.pre

data/lib/typus/orm/active_record.rb

@@ -0,0 +1,378 @@
+module Typus
+
+  module Orm
+
+    module ClassMethods
+
+      # 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
+      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
+      end
+
+      # Model description for admin panel.
+      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.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]
+
+            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
+
+            # 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
+            end
+
+            if respond_to?(:attachment_definitions) && attachment_definitions.try(:has_key?, field)
+              attribute_type = :file
+            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']['default'].extract_settings
+          retry
+        end
+
+        return fields_with_type
+
+      end
+
+      # Typus sidebar filters.
+      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
+          end
+          fields_with_type[field.to_s] = attribute_type
+        end
+
+        return fields_with_type
+
+      end
+
+      def typus_actions
+        return [] if Typus::Configuration.config[name]['actions'].nil?
+        Typus::Configuration.config[name]['actions'].keys.map do |key|
+          Typus::Configuration.config[name]['actions'][key].extract_settings
+        end.flatten
+      rescue
+        []
+      end
+
+      # Extended actions for this model on Typus.
+      def typus_actions_on(filter)
+        Typus::Configuration.config[name]['actions'][filter.to_s].extract_settings
+      rescue
+        []
+      end
+
+      # Used for +search+, +relationships+
+      def typus_defaults_for(filter)
+        data = Typus::Configuration.config[name][filter.to_s]
+        return (!data.nil?) ? data.extract_settings : []
+      end
+
+      def typus_search_fields
+        data = Typus::Configuration.config[name]["search"]
+        return [] if data.nil?
+
+        search = {}
+
+        data.extract_settings.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
+
+        return search
+
+      end
+
+      #--
+      # TODO: Test method.
+      #++
+      def typus_application
+        Typus::Configuration.config[name]["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
+        []
+      end
+
+      #--
+      # Options are defined for all resources on the initializer:
+      #
+      #     Typus::Resources.setup do |config|
+      #       config.per_page = 15
+      #     end
+      #
+      # But sometimes we need to define theme by model:
+      #
+      #     Post:
+      #       ...
+      #       options:
+      #         per_page: 15
+      #++
+      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::Resources.send(filter)
+
+      end
+
+      def typus_export_formats
+        data = Typus::Configuration.config[name]
+        !data['export'].nil? ? data['export'].extract_settings : []
+      end
+
+      # Used for `order_by`.
+      def typus_order_by
+
+        fields = typus_defaults_for(:order_by)
+
+        if fields.empty?
+          "#{table_name}.#{primary_key} ASC"
+        else
+          fields.map do |field|
+            field.include?('-') ? "#{table_name}.#{field.delete('-')} DESC" : "#{table_name}.#{field} ASC"
+          end.join(', ')
+        end
+
+      end
+
+      #--
+      # Define our own boolean mappings.
+      #
+      #     Post:
+      #       fields:
+      #         default: title, status
+      #         options:
+      #           booleans:
+      #             status: "Published", "Not published"
+      #
+      #++
+      def typus_boolean(attribute = :default)
+
+        begin
+          boolean = Typus::Configuration.config[name]['fields']['options']['booleans'][attribute.to_s]
+        rescue
+          boolean = 'true, false'
+        end
+
+        return nil if boolean.nil?
+
+        hash = ActiveSupport::OrderedHash.new
+
+        mapping = boolean.kind_of?(Array) ? boolean : boolean.extract_settings
+        hash[:true], hash[:false] = mapping.first, mapping.last
+        hash.map { |k, v| hash[k] = v.humanize }
+
+        return hash
+
+      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
+      end
+
+      #--
+      # This is user to use custome templates for attribute:
+      #
+      #     Post:
+      #       fields:
+      #         form: title, body, status
+      #         options:
+      #           templates:
+      #             body: rich_text
+      #
+      # 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)
+
+        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
+            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.new.midnight..Time.new.midnight.tomorrow
+                       when 'last_few_days' then 3.days.ago.midnight..Time.new.midnight.tomorrow
+                       when 'last_7_days'   then 6.days.ago.midnight..Time.new.midnight.tomorrow
+                       when 'last_30_days'  then Time.new.midnight.prev_month..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 :date
+            if value.is_a?(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.midnight..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
+
+        end
+
+        return conditions, joins
+
+      end
+
+      def typus_user_id?
+        columns.map { |u| u.name }.include?(Typus.user_fk)
+      end
+
+    end
+
+    module InstanceMethods
+
+      def owned_by?(user)
+        send(Typus.user_fk) == user.id
+      end
+
+    end
+
+  end
+
+end
+
+if defined?(ActiveRecord)
+  ActiveRecord::Base.extend Typus::Orm::ClassMethods
+  ActiveRecord::Base.send :include, Typus::Orm::InstanceMethods
+end

data/lib/typus/resources.rb

@@ -0,0 +1,57 @@
+module Typus
+
+  module Resources
+
+    # Setup Typus::Resources. This should be run from an initializer.
+    #
+    #     Typus::Resources.setup do |config|
+    #       config.default_action_on_item = "index"
+    #     end
+    #
+    def self.setup
+      yield self
+    end
+
+    # Defines the default_action_on_item.
+    mattr_accessor :default_action_on_item
+    @@default_action_on_item = "edit"
+
+    # Defines the end_year.
+    mattr_accessor :end_year
+    @@end_year = nil
+
+    # Defines the form_rows.
+    mattr_accessor :form_rows
+    @@form_rows = 15
+
+    # Defines the action_after_save.
+    mattr_accessor :action_after_save
+    @@action_after_save = "edit"
+
+    # Defines the minute step.
+    mattr_accessor :minute_step
+    @@minute_step = 5
+
+    # Defines nil.
+    mattr_accessor :human_nil
+    @@human_nil = "nil"
+
+    # Defines only_user_items.
+    mattr_accessor :only_user_items
+    @@only_user_items = false
+
+    # Defines per_page
+    mattr_accessor :per_page
+    @@per_page = 15
+
+    # Defines start year
+    mattr_accessor :start_year
+    @@start_year = nil
+
+    def self.method_missing(*args)
+      nil
+    end
+
+  end
+
+end

data/lib/typus/user.rb

@@ -26,7 +26,6 @@ module Typus
         validates_presence_of :role
 
         before_save :initialize_salt, :encrypt_password, :initialize_token
-        before_save :set_preferences
 
         serialize :preferences
 
@@ -38,14 +37,6 @@ module Typus
 
     module ClassMethodsMixin
 
-      def role
-        Typus::Configuration.roles.keys.sort
-      end
-
-      def language
-        Typus.locales
-      end
-
       def authenticate(email, password)
         user = find_by_email_and_status(email, true)
         user && user.authenticated?(password) ? user : nil
@@ -53,10 +44,15 @@ module Typus
 
       def generate(*args)
         options = args.extract_options!
-        new :email => options[:email], 
-            :password => options[:password], 
-            :password_confirmation => options[:password], 
-            :role => options[:role]
+
+        options[:password] ||= ActiveSupport::SecureRandom.hex(4)
+        options[:role] ||= Typus.master_role
+
+        new :email => options[:email],
+            :password => options[:password],
+            :password_confirmation => options[:password],
+            :role => options[:role],
+            :preferences => { :locale => I18n.default_locale.to_s }
       end
 
     end
@@ -64,7 +60,15 @@ module Typus
     module InstanceMethods
 
       def name
-        (!first_name.empty? && !last_name.empty?) ? "#{first_name} #{last_name}" : email
+        if !first_name.blank? and !last_name.blank?
+          "#{first_name} #{last_name}"
+        elsif !first_name.blank? and last_name.blank?
+          first_name
+        elsif first_name.blank? and !last_name.blank?
+          last_name
+        else
+          email
+        end
       end
 
      def authenticated?(password)
@@ -75,51 +79,64 @@ module Typus
         Typus::Configuration.roles[role].compact
       end
 
-      def can_perform?(resource, action, options = {})
+      #--
+      # TODO: Rename action to mapping and refactor the _action case
+      #       statement.
+      #++
+      def can?(action, resource, options = {})
 
-        # We are getting a Class, so we need to convert it to string.
+        # Sometimes we are getting a Class, so we need to convert it
+        # to string.
         resource = resource.to_s
 
         return false if !resources.include?(resource)
-        return true if resources[resource].include?('all')
+        return true if resources[resource].include?("all")
 
         _action = if options[:special]
                     action
                   else
                     case action
-                    when 'new', 'create'       then 'create'
-                    when 'index', 'show'       then 'read'
-                    when 'edit', 'update'      then 'update'
-                    when 'position', 'toggle'  then 'update'
-                    when 'relate', 'unrelate'  then 'update'
-                    when 'destroy'             then 'delete'
+                    when "new", "create" then "create"
+                    when "index", "show" then "read"
+                    when "edit", "update",
+                         "position", "toggle",
+                         "relate", "unrelate", "detach" then "update"
+                    when "destroy" then "delete"
                     else action
                     end
                   end
 
-        resources[resource].split(', ').include?(_action)
+        resources[resource].extract_settings.include?(_action)
+
+      end
 
+      def cannot?(*args)
+        !can?(*args)
       end
 
       def is_root?
-        role == Typus::Configuration.options[:root]
+        role == Typus.master_role
       end
 
-    protected
+      def is_not_root?
+        !is_root?
+      end
 
       def language
-        preferences[:locale] rescue Typus::Configuration.options[:default_locale]
+        preferences[:locale]
+      rescue
+        I18n.default_locale.to_s
       end
 
       def language=(locale)
-        self.preferences = { :locale => locale }
+        options = { :locale => locale }
+        self.preferences.merge!(options)
+      rescue
+        self.preferences = {}
+        retry
       end
 
-      def set_preferences
-        if self.preferences.nil? || self.preferences[:locale].nil? || self.preferences[:locale].blank?
-          self.preferences = { :locale => Typus::Configuration.options[:default_locale] }
-        end
-      end
+      protected
 
       def generate_hash(string)
         Digest::SHA1.hexdigest(string)
@@ -131,11 +148,11 @@ module Typus
       end
 
       def encrypt(string)
-        generate_hash("--#{salt}--#{string}")
+        generate_hash("--#{salt}--#{string}--")
       end
 
       def initialize_salt
-        self.salt = generate_hash("--#{Time.now.utc.to_s}--#{email}--") if new_record?
+        self.salt = generate_hash("--#{Time.now.utc.to_s(:number)}--#{email}--") if new_record?
       end
 
       def initialize_token
@@ -143,7 +160,7 @@ module Typus
       end
 
       def generate_token
-        self.token = encrypt("--#{Time.now.utc.to_s}--#{password}--").first(12)
+        self.token = encrypt("--#{Time.now.utc.to_s(:number)}--#{password}--").first(12)
       end
 
       def password_required?
@@ -156,4 +173,4 @@ module Typus
 
 end
 
-ActiveRecord::Base.send :include, Typus::EnableAsTypusUser
+ActiveRecord::Base.send :include, Typus::EnableAsTypusUser

data/lib/typus/version.rb

@@ -0,0 +1,3 @@
+module Typus
+  VERSION = "1.0.0.pre"
+end