padrino-admin 0.2.9 → 0.4.5

data/lib/padrino-admin/adapters.rb

@@ -0,0 +1,82 @@
+require 'openssl'
+require 'digest/sha1'
+
+module Padrino
+  module Admin
+
+    class AdapterError < StandardError; end
+
+    module Adapters
+      # This method it's used for register for the specified ORM the extensions.
+      def self.register(adapter, klass=nil)
+        klass ||= Account
+        case adapter
+          when :active_record
+            ActiveRecord::Base.send(:include, Padrino::Admin::Adapters::Ar::Base)
+            klass.send(:include, Padrino::Admin::Adapters::Ar::Account)
+          when :data_mapper
+            DataMapper::Model.descendants.each { |d| d.send(:include, Padrino::Admin::Adapters::Dm::Base) }
+            klass.send(:include, Padrino::Admin::Adapters::Dm::Account)
+          when :mongo_mapper
+            MongoMapper::Document.append_inclusions(Padrino::Admin::Adapters::Mm::Base)
+            klass.send(:include, Padrino::Admin::Adapters::Mm::Account)
+          else
+            raise Padrino::Admin::AdapterError, "The adapter #{adapter.inspect} is not supported, available adapters are: " + 
+                                                ":active_record, :data_mapper, :mongo_mapper"
+        end
+      end
+
+      # Here standard extension
+      module Base
+        # TODO
+      end
+      # Here extension for account
+      # 
+      # 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 AccountUtils
+
+        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 })
+            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
+    end
+  end
+end

data/lib/padrino-admin/adapters/ar.rb

@@ -0,0 +1,75 @@
+module Padrino
+  module Admin
+    module Adapters
+      module Ar
+
+        # Here basic functions for interact with ActiveRecord
+        module Base
+          def self.included(base)
+            base.send :include, Padrino::Admin::Adapters::Base
+            base.send :include, InstanceMethods
+            base.extend ClassMethods
+            base.class_eval do
+              named_scope :ext_search, lambda { |params|
+                conditions = nil
+
+                if !params[:query].blank? && !params[:fields].blank?
+                  filters = params[:fields].split(",").collect { |f| "#{f} LIKE ?" }.compact
+                  conditions = [filters.join(" OR ")].concat((1..filters.size).collect { "%#{params[:query]}%" })
+                end
+
+                { :conditions => conditions }
+              }
+              named_scope :ext_paginate, lambda { |params|
+                params.symbolize_keys!
+                order = params[:sort].blank? && params[:dir].blank? ? nil : "#{params[:sort]} #{params[:dir]}"
+                { :order => order, :limit => params[:limit], :offset => params[:start] }
+              }
+            end
+          end
+          
+          module InstanceMethods
+          end
+          
+          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"
+            # 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]))
+            end
+          end
+        end
+
+        # Here extension for account for ActiveRecord
+        module Account
+          # Extend our class when included
+          def self.included(base)
+            base.send :include, Padrino::Admin::Adapters::AccountUtils
+            base.send :attr_accessor, :password
+            # Validations
+            base.validates_presence_of     :email
+            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
+            base.validates_confirmation_of :password,                   :if => :password_required
+            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
+            # Callbacks
+            base.before_save :generate_password
+          end
+        end
+      end
+    end
+  end
+end

data/lib/padrino-admin/adapters/dm.rb

