padrino-admin 0.6.3 → 0.6.7

data/lib/padrino-admin/locale/admin/en.yml

@@ -39,6 +39,7 @@ en:
         remove: "Delete"
         back: "Back"
         save: "Save"
+        save_and_back: "Save & Back"
         close: "Close"
         select: "Select"
         help: "Help"

data/lib/padrino-admin/middleware/flash_middleware.rb

@@ -0,0 +1,36 @@
+require 'rack/utils'
+
+module Padrino
+  module Admin
+    module Middleware
+      ##
+      # FlashSessionCookieMiddleware
+      #   passing your session in the URI, when it should be in the cookie
+      #
+      # This code only works in following cases:
+      # - passing the session as the variable for 'session_key' (it is best to set this to your app's session cookie name
+      # - the value is URI escaped once, (don't do it explicetally if using rails helpers, they do it for you)
+      # - Loading this middleware before session_store middleware
+      #
+      # Note, this could work also after session_store middleware (or others).
+      # However, these could already have modified the cooky values, and this module
+      # could become unstable because of that, and it's functioning can not be
+      # guaranteed.
+      # 
+      class FlashMiddleware
+        def initialize(app, session_key = 'session_id')
+          @app = app
+          @session_key = session_key.to_s
+        end
+
+        def call(env)
+          if env['HTTP_USER_AGENT'] =~ /^(Adobe|Shockwave) Flash/
+            params = ::Rack::Request.new(env).params
+            env['rack.session'][@session_key.to_sym] = params[@session_key] unless params[@session_key].nil?
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/padrino-admin/orm.rb

@@ -0,0 +1,33 @@
+module Padrino
+  module Admin
+
+    module Orm
+
+      class ExtSearch < Struct.new(:count, :records); end
+
+      ##
+      # Method used for register the orm extensions.
+      # 
+      def self.register!
+        ::DataMapper::Model.append_inclusions(Padrino::Admin::Orm::DataMapper::Base)      if defined?(::DataMapper)
+        ::ActiveRecord::Base.send(:include, Padrino::Admin::Orm::ActiveRecord::Base)      if defined?(::ActiveRecord)
+        ::MongoMapper::Document.append_inclusions(Padrino::Admin::Orm::MongoMapper::Base) if defined?(::MongoMapper)
+        # Extend also account model
+        self.extend_account!
+      end
+
+      ##
+      # This method it's used for extend Account Model (if present)
+      # 
+      def self.extend_account!
+        if defined?(Account) && Account.respond_to?(:orm)
+          case Account.orm
+            when :activerecord then Account.send(:include, Padrino::Admin::Orm::ActiveRecord::Account)
+            when :datamapper   then Account.send(:include, Padrino::Admin::Orm::DataMapper::Account)
+            when :mongomapper  then Account.send(:include, Padrino::Admin::Orm::MongoMapper::Account)
+          end
+        end
+      end
+    end # Orm
+  end # Admin
+end # Padrino

data/lib/padrino-admin/orm/abstract.rb

@@ -0,0 +1,94 @@
+module Padrino
+  module Admin
+    class OrmError < StandardError; end
+
+    module Orm
+      module Abstract
+        ##
+        # In this module we have shared function that are shared
+        # with all orm.
+        # 
+        module Base
+          def self.included(base) #:nodoc:
+            base.send :include, InstanceMethods
+            base.extend ClassMethods
+          end
+
+          module InstanceMethods
+          end
+
+          module ClassMethods
+            ##
+            # This method generate store and column config.
+            # for lazinies hands instead supply:
+            # 
+            #   Model.column_store("./../views/model/store.jml")
+            # 
+            # you can:
+            # 
+            #   Model.column_store(options.views, "models/store")
+            def column_store(*args)
+              path   = File.join(*args)
+              path   = Dir[path + ".{jml,jaml}"].first.to_s if path !~ /(\.jml|\.jaml)$/
+              config = YAML.load_file(path)
+              Padrino::Admin::ColumnStore.new(self, config)
+            end
+          end
+        end # Abstract
+
+        ##
+        # Accoun Extensions
+        # 
+        # An Account must have these column/fields:
+        # 
+        # role:: String
+        # email:: String (used as login)
+        # crypted_password:: String
+        # salt:: String
+        # 
+        # We add to Account model some methods:
+        # 
+        # Account.authenticate(email, password):: check if exist an account for the given email and return it if password match
+        # account.password_clean:: return the decrypted password of an Account instance
+        # 
+        module Account
+
+          def self.included(base) #:nodoc:
+            base.extend ClassMethods
+            base.send :include, InstanceMethods
+          end
+
+          module ClassMethods
+            ##
+            # This method it's for authentication purpose
+            # 
+            def authenticate(email, password)
+              account = first(:conditions => { :email => email }) if email.present?
+              account && account.password_clean == password ? account : nil
+            end
+          end
+
+          module InstanceMethods
+            ##
+            # This method it's used for retrive the original password.
+            # 
+            def password_clean
+              crypted_password.decrypt(salt)
+            end
+
+          private
+            def generate_password
+              return if password.blank?
+              self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{email}--") if new_record?
+              self.crypted_password = password.encrypt(self.salt)
+            end
+
+            def password_required
+              crypted_password.blank? || !password.blank?
+            end
+          end
+        end # Account
+      end # Abstract
+    end # Orm
+  end # Admin
+end # Padrino

