padrino-admin 0.8.5 → 0.9.0

data/lib/padrino-admin/locale/extjs/it.yml

@@ -1,147 +0,0 @@
-it:
-  extjs:
-    dateFormat: "d/m/Y"
-    dateTimeFormat: "d/m/Y G:i"
-    ddText: "{0} righe selezionate"
-    closeText: "Chiudi pannello"
-    invalidText: "Valore non valido"
-    msg: "Caricamento in corso..."
-    emptyText: ""
-    splitRegion:
-      splitTip: "Trascina per cambiare dimensioni."
-      collapsibleSplitTip: "Trascina per cambiare dimensioni. Doppio click per nascondere."
-    messageBox:
-      ok: "OK"
-      yesse: "Sì"
-      cancel: "Annulla"
-      none: "No"
-    datePicker:
-      todayText: "Oggi"
-      minText: "Data precedente alla data minima"
-      maxText: "Data successiva alla data massima"
-      disabledDaysText: ""
-      disabledDatesText: ""
-      nextText: 'Mese successivo (Ctrl+Destra)'
-      prevText: 'Mese precedente (Ctrl+Sinistra)'
-      monthYearText: 'Scegli un mese (Ctrl+Su/Giu per cambiare anno)'
-      todayTip: "{0} (Barra spaziatrice)"
-      format: "d/m/y"
-      cancelText: "Annulla"
-      okText: " OK "
-      startDay: 1
-    grid:
-      gridView:
-        sortAscText: "Ordinamento crescente"
-        sortDescText: "Ordinamento decrescente"
-        lockText: "Blocca colonna"
-        unlockText: "Sblocca colonna"
-        columnsText: "Colonne"
-      groupingView:
-        emptyGroupText: '(Nessun dato)'
-        groupByText: 'Raggruppa per questo campo'
-        showGroupsText: 'Mostra nei gruppi'
-      propertyColumnModel:
-        nameText: "Nome"
-        valueText: "Valore"
-        dateFormat: "j/m/Y"
-    search:
-      searchText: "Cerca"
-      searchTipText: "Inserisci una parola o premi cerca"
-      selectAllText: "Seleziona Tutto"
-      minCharsTipText: "Inserisci almeno {0} caratteri"
-    pagingToolbar:
-      beforePageText: "Pagina"
-      afterPageText: "di {0}"
-      firstText: "Prima pagina"
-      prevText: "Pagina precedente"
-      nextText: "Pagina successiva"
-      lastText: "Ultima pagina"
-      refreshText: "Aggiorna"
-      displayMsg: "Record {0} - {1} di {2}"
-      emptyMsg: 'Nessun dato da mostrare'
-    form:
-      textField:
-        minLengthText: "La lunghezza minima è {0}"
-        maxLengthText: "La lunghezza massima è {0}"
-        blankText: "Campo obbligatorio"
-        regexText: ""
-        emptyText: ""
-      numberField:
-        minText: "Il valore minimo è {0}"
-        maxText: "Il valore massimo è {0}"
-        nanText: "{0} non è un valore numerico corretto"
-      dateField:
-        disabledDaysText: "Disabilitato"
-        disabledDatesText: "Disabilitato"
-        minText: "La data deve essere successiva al {0}"
-        maxText: "La data deve essere precedente al {0}"
-        invalidText: "{0} non \u00E8 una data valida. Deve essere nel formato {1}"
-        format: "d/m/y"
-        altFormats: "d/m/Y|d-m-y|d-m-Y|d/m|d-m|dm|dmy|dmY|d|Y-m-d"
-      comboBox:
-        loadingText: "Caricamento in corso..."
-        valueNotFoundText: ""
-      vTypes:
-        emailText: 'Il campo deve essere un indirizzo e-mail nel formato "user@domain.com"'
-        urlText: 'Il campo deve essere un indirizzo web nel formato "http://www.domain.com"'
-        alphaText: 'Il campo deve contenere solo lettere e _'
-        alphanumText: 'Il campo deve contenere solo lettere, numeri e _'
-      htmlEditor:
-        createLinkText: 'Inserire un URL per il link:'
-        buttonTips:
-          bold:
-            title: 'Grassetto (Ctrl+B)'
-            text: 'Rende il testo selezionato in grassetto.'
-            cls: 'x-html-editor-tip'
-          italic:
-            title: 'Corsivo (Ctrl+I)'
-            text: 'Rende il testo selezionato in corsivo.'
-            cls: 'x-html-editor-tip'
-          underline:
-            title: 'Sottolinea (Ctrl+U)'
-            text: 'Sottolinea il testo selezionato.'
-            cls: 'x-html-editor-tip'
-          increasefontsize:
-            title: 'Ingrandisci testo'
-            text: 'Aumenta la dimensione del carattere.'
-            cls: 'x-html-editor-tip'
-          decreasefontsize:
-            title: 'Rimpicciolisci testo'
-            text: 'Diminuisce la dimensione del carattere.'
-            cls: 'x-html-editor-tip'
-          backcolor:
-            title: 'Colore evidenziatore testo'
-            text: 'Modifica il colore di sfondo del testo selezionato.'
-            cls: 'x-html-editor-tip'
-          forecolor:
-            title: 'Colore carattere'
-            text: 'Modifica il colore del testo selezionato.'
-            cls: 'x-html-editor-tip'
-          justifyleft:
-            title: 'Allinea a sinistra'
-            text: 'Allinea il testo a sinistra.'
-            cls: 'x-html-editor-tip'
-          justifycenter:
-            title: 'Centra'
-            text: 'Centra il testo.'
-            cls: 'x-html-editor-tip'
-          justifyright:
-            title: 'Allinea a destra'
-            text: 'Allinea il testo a destra.'
-            cls: 'x-html-editor-tip'
-          insertunorderedlist:
-            title: 'Elenco puntato'
-            text: 'Elenco puntato.'
-            cls: 'x-html-editor-tip'
-          insertorderedlist:
-            title: 'Elenco numerato'
-            text: 'Elenco numerato.'
-            cls: 'x-html-editor-tip'
-          createlink:
-            title: 'Collegamento'
-            text: 'Trasforma il testo selezionato in un collegamanto.'
-            cls: 'x-html-editor-tip'
-          sourceedit:
-            title: 'Sorgente'
-            text: 'Passa alla modalit\u00E0 editing del sorgente.'
-            cls: 'x-html-editor-tip'

