padrino-gen 0.16.0.pre4 → 0.16.0

data/lib/padrino-gen/generators/components/orms/minirecord.rb

@@ -1,111 +1,111 @@
-MR = (<<-MR) unless defined?(MR)
-##
-# You can use other adapters like:
-#
-#   ActiveRecord::Base.configurations[:development] = {
-#     :adapter   => 'mysql2',
-#     :encoding  => 'utf8',
-#     :reconnect => true,
-#     :database  => 'your_database',
-#     :pool      => 5,
-#     :username  => 'root',
-#     :password  => '',
-#     :host      => 'localhost',
-#     :socket    => '/tmp/mysql.sock'
-#   }
-#
-ActiveRecord::Base.configurations[:development] = {
-!DB_DEVELOPMENT!
-}
-
-ActiveRecord::Base.configurations[:production] = {
-!DB_PRODUCTION!
-}
-
-ActiveRecord::Base.configurations[:test] = {
-!DB_TEST!
-}
-
-# Setup our logger.
-ActiveRecord::Base.logger = logger
-
-if ActiveRecord::VERSION::MAJOR.to_i < 4
-  # Raise exception on mass assignment protection for Active Record models.
-  ActiveRecord::Base.mass_assignment_sanitizer = :strict
-
-  # Log the query plan for queries taking more than this (works
-  # with SQLite, MySQL, and PostgreSQL).
-  ActiveRecord::Base.auto_explain_threshold_in_seconds = 0.5
-end
+MR = <<~MR unless defined?(MR)
+  ##
+  # You can use other adapters like:
+  #
+  #   ActiveRecord::Base.configurations[:development] = {
+  #     adapter:   'mysql2',
+  #     encoding:  'utf8',
+  #     reconnect: true,
+  #     database:  'your_database',
+  #     pool:      5,
+  #     username:  'root',
+  #     password:  '',
+  #     host:      'localhost',
+  #     socket:    '/tmp/mysql.sock'
+  #   }
+  #
+  ActiveRecord::Base.configurations[:development] = {
+  !DB_DEVELOPMENT!
+  }
+
+  ActiveRecord::Base.configurations[:production] = {
+  !DB_PRODUCTION!
+  }
+
+  ActiveRecord::Base.configurations[:test] = {
+  !DB_TEST!
+  }
+
+  # Setup our logger.
+  ActiveRecord::Base.logger = logger
+
+  if ActiveRecord::VERSION::MAJOR.to_i < 4
+    # Raise exception on mass assignment protection for Active Record models.
+    ActiveRecord::Base.mass_assignment_sanitizer = :strict
+
+    # Log the query plan for queries taking more than this (works
+    # with SQLite, MySQL, and PostgreSQL).
+    ActiveRecord::Base.auto_explain_threshold_in_seconds = 0.5
+  end
 
-# Doesn't include Active Record class name as root for JSON serialized output.
-ActiveRecord::Base.include_root_in_json = false
+  # Doesn't include Active Record class name as root for JSON serialized output.
+  ActiveRecord::Base.include_root_in_json = false
 
-# Store the full class name (including module namespace) in STI type column.
-ActiveRecord::Base.store_full_sti_class = true
+  # Store the full class name (including module namespace) in STI type column.
+  ActiveRecord::Base.store_full_sti_class = true
 
-# Use ISO 8601 format for JSON serialized times and dates.
-ActiveSupport.use_standard_json_time_format = true
+  # Use ISO 8601 format for JSON serialized times and dates.
+  ActiveSupport.use_standard_json_time_format = true
 
-# Don't escape HTML entities in JSON, leave that for the #json_escape helper
-# if you're including raw JSON in an HTML page.
-ActiveSupport.escape_html_entities_in_json = false
+  # Don't escape HTML entities in JSON, leave that for the #json_escape helper
+  # if you're including raw JSON in an HTML page.
+  ActiveSupport.escape_html_entities_in_json = false
 
-# Now we can establish connection with our db.
-ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[Padrino.env])
+  # Now we can establish connection with our db.
+  ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[Padrino.env])
 