@@ -0,0 +1,131 @@
+module Padrino
+  module Admin
+    module Adapters
+      module Dm
+
+        # Here basic functions for interact with DataMapper
+        module Base
+
+          def self.included(base)
+            base.send :include, Padrino::Admin::Adapters::Base
+            base.send :include, InstanceMethods
+            base.extend ClassMethods
+          end
+          
+          module InstanceMethods
+            # This method allow us to don't see deprecations
+            def new_record?; new?; end
+          end
+          
+          module ClassMethods
+            def self_and_descendants #:nodoc:
+              klass = self
+              classes = [klass]
+              while klass != klass.base_class  
+                classes << klass = klass.superclass
+              end
+              classes
+            rescue
+              # OPTIMIZE this rescue is to fix this test: ./test/cases/reflection_test.rb:56:in `test_human_name_for_column'
+              # Appearantly the method base_class causes some trouble.
+              # It now works for sure.
+              [self]
+            end
+
+            # 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]))
+            end
+
+            # Return the name of the sql table
+            def table_name
+              storage_names[:default]
+            end
+
+            # Perform a basic fulltext search/ordering for the given columns
+            # 
+            # +params+ is an hash like that:
+            #   { :sort => "name", :dir => "ASC", :fields=>"name,surname,company", :query => 'daddye' }
+            # 
+            # In this example we search in columns name, surname, company the string daddye and then we order by
+            # column +name+
+            def ext_search(params)
+              params.symbolize_keys!
+
+              # We need a basic query
+              query = {}
+
+              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 search
+              all(query)
+            end
+
+            def ext_paginate(params)
+              params.symbolize_keys!
+
+              # We need a basic query
+              query = {}
+
+              # First we need to sort our record
+              if params[:sort].present? && params[:dir].to_s =~ /^(asc|desc)$/
+                query[:order] = [params[:sort].to_sym.send(params[:dir].to_s.downcase)]
+              end
+
+              # 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[:offset].to_i > 0
+
+              # Now we can perform ording/limiting
+              all(query)
+            end
+          end
+        end
+
+        # Here extension for account for DataMapper
+        module Account
+          # Extend our class when included
+          def self.included(base)
+            super
+            base.send :include, Padrino::Admin::Adapters::AccountUtils
+            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
+      end
+    end
+  end
+end

data/lib/padrino-admin/adapters/mm.rb

@@ -0,0 +1,49 @@
+module Padrino
+  module Admin
+    module Adapters
+      module Mm
+
+        # Here basic functions for interact with MongoMapper
+        module Base
+          def self.included(base)
+            base.send :include, Padrino::Admin::Adapters::Base
+            base.send :include, InstanceMethods
+            base.extend ClassMethods
+          end
+          
+          module InstanceMethods
+          end
+          
+          module ClassMethods
+          end
+        end
+
+        # Here extension for account for DataMapper
+        module Account
+          # Extend our class when included
+          def self.included(base)
+            super
+            base.send :include, Padrino::Admin::Adapters::AccountUtils
+            base.send :attr_accessor, :password, :password_confirmation
+            # Properties
+            base.key :email,            String
+            base.key :crypted_password, String
+            base.key :salt,             String
+            base.key :role,             String
+            # Validations
+            base.validates_presence_of     :email
+            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
+            base.validates_confirmation_of :password,                   :if => :password_required
+            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
+            # Callbacks
+            base.before_save :generate_password
+          end
+        end
+      end
+    end
+  end
+end

data/lib/padrino-admin/ext_js/config.rb

@@ -3,167 +3,169 @@ require 'yaml'
 require 'erb'
 require 'json/pure'
 
-module ExtJs
+module Padrino
+  module ExtJs
 
-  class ConfigError < RuntimeError; end
+    class ConfigError < RuntimeError; end
 
-  # This class it's used for JSON variables.
-  # Normally if we convert this { :function => "alert('Test')" } will be:
-  # 
-  #   { "function": "alert('Test')" }
-  # 
-  # But if in our javascript need to "eval" this function is not possible because
-  # it's a string.
-  # 
-  # Using ExtJs::Variable the result will be:
-  # 
-  #   { "function" : alert('Test') }
-  # 
-  # Normally an ExtJs Variable can be handled with ExtJs Config like:
-  # 
-  #   function: !js alert('Test')
-  # 
-  class Variable < String
-    yaml_as "tag:yaml.org,2002:js"
+    # This class it's used for JSON variables.
+    # Normally if we convert this { :function => "alert('Test')" } will be:
+    # 
+    #   { "function": "alert('Test')" }
+    # 
+    # But if in our javascript need to "eval" this function is not possible because
+    # it's a string.
+    # 
+    # Using Padrino::ExtJs::Variable the result will be:
+    # 
+    #   { "function" : alert('Test') }
+    # 
+    # Normally an ExtJs Variable can be handled with ExtJs Config like:
+    # 
+    #   function: !js alert('Test')
+    # 
+    class Variable < String
+      yaml_as "tag:yaml.org,2002:js"
 
-    def to_json(*a) #:nodoc:
-      self
+      def to_json(*a) #:nodoc:
+        self
+      end
     end
-  end
 