data/lib/padrino-admin/orm.rb

@@ -1,48 +0,0 @@
-module Padrino
-  module Admin
-
-    ##
-    # Extend your orm adding these functions:
-    # 
-    # * Translatable columns names (if not just support them)
-    # * Full text search
-    # * Pagination
-    # * Extend Account Model with: role, validation, permission, authentication
-    # 
-    module Orm
-
-      ##
-      # ExtSearch it's the result of an ext_search
-      # 
-      #   result = Account.ext_search(..)
-      #   result.count
-      #   result.records
-      # 
-      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

@@ -1,95 +0,0 @@
-module Padrino
-  module Admin
-    class OrmError < StandardError #:nodoc:
-    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/orm/activerecord.rb

@@ -1,144 +0,0 @@
-module Padrino
-  module Admin
-    module Orm
-      module ActiveRecord
-        ##
-        # Here basic functions for interact with ActiveRecord
-        # 
-        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
-            ##
-            # Method for get only fields with errors
-            # 
-            def errors_keys
-              errors.map { |k,v| k.to_sym }.uniq
-            end
-          end # InstanceMethods
-
-          module ClassMethods
-            ##
-            # Transforms attribute key names into a more humane and localizable format, such as "First name" instead of "first_name". 
-            # 
-            # ==== Examples
-            #   # Do: I18n.translate("models.person.attributes.first_name")
-            #   Person.human_local_attribute_name("first_name") # => "First name"
-            # 
-            # Specify +options+ with additional translating options.
-            # 
-            def human_local_attribute_name(field, options = {})
-              options.reverse_merge!(:count => 1, :default => field.to_s.humanize, :scope => :models)
-              I18n.translate("#{self.name.underscore}.attributes.#{field}", options)
-            end
-
-            ##
-            # Transform table name into a more humane and localizable format, such as "Blog Posts" instead of "BlogPost". 
-            # 
-            # ==== Examples
-            #   # Do: I18n.translate("models.person.name")
-            #   Person.human_local_name # => "Persona"
-            # 
-            # Specify +options+ with additional translating options.
-            # 
-            def human_local_name(options = {})
-              options.reverse_merge!(:count => 1, :default => self.name.humanize, :scope => :models)
-              I18n.translate("#{self.name.underscore}.name", options)
-            end
-
-            ##
-            # 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, [])
-
-              # Search conditions
-              if params[:query].present? && params[:fields].present?
-                filters = params[:fields].split(",").collect { |f| "#{f} LIKE ?" }.compact
-                query[:conditions] = [filters.join(" OR ")].concat((1..filters.size).collect { "%#{params[:query]}%" })
-              end
-
-              result.count = count(query)
-
-              # Order conditions
-              query[:order] = params[:sort].present? && params[:dir].to_s =~ /^(asc|desc)$/i ? "#{params[:sort]} #{params[:dir]}" : nil
-
-              # 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
-
-              result.records = all(query)
-              result
-            end
-
-          end # ClassMethods
-        end # Base
-
-        ##
-        # Here extension for Account for ActiveRecord
-        # 
-        # Basically we need only to perform:
-        # 
-        # * Validations (email, password, role)
-        # * Generate crypted_password on save
-        # 
-        module Account
-
-          def self.included(base) #:nodoc:
-            base.send :include, Padrino::Admin::Orm::Abstract::Account
-            base.send :attr_accessor, :password
-            # Validations
-            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
-            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
-            base.validates_format_of       :role,     :with => /[A-Za-z]/
-            # Callbacks
-            base.before_save :generate_password
-          end
-        end # Account
-      end # ActiveRecord
-    end # Orm
-  end # Admin
-end # Padrino

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

@@ -1,229 +0,0 @@
-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 and localizable format, such as "First name" instead of "first_name". 
-            # 
-            # ==== Examples
-            #   # Do: I18n.translate("models.person.attributes.first_name")
-            #   Person.human_local_attribute_name("first_name") # => "First name"
-            # 
-            # Specify +options+ with additional translating options.
-            # 
-            def human_local_attribute_name(field, options = {})
-              options.reverse_merge!(:count => 1, :default => field.to_s.humanize, :scope => :models)
-              I18n.translate("#{self.name.underscore}.attributes.#{field}", options)
-            end
-
-            ##
-            # Transform table name into a more humane and localizable format, such as "Blog Posts" instead of "BlogPost". 
-            # 
-            # ==== Examples
-            #   # Do: I18n.translate("models.person.name")
-            #   Person.human_local_name # => "Persona"
-            # 
-            # Specify +options+ with additional translating options.
-            # 
-            def human_local_name(options = {})
-              options.reverse_merge!(:count => 1, :default => self.name.humanize, :scope => :models)
-              I18n.translate("#{self.name.underscore}.name", 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)
-            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