-# Timestamps are in the utc by default.
-ActiveRecord::Base.default_timezone = :utc
+  # Timestamps are in the utc by default.
+  ActiveRecord::Base.default_timezone = :utc
 MR
 
-MYSQL = (<<-MYSQL) unless defined?(MYSQL)
-  :adapter   => 'mysql',
-  :encoding  => 'utf8',
-  :reconnect => true,
-  :database  => !DB_NAME!,
-  :pool      => 5,
-  :username  => 'root',
-  :password  => '',
-  :host      => 'localhost',
-  :socket    => '/tmp/mysql.sock'
+MYSQL = <<-MYSQL unless defined?(MYSQL)
+  adapter:   'mysql',
+  encoding:  'utf8',
+  reconnect: true,
+  database:  !DB_NAME!,
+  pool:      5,
+  username:  'root',
+  password:  '',
+  host:      'localhost',
+  socket:    '/tmp/mysql.sock'
 MYSQL
 
-MYSQL2 = (<<-MYSQL2) unless defined?(MYSQL2)
-  :adapter   => 'mysql2',
-  :encoding  => 'utf8',
-  :reconnect => true,
-  :database  => !DB_NAME!,
-  :pool      => 5,
-  :username  => 'root',
-  :password  => '',
-  :host      => 'localhost',
-  :socket    => '/tmp/mysql.sock'
+MYSQL2 = <<-MYSQL2 unless defined?(MYSQL2)
+  adapter:   'mysql2',
+  encoding:  'utf8',
+  reconnect: true,
+  database:  !DB_NAME!,
+  pool:      5,
+  username:  'root',
+  password:  '',
+  host:      'localhost',
+  socket:    '/tmp/mysql.sock'
 MYSQL2
 
-POSTGRES = (<<-POSTGRES) unless defined?(POSTGRES)
-  :adapter   => 'postgresql',
-  :database  => !DB_NAME!,
-  :username  => 'root',
-  :password  => '',
-  :host      => 'localhost',
-  :port      => 5432
+POSTGRES = <<-POSTGRES unless defined?(POSTGRES)
+  adapter:   'postgresql',
+  database:  !DB_NAME!,
+  username:  'root',
+  password:  '',
+  host:      'localhost',
+  port:      5432
 POSTGRES
 
-SQLITE = (<<-SQLITE) unless defined?(SQLITE)
-  :adapter => 'sqlite3',
-  :database => !DB_NAME!
+SQLITE = <<-SQLITE unless defined?(SQLITE)
+  adapter: 'sqlite3',
+  database: !DB_NAME!
 SQLITE
 
-CONNECTION_POOL_MIDDLEWARE = <<-MIDDLEWARE
-class ConnectionPoolManagement
-  def initialize(app)
-    @app = app
-  end
+CONNECTION_POOL_MIDDLEWARE = <<~MIDDLEWARE
+  class ConnectionPoolManagement
+    def initialize(app)
+      @app = app
+    end
 
-  def call(env)
-    ActiveRecord::Base.connection_pool.with_connection { @app.call(env) }
+    def call(env)
+      ActiveRecord::Base.connection_pool.with_connection { @app.call(env) }
+    end
   end
-end
 MIDDLEWARE
 
 def setup_orm
@@ -115,31 +115,31 @@ def setup_orm
   begin
     case adapter ||= options[:adapter]
     when 'mysql-gem'
-      ar.gsub! /!DB_DEVELOPMENT!/, MYSQL.gsub(/!DB_NAME!/,"'#{db}_development'")
-      ar.gsub! /!DB_PRODUCTION!/, MYSQL.gsub(/!DB_NAME!/,"'#{db}_production'")
-      ar.gsub! /!DB_TEST!/, MYSQL.gsub(/!DB_NAME!/,"'#{db}_test'")
-      require_dependencies 'mysql', :version => "~> 2.8.1"
+      ar.gsub!(/!DB_DEVELOPMENT!/, MYSQL.gsub(/!DB_NAME!/, "'#{db}_development'"))
+      ar.gsub!(/!DB_PRODUCTION!/, MYSQL.gsub(/!DB_NAME!/, "'#{db}_production'"))
+      ar.gsub!(/!DB_TEST!/, MYSQL.gsub(/!DB_NAME!/, "'#{db}_test'"))
+      require_dependencies 'mysql', version: '~> 2.8.1'
     when 'mysql', 'mysql2'