-  # This class it's used for write in a new and simple way json.
-  # 
-  # In ExtJs framework generally each component have a configuration written in json.
-  # 
-  # Write this config in ruby it's not the best choice think this example:
-  # 
-  #   # A Generic grid config in JavaScript:
-  #   var gridPanel = new Ext.grid.GridPanel({
-  #     bbar: gridPanelPagingToolbar,
-  #     clicksToEdit: 1,
-  #     cm: gridPanelColumnModel,
-  #     region: "center",
-  #     sm: gridPanelCheckboxSelectionModel,
-  #     viewConfig: {"forceFit":true},
-  #     plugins: [new Ext.grid.Search()],
-  #     border: false,
-  #     tbar: gridPanelToolbar,
-  #     id: "grid-accounts",
-  #     bodyBorder: false,
-  #     store: gridPanelGroupingStore,
-  #     view: gridPanelGroupingView
-  #   });
-  # 
-  #   # A Gneric grid config in Ruby:
-  #   { :bbar => ExtJs::Variable.new('gridPanelPagingToolbar'), :clicksToEdit => 1, 
-  #     :cm => ExtJs::Variable.new('gridPanelColumnModel'), :region => "center",
-  #     :sm => ExtJs::Variable.new('gridPanelCheckboxSelectionModel'),
-  #     :viewConfig => { :forceFit => true }, plugins => [ExtJs::Variable.new('new Ext.grid.Search()'].
-  #     :border => false ... more more code...
-  # 
-  # As you can see writing json in pure ruby (in this case with hash) require much time and is
-  # <tt>less</tt> readable.
-  # 
-  # For this reason we build an ExtJs Config, that basically it's an yaml file with
-  # some new great functions so the example above will be:
-  # 
-  #   # A Generic grid config in ExtJs Config:
-  #   gridPanel:
-  #     bbar: !js gridPanelPagingToolbar
-  #     clicksToEdit: 1,
-  #     cm: !js gridPanelColumnModel
-  #     region: center
-  #     sm: !js gridPanelCheckboxSelectionModel
-  #     viewConfig:
-  #       forceFit: true
-  #     plugins: [!js new Ext.grid.Search()]
-  #     border: false
-  #     tbar: !js gridPanelToolbar
-  #     id: grid-accounts
-  #     bodyBorder: false
-  #     store: !js gridPanelGroupingStore
-  #     view: !js gridPanelGroupingView
-  # 
-  # Now you see that it's more readable, simple and coincise!
-  # 
-  # But our ExtJs config can act also as an xml or an erb partial. See this code:
-  # 
-  #   # A template
-  #   tempate:
-  #     tbar:
-  #       here: a custom config
-  #     grid:
-  #       viewConfig:
-  #         forceFit: true
-  #       plugins: [!js new Ext.grid.Search()]
-  #       border: false  
-  # 
-  # We can "grep" this config in our template with:
-  #   
-  #   # A generic grid
-  #   gridPanel:
-  #     <<: %template/grid
-  #     border: true
-  # 
-  # The result will be:
-  # 
-  #   gridPanel:
-  #     viewConfig:
-  #       forceFit: true
-  #     plugins: [!js new Ext.grid.Search()]
-  #     border: true # overidden
-  # 
-  # See our test for more complex examples.
-  # 
-  class Config < Hash
-    
-    # Initialize a new config parsing an Hash
-    def initialize(data)
-      @data   = data
-      parsed  = parse(@data)
-      super
-      replace parsed
-    end
+    # This class it's used for write in a new and simple way json.
+    # 
+    # In ExtJs framework generally each component have a configuration written in json.
+    # 
+    # Write this config in ruby it's not the best choice think this example:
+    # 
+    #   # A Generic grid config in JavaScript:
+    #   var gridPanel = new Ext.grid.GridPanel({
+    #     bbar: gridPanelPagingToolbar,
+    #     clicksToEdit: 1,
+    #     cm: gridPanelColumnModel,
+    #     region: "center",
+    #     sm: gridPanelCheckboxSelectionModel,
+    #     viewConfig: {"forceFit":true},
+    #     plugins: [new Ext.grid.Search()],
+    #     border: false,
+    #     tbar: gridPanelToolbar,
+    #     id: "grid-accounts",
+    #     bodyBorder: false,
+    #     store: gridPanelGroupingStore,
+    #     view: gridPanelGroupingView
+    #   });
+    # 
+    #   # A Gneric grid config in Ruby:
+    #   { :bbar => Padrino::ExtJs::Variable.new('gridPanelPagingToolbar'), :clicksToEdit => 1, 
+    #     :cm => Padrino::ExtJs::Variable.new('gridPanelColumnModel'), :region => "center",
+    #     :sm => Padrino::ExtJs::Variable.new('gridPanelCheckboxSelectionModel'),
+    #     :viewConfig => { :forceFit => true }, plugins => [Padrino::ExtJs::Variable.new('new Ext.grid.Search()'].
+    #     :border => false ... more more code...
+    # 
+    # As you can see writing json in pure ruby (in this case with hash) require much time and is
+    # <tt>less</tt> readable.
+    # 
+    # For this reason we build an ExtJs Config, that basically it's an yaml file with
+    # some new great functions so the example above will be:
+    # 
+    #   # A Generic grid config in ExtJs Config:
+    #   gridPanel:
+    #     bbar: !js gridPanelPagingToolbar
+    #     clicksToEdit: 1,
+    #     cm: !js gridPanelColumnModel
+    #     region: center
+    #     sm: !js gridPanelCheckboxSelectionModel
+    #     viewConfig:
+    #       forceFit: true
+    #     plugins: [!js new Ext.grid.Search()]
+    #     border: false
+    #     tbar: !js gridPanelToolbar
+    #     id: grid-accounts
+    #     bodyBorder: false
+    #     store: !js gridPanelGroupingStore
+    #     view: !js gridPanelGroupingView
+    # 
+    # Now you see that it's more readable, simple and coincise!
+    # 
+    # But our ExtJs config can act also as an xml or an erb partial. See this code:
+    # 
+    #   # A template
+    #   tempate:
+    #     tbar:
+    #       here: a custom config
+    #     grid:
+    #       viewConfig:
+    #         forceFit: true
+    #       plugins: [!js new Ext.grid.Search()]
+    #       border: false  
+    # 
+    # We can "grep" this config in our template with:
+    #   
+    #   # A generic grid
+    #   gridPanel:
+    #     <<: %template/grid
+    #     border: true
+    # 
+    # The result will be:
+    # 
+    #   gridPanel:
+    #     viewConfig:
+    #       forceFit: true
+    #     plugins: [!js new Ext.grid.Search()]
+    #     border: true # overidden
+    # 
+    # See our test for more complex examples.
+    # 
+    class Config < Hash
 