data/lib/padrino-admin/{adapters/ar.rb → orm/activerecord.rb}

@@ -1,54 +1,79 @@
 module Padrino
   module Admin
-    module Adapters
-      module Ar
-
+    module Orm
+      module ActiveRecord
+        ##
         # Here basic functions for interact with ActiveRecord
+        # 
         module Base
-          def self.included(base)
-            base.send :include, Padrino::Admin::Adapters::Base
+
+          def self.included(base) #:nodoc:
+            base.send :include, Padrino::Admin::Orm::Abstract::Base
             base.send :include, InstanceMethods
             base.extend ClassMethods
           end
 
           module InstanceMethods
-
+            ##
             # Method for get only fields with errors
+            # 
             def errors_keys
               errors.map { |k,v| k.to_sym }.uniq
             end
-          end
+          end # InstanceMethods
 
           module ClassMethods
-            # Transforms attribute key names into a more humane format, such as "First name" instead of "first_name". Example:
+            ##
+            # Transforms attribute key names into a more humane format, such as "First name" instead of "first_name". 
+            # 
+            # Example:
             #   Person.human_attribute_name("first_name") # => "First name"
-            # This used to be depricated in favor of humanize, but is now preferred, because it automatically uses the I18n
-            # module now.
+            # 
             # Specify +options+ with additional translating options.
-            def human_attribute_name(attribute_key_name, options = {})
-              defaults = self_and_descendants.map do |klass|
-                :"#{klass.name.underscore}.#{attribute_key_name}"
-              end
-              defaults << options[:default] if options[:default]
-              defaults.flatten!
-              defaults << attribute_key_name.to_s.humanize
-              options[:count] ||= 1
-              I18n.translate(defaults.shift, options.merge(:default => defaults, :scope => [:model, :attributes]))
+            # 
+            def human_attribute_name(field, options = {})
+              options.reverse_merge!(:count => 1, :default => field.to_s.humanize, :scope => [:model, :attributes])
+              I18n.translate("#{self.name.underscore}.#{field}", options)
             end
 
-            # Alias method for get columns
+            ##
+            # Alias method for get columns names
+            # 
             def properties
               columns
             end
 
+            ##
+            # Return :activerecord
+            # 
+            def orm
+              :activerecord
+            end
+
+            ##
+            # Method for perorm a full text search / sorting in ExtJS grids.
+            # 
+            # For build a query you can provide for +params+:
+            # 
+            # query:: word do search will be converted to "%word%"
+            # fields:: where you want search
+            # sort:: field to sort
+            # dir:: one of ASC/DESC
+            # limit:: limit your results 
+            # start:: offset of your resluts
+            # 
+            # For +query+ we mean standard adapter options such as +include+, +joins+ ...
+            # 
+            # So a +ext_search+ can be:
+            # 
+            #   Account.ext_search({:query => "foo", fileds="name,surname,categories.name", :sort => "name", 
+            #                       :dir => "asc", :limit => 50, :offset => 10 }, { :joins => :categories })
+            # 
             def ext_search(params, query={})
 
               # We build a base struct for have some good results
               result = ExtSearch.new(0, [])
 
-              # We need a basic query
-              query = {}
-
               # Search conditions
               if params[:query].present? && params[:fields].present?
                 filters = params[:fields].split(",").collect { |f| "#{f} LIKE ?" }.compact
@@ -62,23 +87,30 @@ module Padrino
 
               # Now time to limit/offset it
               query[:limit]  = params[:limit].to_i  if params[:limit].to_i > 0