-      ar.gsub! /!DB_DEVELOPMENT!/, MYSQL2.gsub(/!DB_NAME!/,"'#{db}_development'")
-      ar.gsub! /!DB_PRODUCTION!/, MYSQL2.gsub(/!DB_NAME!/,"'#{db}_production'")
-      ar.gsub! /!DB_TEST!/, MYSQL2.gsub(/!DB_NAME!/,"'#{db}_test'")
+      ar.gsub!(/!DB_DEVELOPMENT!/, MYSQL2.gsub(/!DB_NAME!/, "'#{db}_development'"))
+      ar.gsub!(/!DB_PRODUCTION!/, MYSQL2.gsub(/!DB_NAME!/, "'#{db}_production'"))
+      ar.gsub!(/!DB_TEST!/, MYSQL2.gsub(/!DB_NAME!/, "'#{db}_test'"))
       require_dependencies 'mysql2'
     when 'postgres'
-      ar.gsub! /!DB_DEVELOPMENT!/, POSTGRES.gsub(/!DB_NAME!/,"'#{db}_development'")
-      ar.gsub! /!DB_PRODUCTION!/, POSTGRES.gsub(/!DB_NAME!/,"'#{db}_production'")
-      ar.gsub! /!DB_TEST!/, POSTGRES.gsub(/!DB_NAME!/,"'#{db}_test'")
+      ar.gsub!(/!DB_DEVELOPMENT!/, POSTGRES.gsub(/!DB_NAME!/, "'#{db}_development'"))
+      ar.gsub!(/!DB_PRODUCTION!/, POSTGRES.gsub(/!DB_NAME!/, "'#{db}_production'"))
+      ar.gsub!(/!DB_TEST!/, POSTGRES.gsub(/!DB_NAME!/, "'#{db}_test'"))
       require_dependencies 'pg'
     when 'sqlite'
-      ar.gsub! /!DB_DEVELOPMENT!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', '#{db}_development.db')")
-      ar.gsub! /!DB_PRODUCTION!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', '#{db}_production.db')")
-      ar.gsub! /!DB_TEST!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', '#{db}_test.db')")
+      ar.gsub!(/!DB_DEVELOPMENT!/, SQLITE.gsub(/!DB_NAME!/, "Padrino.root('db', '#{db}_development.db')"))
+      ar.gsub!(/!DB_PRODUCTION!/, SQLITE.gsub(/!DB_NAME!/, "Padrino.root('db', '#{db}_production.db')"))
+      ar.gsub!(/!DB_TEST!/, SQLITE.gsub(/!DB_NAME!/, "Padrino.root('db', '#{db}_test.db')"))
       require_dependencies 'sqlite3'
     else
       say "Failed to generate `config/database.rb` for ORM adapter `#{options[:adapter]}`", :red
-      fail ArgumentError
+      raise ArgumentError
     end
   rescue ArgumentError
-    adapter = ask("Please, choose a proper adapter:", :limited_to => %w[mysql mysql2 mysql-gem postgres sqlite])
+    adapter = ask('Please, choose a proper adapter:', limited_to: %w[mysql mysql2 mysql-gem postgres sqlite])
     retry
   end
 
@@ -149,18 +149,18 @@ def setup_orm
   middleware :connection_pool_management, CONNECTION_POOL_MIDDLEWARE
 end
 
-MR_MODEL = (<<-MODEL) unless defined?(MR_MODEL)
-class !NAME! < ActiveRecord::Base
-  # Fields
-  !FIELDS!
-end
+MR_MODEL = <<~MODEL unless defined?(MR_MODEL)
+  class !NAME! < ActiveRecord::Base
+    # Fields
+    !FIELDS!
+  end
 MODEL
 