-    # Load a new config from an yml file and return a parsed hash.
-    def self.load_file(path, binding=nil)
-      self.load(File.read(path), binding)
-    end
+      # Initialize a new config parsing an Hash
+      def initialize(data)
+        @data   = data
+        parsed  = parse(@data)
+        super
+        replace parsed
+      end
 
-    # Load a new config from a yaml "string" and return a parsed hash.
-    def self.load(string, binding=nil)
-      self.new YAML.parse(ERB.new(string).result(binding))
-    end
+      # Load a new config from an yml file and return a parsed hash.
+      def self.load_file(path, binding=nil)
+        self.load(File.read(path), binding)
+      end
 
-  private
-    def parse(node=nil, key=nil)
-      case node.value
-        when String
-          if node.value =~ /^%{1}(.*)/
-            node = parse(@data.select($1).first)
-          end
-          node.respond_to?(:transform) ? node.transform : node
-        when Hash
-          parsed = {}
-          node.value.each do |k,v| 
-            if k.value == "<<"
-              node = parse(v)
-              if node.is_a?(Hash)
-                node.merge!(parsed)
+      # Load a new config from a yaml "string" and return a parsed hash.
+      def self.load(string, binding=nil)
+        self.new YAML.parse(ERB.new(string).result(binding))
+      end
+
+    private
+      def parse(node=nil, key=nil)
+        case node.value
+          when String
+            if node.value =~ /^%{1}(.*)/
+              node = parse(@data.select($1).first)
+            end
+            node.respond_to?(:transform) ? node.transform : node
+          when Hash
+            parsed = {}
+            node.value.each do |k,v| 
+              if k.value == "<<"
+                node = parse(v)
+                if node.is_a?(Hash)
+                  node.merge!(parsed)
+                end
+                parsed = node
+              else
+                parsed[k.value] = parse(v)
               end
-              parsed = node
-            else
-              parsed[k.value] = parse(v)
             end
-          end
-          parsed
-        when Array
-          parsed = []
-          node.value.each do |v|
-            node = parse(v)
-            node.is_a?(Array) ? parsed.concat(node) : parsed.push(node)
-          end
-          parsed
+            parsed
+          when Array
+            parsed = []
+            node.value.each do |v|
+              node = parse(v)
+              node.is_a?(Array) ? parsed.concat(node) : parsed.push(node)
+            end
+            parsed
+        end
       end
     end
   end