-              query[:offset] = params[:offset].to_i if params[:start].to_i > 0
+              query[:offset] = params[:start].to_i  if params[:start].to_i > 0
 
               result.records = all(query)
               result
             end
 
-          end
-        end
+          end # ClassMethods
+        end # Base
 
-        # Here extension for account for ActiveRecord
+        ##
+        # Here extension for Account for ActiveRecord
+        # 
+        # Basically we need only to perform:
+        # 
+        # * Validations (email, password, role)
+        # * Generate crypted_password on save
+        # 
         module Account
-          # Extend our class when included
-          def self.included(base)
-            base.send :include, Padrino::Admin::Adapters::AccountUtils
+
+          def self.included(base) #:nodoc:
+            base.send :include, Padrino::Admin::Orm::Abstract::Account
             base.send :attr_accessor, :password
             # Validations
-            base.validates_presence_of     :email
+            base.validates_presence_of     :email, :role
             base.validates_presence_of     :password,                   :if => :password_required
             base.validates_presence_of     :password_confirmation,      :if => :password_required
             base.validates_length_of       :password, :within => 4..40, :if => :password_required
@@ -86,11 +118,12 @@ module Padrino
             base.validates_length_of       :email,    :within => 3..100
             base.validates_uniqueness_of   :email,    :case_sensitive => false
             base.validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+            base.validates_format_of       :role,     :with => /[A-Za-z]/
             # Callbacks
             base.before_save :generate_password
           end
-        end
-      end
-    end
-  end
-end
+        end # Account
+      end # ActiveRecord
+    end # Orm
+  end # Admin
+end # Padrino

data/lib/padrino-admin/orm/datamapper.rb