-# options => { :fields => ["title:string", "body:string"], :app => 'app' }
-def create_model_file(name, options={})
+# options => { fields: ['title:string', 'body:string'], app: 'app' }
+def create_model_file(name, options = {})
   model_path = destination_root(options[:app], 'models', "#{name.to_s.underscore}.rb")
-  field_tuples = options[:fields].map { |value| value.split(":") }
-  column_declarations = field_tuples.map { |field, kind| "field :#{field}, :as => :#{kind}" }.join("\n  ")
+  field_tuples = options[:fields].map { |value| value.split(':') }
+  column_declarations = field_tuples.map { |field, kind| "field :#{field}, as: :#{kind}" }.join("\n  ")
   model_contents = MR_MODEL.gsub(/!NAME!/, name.to_s.underscore.camelize)
   model_contents.gsub!(/!FIELDS!/, column_declarations)
   create_file(model_path, model_contents)

data/lib/padrino-gen/generators/components/orms/mongoid.rb

@@ -1,85 +1,85 @@
-MONGOID = (<<-MONGO) unless defined?(MONGOID)
-# Connection.new takes host and port.
+MONGOID = <<~MONGO unless defined?(MONGOID)
+  # Connection.new takes host and port.
 
-host = 'localhost'
-port = 27017
+  host = 'localhost'
+  port = 27017
 
-database_name = case Padrino.env
-  when :development then '!NAME!_development'
-  when :production  then '!NAME!_production'
-  when :test        then '!NAME!_test'
-end
+  database_name = case Padrino.env
+    when :development then '!NAME!_development'
+    when :production  then '!NAME!_production'
+    when :test        then '!NAME!_test'
+  end
 
-# Use MONGO_URI if it's set as an environmental variable.
-database_settings = if ENV['MONGO_URI']
-  {default: {uri: ENV['MONGO_URI'] }}
-else
-  {default: {hosts: ["#\{host\}:#\{port\}"], database: database_name}}
-end
+  # Use MONGO_URI if it's set as an environmental variable.
+  database_settings = if ENV['MONGO_URI']
+    { default: { uri: ENV['MONGO_URI'] } }
+  else
+    { default: { hosts: ["#\{host\}:#\{port\}"], database: database_name} }
+  end
 
-case Mongoid::VERSION
-when /^(3|4)/
-  Mongoid::Config.sessions = database_settings
-else
-  Mongoid::Config.load_configuration :clients => database_settings
-end
+  case Mongoid::VERSION
+  when /^(3|4)/
+    Mongoid::Config.sessions = database_settings
+  else
+    Mongoid::Config.load_configuration clients: database_settings
+  end
 
-# If you want to use a YML file for config, use this instead:
-#
-#   Mongoid.load!(File.join(Padrino.root, 'config', 'database.yml'), Padrino.env)
-#
-# And add a config/database.yml file like this:
-#   development:
-#     clients: #Replace clients with sessions to work with Mongoid version 3.x or 4.x
-#       default:
-#         database: !NAME!_development
-#         hosts:
-#           - localhost:27017
-#
-#   production:
-#     clients: #Replace clients with sessions to work with Mongoid version 3.x or 4.x
-#       default:
-#         database: !NAME!_production
-#         hosts:
-#           - localhost:27017
-#
-#   test:
-#     clients: #Replace clients with sessions to work with Mongoid version 3.x or 4.x
-#       default:
-#         database: !NAME!_test
-#         hosts:
-#           - localhost:27017
-#
-#
-# More installation and setup notes are on https://docs.mongodb.org/ecosystem/tutorial/mongoid-installation/
+  # If you want to use a YML file for config, use this instead:
+  #
+  #   Mongoid.load!(File.join(Padrino.root, 'config', 'database.yml'), Padrino.env)
+  #
+  # And add a config/database.yml file like this:
+  #   development:
+  #     clients: #Replace clients with sessions to work with Mongoid version 3.x or 4.x
+  #       default:
+  #         database: !NAME!_development
+  #         hosts:
+  #           - localhost:27017
+  #
+  #   production:
+  #     clients: #Replace clients with sessions to work with Mongoid version 3.x or 4.x
+  #       default:
+  #         database: !NAME!_production
+  #         hosts:
+  #           - localhost:27017
+  #
+  #   test:
+  #     clients: #Replace clients with sessions to work with Mongoid version 3.x or 4.x
+  #       default:
+  #         database: !NAME!_test
+  #         hosts:
+  #           - localhost:27017
+  #
+  #
+  # More installation and setup notes are on https://docs.mongodb.org/ecosystem/tutorial/mongoid-installation/
 MONGO
 
 def setup_orm
