padrino-admin 0.16.0.pre4 → 0.16.0

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

@@ -12,12 +12,12 @@ module Padrino
       class Orm
         attr_reader :klass_name, :klass, :name_plural, :name_singular, :orm, :name_param
 
-        def initialize(name, orm, columns=nil, column_fields=nil)
+        def initialize(name, orm, columns = nil, column_fields = nil)
           name            = name.to_s
           @klass_name     = name.underscore.camelize
           @klass          = @klass_name.constantize rescue nil
-          @name_param     = name.underscore.gsub(/\//, '_')
-          @name_singular  = name.underscore.gsub(/^.*\//, '') # convert submodules i.e. FooBar::Jank.all # => jank
+          @name_param     = name.underscore.gsub('/', '_')
+          @name_singular  = name.underscore.gsub(%r{^.*/}, '') # convert submodules i.e. FooBar::Jank.all # => jank
           @name_plural    = @name_singular.pluralize
           @orm            = orm.to_sym
           @columns        = columns
@@ -35,62 +35,59 @@ module Padrino
         def field_type(type)
           type = :string if type.nil? # couchrest-Hack to avoid the next line to fail
           type = type.to_s.demodulize.downcase.to_sym unless type.is_a?(Symbol)
+
           case type
-            when :integer, :float, :decimal   then :text_field
-            when :string                      then :text_field
-            when :text                        then :text_area
-            when :boolean                     then :check_box
-            else :text_field
+          when :integer, :float, :decimal   then :text_field
+          when :string                      then :text_field
+          when :text                        then :text_area
+          when :boolean                     then :check_box
+          else :text_field
           end
         end
 
         Column = Struct.new(:name, :type) # for compatibility
 
         def columns
-          @columns ||= case orm
+          @columns ||=
+            case orm
             when :activerecord then @klass.columns
             when :minirecord   then @klass.columns
             when :datamapper   then @klass.properties.map { |p| dm_column(p) }
             when :couchrest    then @klass.properties
             when :mongoid      then @klass.fields.values.reject { |col| %w[_id _type].include?(col.name) }
-            when :mongomapper  then @klass.keys.values.reject { |key| key.name == "_id" } # On MongoMapper keys are an hash
-            when :sequel       then @klass.db_schema.map { |k,v| v[:type] = :text if v[:db_type] =~ /^text/i; Column.new(k, v[:type]) }
+            when :mongomapper  then @klass.keys.values.reject { |key| key.name == '_id' } # On MongoMapper keys are an hash
+            when :sequel       then @klass.db_schema.map { |k, v| v[:type] = :text if v[:db_type] =~ /^text/i; Column.new(k, v[:type]) }
             when :ohm          then @klass.attributes.map { |a| Column.new(a.to_s, :string) } # ohm has strings
-            when :dynamoid     then @klass.attributes.map { |k,v| Column.new(k.to_s, v[:type]) }
+            when :dynamoid     then @klass.attributes.map { |k, v| Column.new(k.to_s, v[:type]) }
             else raise OrmError, "Adapter #{orm} is not yet supported!"
-          end
+            end
         end
 
-        def dm_column(p)
-          case p
+        def dm_column(property)
+          case property
           when DataMapper::Property::Text
-            Column.new(p.name, :text)
+            Column.new(property.name, :text)
           when DataMapper::Property::Boolean
-            Column.new(p.name, :boolean)
+            Column.new(property.name, :boolean)
           when DataMapper::Property::Integer
-            Column.new(p.name, :integer)
+            Column.new(property.name, :integer)
           when DataMapper::Property::Decimal
-            Column.new(p.name, :decimal)
+            Column.new(property.name, :decimal)
           when DataMapper::Property::Float
-            Column.new(p.name, :float)
+            Column.new(property.name, :float)
           when DataMapper::Property::String
-            Column.new(p.name, :string)
-          else #if all fails, lets assume its stringish
-            Column.new(p.name, :string)
+            Column.new(property.name, :string)
+          else # if all fails, lets assume its string-ish
+            Column.new(property.name, :string)
           end
         end
 
         def column_fields
-          excluded_columns = %w[created_at updated_at]
-          case orm
-            when :mongoid then excluded_columns << '_id'
-            else excluded_columns << 'id'
-          end
-
+          excluded_columns = %w[created_at updated_at] << (orm == :mongoid ? '_id' : 'id')
           column_fields    = columns.dup
           column_fields.reject! { |column| excluded_columns.include?(column.name.to_s) }
           @column_fields ||= column_fields.map do |column|
-            { :name => column.name, :field_type => field_type(column.type) }
+            { name: column.name, field_type: field_type(column.type) }
           end
         end
 
@@ -98,16 +95,16 @@ module Padrino
           "#{klass_name}.all"
         end
 
-        def find(params=nil)
+        def find(params = nil)
           case orm
-            when :activerecord, :minirecord, :mongomapper, :mongoid, :dynamoid then "#{klass_name}.find(#{params})"
-            when :datamapper, :couchrest then "#{klass_name}.get(#{params})"
-            when :sequel, :ohm then "#{klass_name}[#{params}]"
-            else raise OrmError, "Adapter #{orm} is not yet supported!"
+          when :activerecord, :minirecord, :mongomapper, :mongoid, :dynamoid then "#{klass_name}.find(#{params})"
+          when :datamapper, :couchrest then "#{klass_name}.get(#{params})"
+          when :sequel, :ohm then "#{klass_name}[#{params}]"
+          else raise OrmError, "Adapter #{orm} is not yet supported!"
           end
         end
 
-        def build(params=nil)
+        def build(params = nil)
           if params
             "#{klass_name}.new(#{params})"
           else
@@ -116,54 +113,48 @@ module Padrino
         end
 
         def save
-          case orm
-            when :sequel then "(@#{name_singular}.save rescue false)"
-            else "@#{name_singular}.save"
-          end
+          orm == :sequel ? "(@#{name_singular}.save rescue false)" : "@#{name_singular}.save"
         end
 
-        def update_attributes(params=nil)
+        def update_attributes(params = nil)
           case orm
-            when :mongomapper, :mongoid, :couchrest, :dynamoid then "@#{name_singular}.update_attributes(#{params})"
-            when :activerecord, :minirecord, :datamapper, :ohm then "@#{name_singular}.update(#{params})"
-            when :sequel then "@#{name_singular}.modified! && @#{name_singular}.update(#{params})"
-            else raise OrmError, "Adapter #{orm} is not yet supported!"
+          when :mongomapper, :mongoid, :couchrest, :dynamoid then "@#{name_singular}.update_attributes(#{params})"
+          when :activerecord, :minirecord, :datamapper, :ohm then "@#{name_singular}.update(#{params})"
+          when :sequel then "@#{name_singular}.modified! && @#{name_singular}.update(#{params})"
+          else raise OrmError, "Adapter #{orm} is not yet supported!"
           end
         end
 
         def destroy
-          case orm
-            when :ohm then "#{name_singular}.delete"
-            else "#{name_singular}.destroy"
-          end
+          orm == :ohm ? "#{name_singular}.delete" : "#{name_singular}.destroy"
         end
 
-        def find_by_ids(params=nil)
+        def find_by_ids(params = nil)
           case orm
-            when :ohm then "#{klass_name}.fetch(#{params})"
-            when :datamapper then "#{klass_name}.all(:id => #{params})"
-            when :sequel then "#{klass_name}.where(:id => #{params})"
-            when :mongoid then "#{klass_name}.find(#{params})"
-            when :couchrest then "#{klass_name}.all(:keys => #{params})"
-            when :dynamoid then "#{klass_name}.find(#{params})"
-            else find(params)
+          when :ohm then "#{klass_name}.fetch(#{params})"
+          when :datamapper then "#{klass_name}.all(id: #{params})"
+          when :sequel then "#{klass_name}.where(id: #{params})"
+          when :mongoid then "#{klass_name}.find(#{params})"
+          when :couchrest then "#{klass_name}.all(keys: #{params})"
+          when :dynamoid then "#{klass_name}.find(#{params})"
+          else find(params)
           end
         end
 
-        def multiple_destroy(params=nil)
+        def multiple_destroy(params = nil)
           case orm
-            when :ohm then "#{params}.each(&:delete)"
-            when :sequel then  "#{params}.destroy"
-            when :datamapper then "#{params}.destroy"
-            when :couchrest, :mongoid, :mongomapper, :dynamoid then "#{params}.each(&:destroy)"
-            else "#{klass_name}.destroy #{params}"
+          when :ohm then "#{params}.each(&:delete)"
+          when :sequel then "#{params}.destroy"
+          when :datamapper then "#{params}.destroy"
+          when :couchrest, :mongoid, :mongomapper, :dynamoid then "#{params}.each(&:destroy)"
+          else "#{klass_name}.destroy #{params}"
           end
         end
 
         def has_error(field)
           case orm
-            when :datamapper, :ohm, :sequel then "@#{name_singular}.errors.key?(:#{field}) && @#{name_singular}.errors[:#{field}].count > 0"
-            else "@#{name_singular}.errors.include?(:#{field})"
+          when :datamapper, :ohm, :sequel then "@#{name_singular}.errors.key?(:#{field}) && @#{name_singular}.errors[:#{field}].count > 0"
+          else "@#{name_singular}.errors.include?(:#{field})"
           end
         end
       end

data/lib/padrino-admin/generators/templates/account/activerecord.rb.tt

@@ -3,24 +3,24 @@ class <%= @model_name %> < ActiveRecord::Base
 
   # Validations
   validates_presence_of     :email, :role
-  validates_presence_of     :password,                   :if => :password_required
-  validates_presence_of     :password_confirmation,      :if => :password_required
-  validates_length_of       :password, :within => 4..40, :if => :password_required
-  validates_confirmation_of :password,                   :if => :password_required
-  validates_length_of       :email,    :within => 3..100
-  validates_uniqueness_of   :email,    :case_sensitive => false
-  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
-  validates_format_of       :role,     :with => /[A-Za-z]/
+  validates_presence_of     :password,                if: :password_required
+  validates_presence_of     :password_confirmation,   if: :password_required
+  validates_length_of       :password, within: 4..40, if: :password_required
+  validates_confirmation_of :password,                if: :password_required
+  validates_length_of       :email,    within: 3..100
+  validates_uniqueness_of   :email,    case_sensitive: false
+  validates_format_of       :email,    with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     with: /[A-Za-z]/
 
   # Callbacks
-  before_save :encrypt_password, :if => :password_required
+  before_save :encrypt_password, if: :password_required
 
   ##
   # This method is for authentication purpose.
   #
   def self.authenticate(email, password)
-    account = where("lower(email) = lower(?)", email).first if email.present?
-    account && account.has_password?(password) ? account : nil
+    account = where('lower(email) = lower(?)', email).first if email.present?
+    account if account&.has_password?(password)
   end
 
   def has_password?(password)

data/lib/padrino-admin/generators/templates/account/couchrest.rb.tt

@@ -12,24 +12,24 @@ class <%= @model_name %> < CouchRest::Model::Base
 
   # Validations
   validates_presence_of     :email, :role
-  validates_presence_of     :password,                   :if => :password_required
-  validates_presence_of     :password_confirmation,      :if => :password_required
-  validates_length_of       :password, :within => 4..40, :if => :password_required
-  validates_confirmation_of :password,                   :if => :password_required
-  validates_length_of       :email,    :within => 3..100
-  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
-  validates_format_of       :role,     :with => /[A-Za-z]/
+  validates_presence_of     :password,                if: :password_required
+  validates_presence_of     :password_confirmation,   if: :password_required
+  validates_length_of       :password, within: 4..40, if: :password_required
+  validates_confirmation_of :password,                if: :password_required
+  validates_length_of       :email,    within: 3..100
+  validates_format_of       :email,    with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     with: /[A-Za-z]/
   validate                  :unique_email_validator
 
   # Callbacks
-  after_validation :encrypt_password, :if => :password_required
+  after_validation :encrypt_password, if: :password_required
 
   ##
   # This method is for authentication purpose.
   #
   def self.authenticate(email, password)
     account = find_by_email(email)
-    account if account && account.has_password?(password)
+    account if account&.has_password?(password)
   end
 
   def has_password?(password)
@@ -62,6 +62,6 @@ class <%= @model_name %> < CouchRest::Model::Base
     # Account with same email in database is this account.
     return if has_key?('_id') && self['_id'] == account['_id']
 
-    errors.add(:email, "is not unique")
+    errors.add(:email, 'is not unique')
   end
 end

data/lib/padrino-admin/generators/templates/account/datamapper.rb.tt

@@ -8,19 +8,19 @@ class <%= @model_name %>
   property :name,             String
   property :surname,          String
   property :email,            String
-  property :crypted_password, String, :length => 70
+  property :crypted_password, String, length: 70
   property :role,             String
 
   # Validations
   validates_presence_of      :email, :role
-  validates_presence_of      :password,                          :if => :password_required
-  validates_presence_of      :password_confirmation,             :if => :password_required
-  validates_length_of        :password, :min => 4, :max => 40,   :if => :password_required
-  validates_confirmation_of  :password,                          :if => :password_required
-  validates_length_of        :email,    :min => 3, :max => 100
-  validates_uniqueness_of    :email,    :case_sensitive => false
-  validates_format_of        :email,    :with => :email_address
-  validates_format_of        :role,     :with => /[A-Za-z]/
+  validates_presence_of      :password,                    if: :password_required
+  validates_presence_of      :password_confirmation,       if: :password_required
+  validates_length_of        :password, min: 4, max: 40,   if: :password_required
+  validates_confirmation_of  :password,                    if: :password_required
+  validates_length_of        :email,    min: 3, max: 100
+  validates_uniqueness_of    :email,    case_sensitive: false
+  validates_format_of        :email,    with: :email_address
+  validates_format_of        :role,     with: /[A-Za-z]/
 
   # Callbacks
   before :save, :encrypt_password
@@ -29,8 +29,8 @@ class <%= @model_name %>
   # This method is for authentication purpose.
   #
   def self.authenticate(email, password)
-    account = first(:conditions => ["lower(email) = lower(?)", email]) if email.present?
-    account && account.has_password?(password) ? account : nil
+    account = first(conditions: ['lower(email) = lower(?)', email]) if email.present?
+    account if account&.has_password?(password)
   end
 
   ##

data/lib/padrino-admin/generators/templates/account/dynamoid.rb.tt

@@ -11,23 +11,23 @@ class <%= @model_name %>
 
   # Validations
   validates_presence_of     :email, :role
-  validates_presence_of     :password,                   :if => :password_required
-  validates_presence_of     :password_confirmation,      :if => :password_required
-  validates_length_of       :password, :within => 4..40, :if => :password_required
-  validates_confirmation_of :password,                   :if => :password_required
-  validates_length_of       :email,    :within => 3..100
-  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
-  validates_format_of       :role,     :with => /[A-Za-z]/
+  validates_presence_of     :password,                if: :password_required
+  validates_presence_of     :password_confirmation,   if: :password_required
+  validates_length_of       :password, within: 4..40, if: :password_required
+  validates_confirmation_of :password,                if: :password_required
+  validates_length_of       :email,    within: 3..100
+  validates_format_of       :email,    with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     with: /[A-Za-z]/
 
   # Callbacks
-  before_save :encrypt_password, :if => :password_required
+  before_save :encrypt_password, if: :password_required
 
   ##
   # This method is for authentication purpose.
   #
   def self.authenticate(email, password)
     account = find_by_email(email) if email.present?
-    account && account.has_password?(password) ? account : nil
+    account if account&.has_password?(password)
   end
 
   ##

data/lib/padrino-admin/generators/templates/account/minirecord.rb.tt

@@ -6,24 +6,24 @@ class <%= @model_name %> < ActiveRecord::Base
 
   # Validations
   validates_presence_of     :email, :role
-  validates_presence_of     :password,                   :if => :password_required
-  validates_presence_of     :password_confirmation,      :if => :password_required
-  validates_length_of       :password, :within => 4..40, :if => :password_required
-  validates_confirmation_of :password,                   :if => :password_required
-  validates_length_of       :email,    :within => 3..100
-  validates_uniqueness_of   :email,    :case_sensitive => false
-  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
-  validates_format_of       :role,     :with => /[A-Za-z]/
+  validates_presence_of     :password,                if: :password_required
+  validates_presence_of     :password_confirmation,   if: :password_required
+  validates_length_of       :password, within: 4..40, if: :password_required
+  validates_confirmation_of :password,                if: :password_required
+  validates_length_of       :email,    within: 3..100
+  validates_uniqueness_of   :email,    case_sensitive: false
+  validates_format_of       :email,    with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     with: /[A-Za-z]/
 
   # Callbacks
-  before_save :encrypt_password, :if => :password_required
+  before_save :encrypt_password, if: :password_required
 
   ##
   # This method is for authentication purpose.
   #
   def self.authenticate(email, password)
-    account = where("lower(email) = lower(?)", email).first if email.present?
-    account && account.has_password?(password) ? account : nil
+    account = where('lower(email) = lower(?)', email).first if email.present?
+    account if account&.has_password?(password)
   end
 
   def has_password?(password)

data/lib/padrino-admin/generators/templates/account/mongoid.rb.tt

@@ -3,32 +3,32 @@ class <%= @model_name %>
   attr_accessor :password, :password_confirmation
 
   # Fields
-  field :name,             :type => String
-  field :surname,          :type => String
-  field :email,            :type => String
-  field :crypted_password, :type => String
-  field :role,             :type => String
+  field :name,             type: String
+  field :surname,          type: String
+  field :email,            type: String
+  field :crypted_password, type: String
+  field :role,             type: String
 
   # Validations
   validates_presence_of     :email, :role
-  validates_presence_of     :password,                   :if => :password_required
-  validates_presence_of     :password_confirmation,      :if => :password_required
-  validates_length_of       :password, :within => 4..40, :if => :password_required
-  validates_confirmation_of :password,                   :if => :password_required
-  validates_length_of       :email,    :within => 3..100
-  validates_uniqueness_of   :email,    :case_sensitive => false
-  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
-  validates_format_of       :role,     :with => /[A-Za-z]/
+  validates_presence_of     :password,                if: :password_required
+  validates_presence_of     :password_confirmation,   if: :password_required
+  validates_length_of       :password, within: 4..40, if: :password_required
+  validates_confirmation_of :password,                if: :password_required
+  validates_length_of       :email,    within: 3..100
+  validates_uniqueness_of   :email,    case_sensitive: false
+  validates_format_of       :email,    with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     with: /[A-Za-z]/
 
   # Callbacks
-  before_save :encrypt_password, :if => :password_required
+  before_save :encrypt_password, if: :password_required
 
   ##
   # This method is for authentication purpose.
   #
   def self.authenticate(email, password)
-    account = where(:email => /#{Object::Regexp.escape(email)}/i).first if email.present?
-    account && account.has_password?(password) ? account : nil
+    account = where(email: /#{Object::Regexp.escape(email)}/i).first if email.present?
+    account if account&.has_password?(password)
   end
 
   ##

data/lib/padrino-admin/generators/templates/account/mongomapper.rb.tt

@@ -11,24 +11,24 @@ class <%= @model_name %>
 
   # Validations
   validates_presence_of     :email, :role
-  validates_presence_of     :password,                   :if => :password_required
-  validates_presence_of     :password_confirmation,      :if => :password_required
-  validates_length_of       :password, :within => 4..40, :if => :password_required
-  validates_confirmation_of :password,                   :if => :password_required
-  validates_length_of       :email,    :within => 3..100
-  validates_uniqueness_of   :email,    :case_sensitive => false
-  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
-  validates_format_of       :role,     :with => /[A-Za-z]/
+  validates_presence_of     :password,                if: :password_required
+  validates_presence_of     :password_confirmation,   if: :password_required
+  validates_length_of       :password, within: 4..40, if: :password_required
+  validates_confirmation_of :password,                if: :password_required
+  validates_length_of       :email,    within: 3..100
+  validates_uniqueness_of   :email,    case_sensitive: false
+  validates_format_of       :email,    with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     with: /[A-Za-z]/
 
   # Callbacks
-  before_save :encrypt_password, :if => :password_required
+  before_save :encrypt_password, if: :password_required
 
   ##
   # This method is for authentication purpose.
   #
   def self.authenticate(email, password)
-    account = first(:email => /#{Regexp.escape(email)}/i) if email.present?
-    account && account.has_password?(password) ? account : nil
+    account = first(email: /#{Regexp.escape(email)}/i) if email.present?
+    account if account&.has_password?(password)
   end
 
   def has_password?(password)

data/lib/padrino-admin/generators/templates/account/ohm.rb.tt

@@ -36,7 +36,7 @@ class Account < Ohm::Model
   #
   def self.authenticate(email, password)
     account = with(:email, email) if email.present?
-    account && account.has_password?(password) ? account : nil
+    account if account&.has_password?(password)
   end
 
   ##
@@ -50,7 +50,7 @@ class Account < Ohm::Model
   # This method is used by Admin Sessions Controller for login bypass.
   #
   def self.first
-    first_id = key[:all].sort(:order => "asc", :limit => [0,1]).first
+    first_id = key[:all].sort(order: "asc", limit: [0, 1]).first
     self[first_id] if first_id
   end
 

data/lib/padrino-admin/generators/templates/account/seeds.rb.tt

@@ -6,11 +6,11 @@
 #   shell.say name
 #
 email     = shell.ask "Which email do you want use for logging into admin?"
-password  = shell.ask "Tell me the password to use:", :echo => false
+password  = shell.ask "Tell me the password to use:", echo: false
 
 shell.say ""
 
-account = <%= @model_name %>.new(:email => email, :name => "Foo", :surname => "Bar", :password => password, :password_confirmation => password, :role => "admin")
+account = <%= @model_name %>.new(email: email, name: "Foo", surname: "Bar", password: password, password_confirmation: password, role: "admin")
 
 if account.valid?
   account.save

data/lib/padrino-admin/generators/templates/app/controllers/base.rb.tt

@@ -1,5 +1,5 @@
 <%= @app_name %>::<%= @admin_name %>.controllers :base do
-  get :index, :map => "/" do
-    render "base/index"
+  get :index, map: '/' do
+    render 'base/index'
   end
 end

data/lib/padrino-admin/generators/templates/app/controllers/sessions.rb.tt

@@ -1,6 +1,6 @@
 <%= @app_name %>::<%= @admin_name %>.controllers :sessions do
   get :new do
-    render "/sessions/new", nil, :layout => false
+    render '/sessions/new', nil, layout: false
   end
 
   post :create do
@@ -18,7 +18,7 @@
     else
       params[:email] = h(params[:email])
       flash.now[:error] = pat('login.error')
-      render "/sessions/new", nil, :layout => false
+      render '/sessions/new', nil, layout: false
     end
   end
 

data/lib/padrino-admin/generators/templates/app.rb.tt

@@ -14,10 +14,10 @@ module <%= @app_name %>
     # set :dump_errors, true          # Exception backtraces are written to STDERR (default for production/development)
     # set :show_exceptions, true      # Shows a stack trace in browser (default for development)
     # set :logging, true              # Logging in STDOUT for development and file for production (default only for development)
-    # set :public_folder, "foo/bar"   # Location for static assets (default root/public)
+    # set :public_folder, 'foo/bar'   # Location for static assets (default root/public)
     # set :reload, false              # Reload application files (default in development)
-    # set :default_builder, "foo"     # Set a custom form builder (default 'StandardFormBuilder')
-    # set :locale_path, "bar"         # Set path for I18n translations (default your_app/locales)
+    # set :default_builder, 'foo'     # Set a custom form builder (default 'StandardFormBuilder')
+    # set :locale_path, 'bar'         # Set path for I18n translations (default your_app/locales)
     # disable :sessions               # Disabled sessions by default (enable if needed)
     # disable :flash                  # Disables sinatra-flash (enabled by default if Sinatra::Flash is defined)
     # layout  :my_layout              # Layout can be in views/layouts/foo.ext or views/foo.ext (default :application)
@@ -37,9 +37,9 @@ module <%= @app_name %>
     access_control.roles_for :admin do |role|
     end
 
-    # Custom error management 
-    error(403) { @title = "Error 403"; render('errors/403', :layout => :error) }
-    error(404) { @title = "Error 404"; render('errors/404', :layout => :error) }
-    error(500) { @title = "Error 500"; render('errors/500', :layout => :error) }
+    # Custom error management
+    error(403) { @title = 'Error 403'; render('errors/403', layout: :error) }
+    error(404) { @title = 'Error 404'; render('errors/404', layout: :error) }
+    error(500) { @title = 'Error 500'; render('errors/500', layout: :error) }
   end
 end

data/lib/padrino-admin/generators/templates/erb/app/layouts/application.erb.tt

@@ -12,15 +12,16 @@
     <link href='http://fonts.googleapis.com/css?family=Varela' rel=stylesheet />
     <%%= stylesheet_link_tag 'bootstrap', 'application' %>
   </head>
+
   <body>
     <div class="navbar navbar-fixed-top">
       <div class=navbar-inner>
         <div class=container>
-          <%%= link_to 'Padrino', url(:base, :index), :class => 'navbar-brand', :title => 'Padrino Admin' %>
+          <%%= link_to 'Padrino', url(:base, :index), class: 'navbar-brand', title: 'Padrino Admin' %>
           <ul class="nav navbar-nav pull-right">
-            <li class=navbar-edit-account><%%= link_to tag_icon(:user), url(:<%= @model_plural %>, :edit, :id => current_account.id), :title => pat(:profile), :class => 'navbar-nav-link' %></li>
+            <li class=navbar-edit-account><%%= link_to tag_icon(:user), url(:<%= @model_plural %>, :edit, id: current_account.id), title: pat(:profile), class: 'navbar-nav-link' %></li>
             <li class=navbar-logout>
-              <%%= button_to(:logout, url(:sessions, :destroy), :method => :delete, :class => 'navbar-nav-form', :submit_options => { :type => :submit, :title => pat(:logout), :class => 'navbar-nav-form-link' }) { tag_icon(:'power-off') } %>
+              <%%= button_to(:logout, url(:sessions, :destroy), method: :delete, class: 'navbar-nav-form', submit_options: { type: :submit, title: pat(:logout), class: 'navbar-nav-form-link' }) { tag_icon('power-off') } %>
             </li>
           </ul>
 
@@ -41,7 +42,7 @@
 
     <div class='container main'>
       <div class='main-wrapper'>
-        <%%= {:error => 'danger', :warning => 'warning', :success => 'success', :notice => 'info'}.map { |type, class_name| flash_tag(type, :class => "alert alert-#{class_name} fade in", :bootstrap => true) }.join.html_safe %>
+        <%%= { error: 'danger', warning: 'warning', success: 'success', notice: 'info' }.map { |type, class_name| flash_tag(type, class: "alert alert-#{class_name} fade in", bootstrap: true) }.join.html_safe %>
         <div class='row'><%%= yield %></div>
         <div class='main-wrapper-push'></div>
       </div>
@@ -51,14 +52,14 @@
       <div class='footer-wrapper container'>
         <p class='pull-left'>Copyright &copy; <%= Time.now.year %> Your Site - Powered by Padrino v.<%= Padrino.version %></p>
         <ul class='pull-right footer-links'>
-          <li><%%= link_to tag_icon(:home, 'web'), 'http://www.padrinorb.com', :target => :_blank, :class => 'footer-links-link' %></li>
-          <li><%%= link_to tag_icon(:heart, 'blog'), 'http://www.padrinorb.com/blog', :target => :_blank, :class => 'footer-links-link' %></li>
-          <li><%%= link_to tag_icon(:github, 'code'), 'https://github.com/padrino/padrino-framework', :target => :_blank, :class => 'footer-links-link' %></li>
-          <li><%%= link_to tag_icon(:twitter, 'twitter'), 'http://twitter.com/padrinorb', :target => :_blank, :class => 'footer-links-link' %></li>
+          <li><%%= link_to tag_icon(:home, 'web'), 'http://www.padrinorb.com', target: :_blank, class: 'footer-links-link' %></li>
+          <li><%%= link_to tag_icon(:heart, 'blog'), 'http://www.padrinorb.com/blog', target: :_blank, class: 'footer-links-link' %></li>
+          <li><%%= link_to tag_icon(:github, 'code'), 'https://github.com/padrino/padrino-framework', target: :_blank, class: 'footer-links-link' %></li>
+          <li><%%= link_to tag_icon(:twitter, 'twitter'), 'http://twitter.com/padrinorb', target: :_blank, class: 'footer-links-link' %></li>
         </ul>
       </div>
     </footer>
 
-    <%%= javascript_include_tag 'jquery-1.11.0.min', (Padrino.env == :production ? 'bootstrap/bootstrap.min' : %w[bootstrap/affix bootstrap/alert bootstrap/button bootstrap/carousel bootstrap/collapse bootstrap/dropdown  bootstrap/tooltip bootstrap/transition  bootstrap/modal bootstrap/popover bootstrap/scrollspy bootstrap/tab]), :application %>
+    <%%= javascript_include_tag 'jquery-1.11.0.min', (Padrino.env == :production ? 'bootstrap/bootstrap.min' : %w[bootstrap/affix bootstrap/alert bootstrap/button bootstrap/carousel bootstrap/collapse bootstrap/dropdown bootstrap/tooltip bootstrap/transition bootstrap/modal bootstrap/popover bootstrap/scrollspy bootstrap/tab]), :application %>
   </body>
 </html>