@@ -0,0 +1,214 @@
+module Padrino
+  module Admin
+    module Orm
+      module DataMapper
+        ##
+        # Here basic functions for interact with DataMapper
+        # 
+        module Base
+
+          def self.included(base) #:nodoc:
+            base.send :include, Padrino::Admin::Orm::Abstract::Base
+            base.send :include, InstanceMethods
+            base.extend ClassMethods
+          end
+
+          module InstanceMethods
+            ##
+            # This is an alias method to allow us to don't see deprecations 
+            # and keep compatibility with new DataMapper versions
+            # 
+            def new_record?; new?; end
+
+            ##
+            # Returns a String, which Padrino uses for constructing an URL to this object. 
+            # The default implementation returns this record‘s id as a String, 
+            # or nil if this record‘s unsaved.
+            # 
+            def to_param
+              # We can't use alias_method here, because method 'id' optimizes itself on the fly.
+              (id = self.id) ? id.to_s : nil # Be sure to stringify the id for routes
+            end
+
+            ##
+            # Update attributes is deprecated but for compatibility with other ORM we support them.
+            # 
+            def update_attributes(attributes = {})
+              update(attributes)
+            end
+
+            ##
+            # Method for get only fields with errors
+            # 
+            def errors_keys
+              errors.keys
+            end
+
+          end # InstanceMethods
+
+          module ClassMethods
+            ##
+            # Transforms attribute key names into a more humane format, such as "First name" instead of "first_name". 
+            # 
+            # Example:
+            #   Person.human_attribute_name("first_name") # => "First name"
+            # 
+            # Specify +options+ with additional translating options.
+            # 
+            def human_attribute_name(field, options = {})
+              options.reverse_merge!(:count => 1, :default => field.to_s.humanize, :scope => [:model, :attributes])
+              I18n.translate("#{self.name.underscore}.#{field}", options)
+            end
+
+            ##
+            # Return the name of the Table
+            # 
+            # Because in some unkown circumstances +storage_names[:default]+ give us an wrong value
+            # we use the class name for get the value
+            # 
+            def table_name
+              self.name.underscore.pluralize
+            end
+
+            ##
+            # Return :activerecord
+            # 
+            def orm
+              :datamapper
+            end
+
+            ##
+            # Method for perorm a full text search / sorting in ExtJS grids.
+            # 
+            # For build a query you can provide for +params+:
+            # 
+            # query:: word do search will be converted to "%word%"
+            # fields:: where you want search
+            # sort:: field to sort
+            # dir:: one of ASC/DESC
+            # limit:: limit your results 
+            # start:: offset of your resluts
+            # 
+            # For +query+ we mean standard adapter options such as +links+ ...
+            # 
+            # So a +ext_search+ can be:
+            # 
+            #   Account.ext_search({:query => "foo", fileds="name,surname,categories.name", :sort => "name", 
+            #                       :dir => "asc", :limit => 50, :offset => 10 }, { :links => :categories })
+            # 
+            def ext_search(params, query={})
+
+              # We build a base struct for have some good results
+              result = ExtSearch.new(0, [])
+
+              if params[:query].present? && params[:fields].present?
+                # Here we build some like: ["name LIKE ?", "surname LIKE ?"]
+                fields  = params[:fields].split(",").collect { |f| "#{f.strip.downcase} LIKE ?" }
+                # Here we build some like: ["name LIKE ? OR surname LIKE ?", "%foo%", "%foo%"]
+                query[:conditions] = [fields.join(" OR ")].concat(1.upto(fields.length).collect { "%#{params[:query]}%" })
+              end
+
+              # Now we can perform a count
+              result.count = count(query)
+
+              # First we need to sort our record but we have some problems if we sort for associated tables.
+              # 
+              # see: http://www.mail-archive.com/datamapper@googlegroups.com/msg01310.html
+              # 
+              # I can get these values:
+              # 
+              # * accounts.name
+              # * accounts.posts.name
+              # * accounts.posts.categories.name
+              # 
+              # We need to transform in some like [DataMapper::Query::Direction.new(Account.properties[:name], :asc)]
+              # 
+              if params[:sort].present? && params[:dir].to_s =~ /^(asc|desc)$/i
+                values    = params[:sort].to_s.sub(/^#{table_name}\./, "").split(".").collect(&:to_sym)
+                property  = values.delete_at(-1) # the last value is always a property
+                relation  = values.inject(self) do |relation, value| 
+                  raise "Unknow relation #{value} for #{relation}" unless relation.relationships[value]
+                  relation.send(value)
+                end
+                target = relation.respond_to?(:model) ? relation.model.properties[property] : relation.properties[property]
+                query[:order] = [::DataMapper::Query::Direction.new(target, params[:dir].to_s.downcase.to_sym)]
+              end
+
+              # Now time to limit/offset it
+              query[:limit]  = params[:limit].to_i  if params[:limit].to_i > 0
+              query[:offset] = params[:start].to_i  if params[:start].to_i > 0
+
+              # Now we can perform ording/limiting
+              result.records = all(query)
+              result
+            end
+
+            ##
+            # The aim of this method is act DM as AR, so when you define a many-to-many relation like:
+            # 
+            #   has n, :images
+            #   has n, :images, :through => Resource
+            # 
+            # you have two new methods:
+            # 
+            #   images_ids
+            #   images_ids=(*ids)
+            #
+            def has(cardinality, name, *args)
+              relationship = super(cardinality, name, *args)
+              if relationship.is_a?(::DataMapper::Associations::ManyToMany::Relationship) ||
+                 relationship.is_a?(::DataMapper::Associations::OneToMany::Relationship)
+
+                class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                  def #{name.to_s.singular}_ids
+                    #{name}.collect(&:id)
+                  end
+
+                  def #{name.to_s.singular}_ids=(*ids)
+                    self.#{name} = #{relationship.child_model.name}.all(:id => ids.flatten)
+                  end
+                RUBY
+              end
+              relationship
+            end
+          end # ClassMethods
+        end # Base
+
+        ##
+        # Here extension for Account for MongoMapper
+        # 
+        # Basically we need only to perform:
+        # 
+        # * Validations (email, password, role)
+        # * Generate crypted_password on save
+        # 
+        module Account
+
+          def self.included(base) #:nodoc:
+            super
+            base.send :include, Padrino::Admin::Orm::Abstract::Account
+            base.send :include, ::DataMapper::Validate
+            base.send :attr_accessor, :password, :password_confirmation
+            # Properties
+            base.property :email,            String
+            base.property :crypted_password, String
+            base.property :salt,             String
+            base.property :role,             String
+            # Validations
+            base.validates_present      :email, :role
+            base.validates_present      :password,                          :if => :password_required
+            base.validates_present      :password_confirmation,             :if => :password_required
+            base.validates_length       :password, :min => 4, :max => 40,   :if => :password_required
+            base.validates_is_confirmed :password,                          :if => :password_required
+            base.validates_length       :email,    :min => 3, :max => 100
+            base.validates_is_unique    :email,    :case_sensitive => false
+            base.validates_format       :email,    :with => :email_address
+            base.validates_format       :role,     :with => /[A-Za-z]/
+            # Callbacks
+            base.before :save, :generate_password
+          end
+        end # Account
+      end # DataMapper
+    end # Orm
+  end # Admin
+end # Padrino