-  require_dependencies 'mongoid', :version => '>= 3.0.0'
+  require_dependencies 'mongoid', version: '>= 3.0.0'
   create_file('config/database.rb', MONGOID.gsub(/!NAME!/, @project_name.underscore))
 end
 
-MONGOID_MODEL = (<<-MODEL) unless defined?(MONGOID_MODEL)
-class !NAME!
-  include Mongoid::Document
-  include Mongoid::Timestamps # adds created_at and updated_at fields
+MONGOID_MODEL = <<~MODEL unless defined?(MONGOID_MODEL)
+  class !NAME!
+    include Mongoid::Document
+    include Mongoid::Timestamps # adds created_at and updated_at fields
 
-  # field <name>, :type => <type>, :default => <value>
-  !FIELDS!
+    # field <name>, type: <type>, default: <value>
+    !FIELDS!
 
-  # You can define indexes on documents using the index macro:
-  # index :field <, :unique => true>
+    # You can define indexes on documents using the index macro:
+    # index :field <, unique: true>
 
-  # You can create a composite key in mongoid to replace the default id using the key macro:
-  # key :field <, :another_field, :one_more ....>
-end
+    # You can create a composite key in mongoid to replace the default id using the key macro:
+    # key :field <, :another_field, :one_more ....>
+  end
 MODEL
 
-# options => { :fields => ["title:string", "body:string"], :app => 'app' }
-def create_model_file(name, options={})
+# options => { fields: ['title:string', 'body:string'], app: 'app' }
+def create_model_file(name, options = {})
   model_path = destination_root(options[:app], 'models', "#{name.to_s.underscore}.rb")
-  field_tuples = options[:fields].map { |value| value.split(":") }
-  column_declarations = field_tuples.map { |field, kind| "field :#{field}, :type => #{kind.underscore.camelize}" }.join("\n  ")
+  field_tuples = options[:fields].map { |value| value.split(':') }
+  column_declarations = field_tuples.map { |field, kind| "field :#{field}, type: #{kind.underscore.camelize}" }.join("\n  ")
   model_contents = MONGOID_MODEL.gsub(/!NAME!/, name.to_s.underscore.camelize)
   model_contents.gsub!(/!FIELDS!/, column_declarations)
   create_file(model_path, model_contents)

data/lib/padrino-gen/generators/components/orms/mongomapper.rb

@@ -1,34 +1,34 @@
-MONGO = (<<-MONGO) unless defined?(MONGO)
-MongoMapper.connection = Mongo::Connection.new('localhost', nil, :logger => logger)
+MONGO = <<~MONGO unless defined?(MONGO)
+  MongoMapper.connection = Mongo::Connection.new('localhost', nil, logger: logger)
 
-case Padrino.env
-  when :development then MongoMapper.database = '!NAME!_development'
-  when :production  then MongoMapper.database = '!NAME!_production'
-  when :test        then MongoMapper.database = '!NAME!_test'
-end
+  case Padrino.env
+    when :development then MongoMapper.database = '!NAME!_development'
+    when :production  then MongoMapper.database = '!NAME!_production'
+    when :test        then MongoMapper.database = '!NAME!_test'
+  end
 MONGO
 
 def setup_orm
   require_dependencies 'mongo_mapper'
-  require_dependencies 'bson_ext', :require => 'mongo'
-  require_dependencies 'activemodel', :version => '< 5'
-  create_file("config/database.rb", MONGO.gsub(/!NAME!/, @project_name.underscore))
+  require_dependencies 'bson_ext', require: 'mongo'
+  require_dependencies 'activemodel', version: '< 5'
+  create_file('config/database.rb', MONGO.gsub(/!NAME!/, @project_name.underscore))
 end
 
-MM_MODEL = (<<-MODEL) unless defined?(MM_MODEL)
-class !NAME!
-  include MongoMapper::Document
+MM_MODEL = <<~MODEL unless defined?(MM_MODEL)
+  class !NAME!
+    include MongoMapper::Document
 
-  # key <name>, <type>
-  !FIELDS!
-  timestamps!
-end
+    # key <name>, <type>
+    !FIELDS!
+    timestamps!
+  end
 MODEL
 
-# options => { :fields => ["title:string", "body:string"], :app => 'app' }
-def create_model_file(name, options={})
+# options => { fields: ['title:string', 'body:string'], app: 'app' }
+def create_model_file(name, options = {})
   model_path = destination_root(options[:app], 'models', "#{name.to_s.underscore}.rb")
-  field_tuples = options[:fields].map { |value| value.split(":") }
+  field_tuples = options[:fields].map { |value| value.split(':') }
   column_declarations = field_tuples.map { |field, kind| "key :#{field}, #{kind.underscore.camelize}" }.join("\n  ")
   model_contents = MM_MODEL.gsub(/!NAME!/, name.to_s.underscore.camelize)
   model_contents.gsub!(/!FIELDS!/, column_declarations)

data/lib/padrino-gen/generators/components/orms/mongomatic.rb

@@ -1,78 +1,82 @@
-MONGOMATIC = (<<-MONGO) unless defined?(MONGOMATIC)
+MONGOMATIC = <<~MONGO unless defined?(MONGOMATIC)
 
-case Padrino.env
-  when :development then Mongomatic.db = Mongo::Connection.new.db("!NAME!_development")
-  when :production then Mongomatic.db = Mongo::Connection.new.db("!NAME!_production")
-  when :test then Mongomatic.db = Mongo::Connection.new.db("!NAME!_test")
-end
+  case Padrino.env
+    when :development then Mongomatic.db = Mongo::Connection.new.db('!NAME!_development')
+    when :production then Mongomatic.db = Mongo::Connection.new.db('!NAME!_production')
+    when :test then Mongomatic.db = Mongo::Connection.new.db('!NAME!_test')
+  end
 MONGO
 
 def setup_orm
-  mongomatic = MONGOMATIC
+  _mongomatic = MONGOMATIC
   require_dependencies 'mongomatic'
-  require_dependencies 'bson_ext', :require => 'mongo'
-  create_file("config/database.rb", MONGOMATIC.gsub(/!NAME!/, @project_name.underscore))
+  require_dependencies 'bson_ext', require: 'mongo'
+  create_file('config/database.rb', MONGOMATIC.gsub(/!NAME!/, @project_name.underscore))
 end
 
-MONGOMATIC_MODEL = (<<-MODEL) unless defined?(MONGOMATIC_MODEL)
-class !NAME! < Mongomatic::Base
-  include Mongomatic::Expectations::Helper
+MONGOMATIC_MODEL = <<~MODEL unless defined?(MONGOMATIC_MODEL)
+  class !NAME! < Mongomatic::Base
+    include Mongomatic::Expectations::Helper
 
-  # Mongomatic does not have the traditional
-  # model definition that AR/MM/DM et. al. have.
-  # Staying true to the "ad-hoc" nature of MongoDB,
-  # there are no explicit column definitions in the
-  # model file.
+    # Mongomatic does not have the traditional
+    # model definition that AR/MM/DM et. al. have.
+    # Staying true to the "ad-hoc" nature of MongoDB,
+    # there are no explicit column definitions in the
+    # model file.
 
-  # However you can "fake it" by making a column
-  # required using expectations
-  # For the sake of padrino g model,
-  # we'll assume that any property defined
-  # on the command-line is required
-  # In the case of Integer types, we'll add
-  # the expectation: be_a_number
-  # Future enhancement may allow a regex for
-  # String datatypes
+    # However you can "fake it" by making a column
+    # required using expectations
+    # For the sake of padrino g model,
+    # we'll assume that any property defined
+    # on the command-line is required
+    # In the case of Integer types, we'll add
+    # the expectation: be_a_number
+    # Future enhancement may allow a regex for
+    # String datatypes
 
 
-  # Examples:
-  # def validate
-  #   expectations do
-  #     be_present self['name'], "Name cannot be blank"
-  #     be_present self['email'], "Email cannot be blank"
-  #     be_present self['age'], "Age cannot be blank"
-  #     be_present self['password'], "Password cannot be blank"
-  #     be_a_number self['age'], "Age must be a number"
-  #     be_of_length self['password'], "Password must be at least 8 characters", :minimum => 8
-  #   end
-  # end
+    # Examples:
+    # def validate
+    #   expectations do
+    #     be_present self['name'], 'Name cannot be blank'
+    #     be_present self['email'], 'Email cannot be blank'
+    #     be_present self['age'], 'Age cannot be blank'
+    #     be_present self['password'], 'Password cannot be blank'
+    #     be_a_number self['age'], 'Age must be a number'
+    #     be_of_length self['password'], 'Password must be at least 8 characters', minimum: 8
+    #   end
+    # end
 
-  # def create_indexes
-  #   self.collection.create_index('name', :unique => true)
-  #   self.collection.create_index('email', :unique => true)
-  #   self.collection.create_index('age')
-  # end
-  def validate
-    expectations do
-      !FIELDS!
-      !INTEGERS!
+    # def create_indexes
+    #   self.collection.create_index('name', unique: true)
+    #   self.collection.create_index('email', unique: true)
+    #   self.collection.create_index('age')
+    # end
+    def validate
+      expectations do
+        !FIELDS!
+        !INTEGERS!
+      end
     end
   end
-
-end
 MODEL
 
-# options => { :fields => ["title:string", "body:string"], :app => 'app' }
-def create_model_file(name, options={})
-    model_path = destination_root(options[:app], 'models', "#{name.to_s.underscore}.rb")
-    field_tuples = options[:fields].map { |value| value.split(":") }
-    column_declarations = field_tuples.map { |field, kind| "be_present self['#{field}'], '#{field} cannot be blank'" }.join("\n      ")
-    # Really ugly oneliner
-    integers = field_tuples.select { |col, type| type =~ /[Ii]nteger/ }.map { |field, kind| "be_a_number self['#{field}'], '#{field} must be a number'" }.join("\n ")
-    model_contents = MONGOMATIC_MODEL.gsub(/!NAME!/, name.to_s.underscore.camelize)
-    model_contents.gsub!(/!FIELDS!/, column_declarations)
-    model_contents.gsub!(/!INTEGERS!/, integers)
-    create_file(model_path, model_contents)
+# options => { fields: ['title:string', 'body:string'], app: 'app' }
+def create_model_file(name, options = {})
+  model_path = destination_root(options[:app], 'models', "#{name.to_s.underscore}.rb")
+  column_declarations = []
+  integers = []
+
+  options[:fields].each do |value|
+    field, kind = value.split(':')
+    column_declarations << "be_present self['#{field}'], '#{field} cannot be blank'"
+    integers << "be_a_number self['#{field}'], '#{field} must be a number'" if kind =~ /[Ii]nteger/
+  end
+
+  model_contents = MONGOMATIC_MODEL.gsub(/!NAME!/, name.to_s.underscore.camelize)
+  model_contents.gsub!(/!FIELDS!/, column_declarations.join("\n      "))
+  model_contents.gsub!(/!INTEGERS!/, integers.join("\n      "))
+  create_file(model_path, model_contents)
 end
 
 def create_model_migration(filename, name, fields)