padrino-gen 0.9.10 → 0.9.11

data/README.rdoc

@@ -40,9 +40,9 @@ The available components and their default options are listed below:
 
 test::       rspec (default), bacon, shoulda, cucumber, testspec, riot
 renderer::   haml  (default), erb
-stylesheet:: sass  (default), less
+stylesheet:: sass  (default), less, compass
 mock::       none  (default), mocha, rr
-script::     none  (default), jquery, prototype, mootools, rightjs, extcore
+script::     none  (default), jquery, prototype, mootools, rightjs, extcore, dojo
 orm::        none  (default), datamapper, mongomapper, mongoid, activerecord, sequel, couchrest
 
 To learn more about the project generator, check out the guide to

data/Rakefile

@@ -1,54 +1,5 @@
-require 'rubygems'
-require 'rake'
-
-require File.expand_path("../../padrino-core/lib/padrino-core/version.rb", __FILE__)
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "padrino-gen"
-    gem.summary = "Generators for easily creating and building padrino applications"
-    gem.description = "Generators for easily creating and building padrino applications from the console"
-    gem.email = "padrinorb@gmail.com"
-    gem.homepage = "http://github.com/padrino/padrino-framework/tree/master/padrino-gen"
-    gem.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
-    gem.executables = ["padrino-gen"]
-    gem.rubyforge_project = 'padrino-gen'
-    gem.version = Padrino.version
-    gem.add_runtime_dependency     "padrino-core",  "= #{Padrino.version}"
-    gem.add_development_dependency "haml",          ">= 2.2.1"
-    gem.add_development_dependency "shoulda",       ">= 2.10.3"
-    gem.add_development_dependency "mocha",         ">= 0.9.7"
-    gem.add_development_dependency "rack-test",     ">= 0.5.0"
-    gem.add_development_dependency "webrat",        ">= 0.5.1"
-    gem.add_development_dependency "fakeweb",       ">= 1.2.3"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-  Jeweler::RubyforgeTasks.new { |r| r.doc_task = :none }
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
+# coding:utf-8
+RAKE_ROOT = __FILE__
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |rcov|
-    rcov.libs << 'test'
-    rcov.pattern = 'test/**/test_*.rb'
-    rcov.verbose = true
-    rcov.rcov_opts << ['--exclude /Gems/1.8/gems/,/tmp/,padrino-admin,padrino-cache,padrino-core,padrino-helpers,padrino-mailer']
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install relevance-rcov"
-  end
-end
-
-task :default => :test
+require 'rubygems'
+require File.expand_path(File.dirname(__FILE__) + '/../gem_rake_helper')

data/bin/padrino-gen

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
-require 'rubygems'
+
+# We load padrino-gen
 padrino_gen_path = File.expand_path('../../lib', __FILE__)
 $:.unshift(padrino_gen_path) if File.directory?(padrino_gen_path) && !$:.include?(padrino_gen_path)
 
@@ -7,9 +8,6 @@ $:.unshift(padrino_gen_path) if File.directory?(padrino_gen_path) && !$:.include
 padrino_core_path = File.expand_path('../../../padrino-core/lib', __FILE__)
 $:.unshift(padrino_core_path) if File.directory?(padrino_core_path) && !$:.include?(padrino_core_path)
 
-padrino_local_path = Dir.pwd
-$:.unshift(padrino_local_path) if File.directory?(padrino_local_path) && !$:.include?(padrino_local_path)
-
 require 'padrino-gen'
 require 'padrino-gen/generators/cli'
 

data/lib/padrino-gen/command.rb

@@ -0,0 +1,12 @@
+require 'padrino-core/command'
+
+module Padrino
+  ##
+  # This method return the correct location of padrino-gen bin or
+  # exec it using Kernel#system with the given args
+  #
+  def self.bin_gen(*args)
+    @_padrino_gen_bin ||= [Padrino.ruby_command, File.expand_path("../../../bin/padrino-gen", __FILE__)]
+    args.empty? ? @_padrino_gen_bin : system(args.unshift(@_padrino_gen_bin).join(" "))
+  end
+end # Padrino

data/lib/padrino-gen/generators/actions.rb

@@ -88,6 +88,12 @@ module Padrino
         File.exist?(destination_root('config/boot.rb'))
       end
 
+      # Returns the field with an unacceptable name(for symbol) else returns nil
+      def invalid_fields(fields)
+        results = fields.select { |field| field.split(":").first =~ /\W/ }
+        results.empty? ? nil : results
+      end
+
       # Returns the app_name for the application at root
       def fetch_app_name(app='app')
         app_path = destination_root(app, 'app.rb')
@@ -107,10 +113,9 @@ module Padrino
       # insert_into_gemfile(name, :group => 'test', :require => 'foo')
       def insert_into_gemfile(name, options={})
         after_pattern = options[:group] ? "#{options[:group].to_s.capitalize} requirements\n" : "Component requirements\n"
-        gem_options = options.slice(:group, :require).collect { |k, v| "#{k.inspect} => #{v.inspect}" }.join(", ")
-        include_text = "gem '#{name}'" << (gem_options.present? ? ", #{gem_options}" : "") << "\n"
-        options.merge!(:content => include_text, :after => after_pattern)
-        inject_into_file('Gemfile', options[:content], :after => options[:after])
+        gem_options   = options.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(", ")
+        include_text  = "gem '#{name}'" << (gem_options.present? ? ", #{gem_options}" : "") << "\n"
+        inject_into_file('Gemfile', include_text, :after => after_pattern)
       end
 
       ## Return true if our project has test component
@@ -134,6 +139,21 @@ module Padrino
         end
       end
 
+      # Generates standard and tiny applications within a project
+      def app_skeleton(app, tiny=false)
+        directory("app/", destination_root(app))
+        if tiny # generate tiny structure
+          template "templates/controller.rb.tt", destination_root(app, "controllers.rb")
+          template "templates/helper.rb.tt", destination_root(app, "helpers.rb")
+          @short_name = 'notifier'
+          template "templates/mailer.rb.tt", destination_root(app, "mailers.rb")
+          empty_directory destination_root(app, "views", "mailers")
+        else # generate standard folders
+          empty_directory destination_root("#{app}/controllers/")
+          empty_directory destination_root("#{app}/helpers/")
+        end
+      end
+
       module ClassMethods
         # Defines a class option to allow a component to be chosen and add to component type list
         # Also builds the available_choices hash of which component choices are supported
@@ -167,4 +187,4 @@ module Padrino
       end
     end # Actions
   end # Generators
-end # Padrino
+end # Padrino

data/lib/padrino-gen/generators/app/app.rb.tt

@@ -1,27 +1,26 @@
-class <%= @class_name %> < Padrino::Application
-  configure do
-    ##
-    # Application-specific configuration options
-    #
-    # set :raise_errors, true     # Show exceptions (default for development)
-    # set :public, "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)
-    # enable  :sessions           # Disabled by default
-    # disable :flash              # Disables rack-flash (enabled by default if sessions)
-    # disable :padrino_helpers    # Disables padrino markup helpers (enabled by default if present)
-    # disable :padrino_mailer     # Disables padrino mailer (enabled by default if present)
-    # enable  :authentication     # Enable padrino-admin authentication (disabled by default)
-    # layout  :my_layout          # Layout can be in views/layouts/foo.ext or views/foo.ext (default :application)
-    #
-  end
+class <%= @app_name %> < Padrino::Application
+  register Padrino::Mailer
+  register Padrino::Helpers
+
+  ##
+  # Application configuration options
+  #
+  # set :raise_errors, true     # Show exceptions (default for development)
+  # set :public, "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 (defaults to app/locale/)
+  # enable  :sessions           # Disabled by default
+  # disable :flash              # Disables rack-flash (enabled by default if sessions)
+  # layout  :my_layout          # Layout can be in views/layouts/foo.ext or views/foo.ext (default :application)
+  #
 
   ##
   # You can configure for a specified environment like:
   #
   #   configure :development do
   #     set :foo, :bar
+  #     disable :asset_stamp # no asset timestamping for dev
   #   end
   #
 
@@ -32,5 +31,4 @@ class <%= @class_name %> < Padrino::Application
   #     render 'errors/404'
   #   end
   #
-
 end

data/lib/padrino-gen/generators/app.rb

@@ -18,8 +18,9 @@ module Padrino
 
       argument :name, :desc => "The name of your padrino application"
 
-      class_option :root, :desc => "The root destination", :aliases => '-r', :default => ".", :type => :string
-      class_option :destroy, :aliases => '-d', :default => false,   :type    => :boolean
+      class_option :root,    :desc => "The root destination",       :aliases => '-r', :default => ".",   :type => :string
+      class_option :destroy,                                        :aliases => '-d', :default => false, :type => :boolean
+      class_option :tiny,    :desc => "Generate tiny app skeleton", :aliases => '-i', :default => false, :type => :boolean
 
       # Show help if no argv given
       require_arguments!
@@ -27,16 +28,16 @@ module Padrino
       # Copies over the Padrino base admin application
       def create_app
         self.destination_root = options[:root]
-        @class_name = name.gsub(/\W/, "_").underscore.classify
+        @app_name = name.gsub(/\W/, "_").underscore.classify
         if in_app_root?
-          directory("app/", destination_root(name))
-          append_file destination_root("config/apps.rb"),  "\nPadrino.mount(\"#{@class_name}\").to(\"/#{name.underscore}\")"
+          app_skeleton(name, options[:tiny])
+          append_file destination_root("config/apps.rb"),  "\nPadrino.mount(\"#{@app_name}\").to(\"/#{name.underscore}\")"
 
           return if self.behavior == :revoke
           say (<<-TEXT).gsub(/ {10}/,'')
 
           =================================================================
-          Your #{@class_name} application has been installed.
+          Your #{@app_name} application has been installed.
           This application has been mounted to /#{name.underscore}
           You can configure a different path by editing 'config/apps.rb'
           =================================================================

data/lib/padrino-gen/generators/cli.rb

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'thor/group'
 
 module Padrino
@@ -20,10 +21,10 @@ module Padrino
           ENV['PADRINO_LOG_LEVEL'] ||= "test"
           boot = options[:root] ? File.join(options[:root], 'config/boot.rb') : 'config/boot.rb'
           if File.exist?(boot)
-            require boot
+            require File.expand_path(boot)
           else
             # If we are outside app we need to load support_lite
-            require 'padrino-core/support_lite'
+            require 'padrino-core/support_lite' unless defined?(SupportLite)
           end
         rescue Exception => e
           puts "=> Problem loading config/boot.rb"

data/lib/padrino-gen/generators/components/actions.rb

@@ -57,9 +57,9 @@ module Padrino
         # For migration files
         # returns the number of the latest(most current) migration file
         def return_last_migration_number
-          Dir[destination_root('db/migrate/*.rb')].map do |f|
+          Dir[destination_root('db/migrate/*.rb')].map { |f|
             File.basename(f).match(/^(\d+)/)[0].to_i
-          end.max.to_i || 0
+          }.max.to_i || 0
         end
 
         # Return true if the migration already exist
@@ -82,10 +82,10 @@ module Padrino
         # For testing components
         # Injects the test class text into the test_config file for setting up the test gen
         # insert_test_suite_setup('...CLASS_NAME...')
-        # => inject_into_file("test/test_config.rb", TEST.gsub(/CLASS_NAME/, @class_name), :after => "set :environment, :test")
+        # => inject_into_file("test/test_config.rb", TEST.gsub(/CLASS_NAME/, @app_name), :after => "set :environment, :test")
         def insert_test_suite_setup(suite_text, options={})
           options.reverse_merge!(:path => "test/test_config.rb")
-          create_file(options[:path], suite_text.gsub(/CLASS_NAME/, @class_name))
+          create_file(options[:path], suite_text.gsub(/CLASS_NAME/, @app_name))
         end
 
         # For mocking components

data/lib/padrino-gen/generators/components/mocks/rr.rb

@@ -4,7 +4,7 @@ def setup_mock
     when 'rspec'
       inject_into_file 'spec/spec_helper.rb', "  conf.mock_with :rr\n", :after => "Spec::Runner.configure do |conf|\n"
     when 'riot'
-      inject_into_file "test/test_config.rb","require 'riot/rr'\n", :after => "\"/../config/boot\"\n"
+      inject_into_file "test/test_config.rb","require 'riot/rr'\n", :after => "\"/../config/boot\")\n"
     else
       insert_mocking_include "RR::Adapters::RRMethods", :path => "test/test_config.rb"
   end

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

@@ -1,4 +1,4 @@
-AR = (<<-AR).gsub(/^ {10}/, '') unless defined?(AR)
+AR = (<<-AR) unless defined?(AR)
 ##
 # You can use other adapters like:
 #
@@ -15,18 +15,15 @@ AR = (<<-AR).gsub(/^ {10}/, '') unless defined?(AR)
 #   }
 #
 ActiveRecord::Base.configurations[:development] = {
-  :adapter => 'sqlite3',
-  :database => Padrino.root('db', "development.db")
+!DB_DEVELOPMENT!
 }
 
 ActiveRecord::Base.configurations[:production] = {
-  :adapter => 'sqlite3',
-  :database => Padrino.root('db', "production.db")
+!DB_PRODUCTION!
 }
 
 ActiveRecord::Base.configurations[:test] = {
-  :adapter => 'sqlite3',
-  :database => Padrino.root('db', "test.db")
+!DB_TEST!
 }
 
 # Setup our logger
@@ -49,26 +46,71 @@ ActiveSupport.escape_html_entities_in_json = false
 ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[Padrino.env])
 AR
 
+MYSQL = (<<-MYSQL)
+  :adapter   => 'mysql',
+  :encoding  => 'utf8',
+  :reconnect => false,
+  :database  => !DB_NAME!,
+  :pool      => 5,
+  :username  => 'root',
+  :password  => '',
+  :host      => 'localhost',
+  :socket    => '/tmp/mysql.sock'
+MYSQL
+
+POSTGRES = (<<-POSTGRES)
+  :adapter   => 'postgresql',
+  :database  => !DB_NAME!,
+  :username  => 'root',
+  :password  => '',
+  :host      => 'localhost',
+  :port      => 5432
+POSTGRES
+
+SQLITE = (<<-SQLITE)
+  :adapter => 'sqlite3',
+  :database => !DB_NAME!
+SQLITE
+
+
 def setup_orm
-  require_dependencies 'sqlite3-ruby', :require => 'sqlite3'
+  ar = AR
+  case options[:adapter]
+  when 'mysql'
+    ar.gsub! /!DB_DEVELOPMENT!/, MYSQL.gsub(/!DB_NAME!/,"\"#{name}_development\"")
+    ar.gsub! /!DB_PRODUCTION!/, MYSQL.gsub(/!DB_NAME!/,"\"#{name}_production\"")
+    ar.gsub! /!DB_TEST/, MYSQL.gsub(/!DB_NAME!/,"\"#{name}_test\"")
+    require_dependencies 'mysql'
+  when 'postgres'
+    ar.gsub! /!DB_DEVELOPMENT!/, POSTGRES.gsub(/!DB_NAME!/,"\"#{name}_development\"")
+    ar.gsub! /!DB_PRODUCTION!/, POSTGRES.gsub(/!DB_NAME!/,"\"#{name}_production\"")
+    ar.gsub! /!DB_TEST!/, POSTGRES.gsub(/!DB_NAME!/,"\"#{name}_test\"")
+    require_dependencies 'pg', :require => 'postgres'
+  else
+    ar.gsub! /!DB_DEVELOPMENT!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', \"#{name}_development.db\")")
+    ar.gsub! /!DB_PRODUCTION!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', \"#{name}_production.db\")")
+    ar.gsub! /!DB_TEST!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', \"#{name}_test.db\")")    
+    require_dependencies 'sqlite3-ruby', :require => 'sqlite3'
+  end
   require_dependencies 'activerecord', :require => 'active_record'
-  create_file("config/database.rb", AR)
+  create_file("config/database.rb", ar)
   empty_directory('app/models')
 end
 
-AR_MODEL = (<<-MODEL).gsub(/^ {10}/, '')
+AR_MODEL = (<<-MODEL) unless defined?(AR_MODEL)
 class !NAME! < ActiveRecord::Base
 
 end
 MODEL
 
-def create_model_file(name, fields)
-  model_path = destination_root('app/models/', "#{name.to_s.underscore}.rb")
+# 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")
   model_contents = AR_MODEL.gsub(/!NAME!/, name.to_s.downcase.camelize)
   create_file(model_path, model_contents,:skip => true)
 end
 
-AR_MIGRATION = (<<-MIGRATION).gsub(/^ {10}/, '')
+AR_MIGRATION = (<<-MIGRATION) unless defined?(AR_MIGRATION)
 class !FILECLASS! < ActiveRecord::Migration
   def self.up
     !UP!
@@ -80,13 +122,13 @@ class !FILECLASS! < ActiveRecord::Migration
 end
 MIGRATION
 
-AR_MODEL_UP_MG = (<<-MIGRATION).gsub(/^ {6}/, '')
+AR_MODEL_UP_MG = (<<-MIGRATION).gsub(/^/, '    ') unless defined?(AR_MODEL_UP_MG)
 create_table :!TABLE! do |t|
   !FIELDS!
 end
 MIGRATION
 
-AR_MODEL_DOWN_MG = (<<-MIGRATION).gsub(/^ {10}/, '')
+AR_MODEL_DOWN_MG = (<<-MIGRATION) unless defined?(AR_MODEL_DOWN_MG)
 drop_table :!TABLE!
 MIGRATION
 
@@ -97,7 +139,7 @@ def create_model_migration(migration_name, name, columns)
        :up => AR_MODEL_UP_MG, :down => AR_MODEL_DOWN_MG)
 end
 
-AR_CHANGE_MG = (<<-MIGRATION).gsub(/^ {6}/, '')
+AR_CHANGE_MG = (<<-MIGRATION).gsub(/^/, '    ') unless defined?(AR_CHANGE_MG)
 change_table :!TABLE! do |t|
   !COLUMNS!
 end

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

@@ -1,4 +1,4 @@
-COUCHREST = (<<-COUCHREST).gsub(/^ {10}/, '') unless defined?(COUCHREST)
+COUCHREST = (<<-COUCHREST) unless defined?(COUCHREST)
 case Padrino.env
   when :development then COUCHDB_NAME = '!NAME!_development'
   when :production  then COUCHDB_NAME = '!NAME!_production'
@@ -14,7 +14,7 @@ def setup_orm
   empty_directory('app/models')
 end
 
-CR_MODEL = (<<-MODEL).gsub(/^ {10}/, '') unless defined?(CR_MODEL)
+CR_MODEL = (<<-MODEL) unless defined?(CR_MODEL)
 class !NAME! < CouchRest::ExtendedDocument
   include CouchRest::Validation
 
@@ -26,9 +26,10 @@ class !NAME! < CouchRest::ExtendedDocument
 end
 MODEL
 
-def create_model_file(name, fields)
-  model_path = destination_root('app/models/', "#{name.to_s.underscore}.rb")
-  field_tuples = fields.collect { |value| value.split(":") }
+# 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].collect { |value| value.split(":") }
   column_declarations = field_tuples.collect { |field, kind| "property :#{field}" }.join("\n  ")
   model_contents = CR_MODEL.gsub(/!NAME!/, name.to_s.camelize)
   model_contents.gsub!(/!FIELDS!/, column_declarations)

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

@@ -1,4 +1,4 @@
-DM = (<<-DM).gsub(/^ {10}/, '') unless defined?(DM)
+DM = (<<-DM) unless defined?(DM)
 ##
 # A MySQL connection:
 # DataMapper.setup(:default, 'mysql://user:password@localhost/the_database_name')
@@ -6,23 +6,46 @@ DM = (<<-DM).gsub(/^ {10}/, '') unless defined?(DM)
 # # A Postgres connection:
 # DataMapper.setup(:default, 'postgres://user:password@localhost/the_database_name')
 #
+# # A Sqlite3 connection
+# DataMapper.setup(:default, "sqlite3://" + Padrino.root('db', "development.db"))
+#
+
 
 DataMapper.logger = logger
 
 case Padrino.env
-  when :development then DataMapper.setup(:default, "sqlite3://" + Padrino.root('db', "development.db"))
-  when :production  then DataMapper.setup(:default, "sqlite3://" + Padrino.root('db', "production.db"))
-  when :test        then DataMapper.setup(:default, "sqlite3://" + Padrino.root('db', "test.db"))
+  when :development then DataMapper.setup(:default, !DB_DEVELOPMENT!)
+  when :production  then DataMapper.setup(:default, !DB_PRODUCTION!)
+  when :test        then DataMapper.setup(:default, !DB_TEST!)
 end
 DM
 
 def setup_orm
-  require_dependencies 'data_objects', 'do_sqlite3', 'datamapper'
-  create_file("config/database.rb", DM)
+  dm = DM
+  require_dependencies 'data_mapper'
+  require_dependencies case options[:adapter]
+    when 'mysql'
+      dm.gsub!(/!DB_DEVELOPMENT!/,"\"mysql://root@localhost/#{name}_development\"")
+      dm.gsub!(/!DB_PRODUCTION!/,"\"mysql://root@localhost/#{name}_production\"")
+      dm.gsub!(/!DB_TEST!/,"\"mysql://root@localhost/#{name}_test\"")
+      'dm-mysql-adapter'
+    when 'postgres'
+      dm.gsub!(/!DB_DEVELOPMENT!/,"\"postgres://root@localhost/#{name}_development\"")
+      dm.gsub!(/!DB_PRODUCTION!/,"\"postgres://root@localhost/#{name}_production\"")
+      dm.gsub!(/!DB_TEST!/,"\"postgres://root@localhost/#{name}_test\"")
+      'dm-postgres-adapter'
+    else
+      dm.gsub!(/!DB_DEVELOPMENT!/,"\"sqlite3://\" + Padrino.root('db', \"#{name}_development.db\")")
+      dm.gsub!(/!DB_PRODUCTION!/,"\"sqlite3://\" + Padrino.root('db', \"#{name}_production.db\")")
+      dm.gsub!(/!DB_TEST!/,"\"sqlite3://\" + Padrino.root('db', \"#{name}_test.db\")")
+      'dm-sqlite-adapter'
+  end
+
+  create_file("config/database.rb", dm)
   empty_directory('app/models')
 end
 
-DM_MODEL = (<<-MODEL).gsub(/^ {10}/, '') unless defined?(DM_MODEL)
+DM_MODEL = (<<-MODEL) unless defined?(DM_MODEL)
 class !NAME!
   include DataMapper::Resource
 
@@ -32,17 +55,18 @@ class !NAME!
 end
 MODEL
 
-def create_model_file(name, fields)
-  model_path = destination_root('app/models/', "#{name.to_s.underscore}.rb")
+# 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")
   model_contents = DM_MODEL.gsub(/!NAME!/, name.to_s.downcase.camelize)
-  field_tuples = fields.collect { |value| value.split(":") }
+  field_tuples = options[:fields].collect { |value| value.split(":") }
   field_tuples.collect! { |field, kind| kind =~ /datetime/i ? [field, 'DateTime'] : [field, kind] } # fix datetime
   column_declarations = field_tuples.collect { |field, kind|"property :#{field}, #{kind.camelize}" }.join("\n  ")
   model_contents.gsub!(/!FIELDS!/, column_declarations)
   create_file(model_path, model_contents)
 end
 
-DM_MIGRATION = (<<-MIGRATION).gsub(/^ {10}/, '') unless defined?(DM_MIGRATION)
+DM_MIGRATION = (<<-MIGRATION) unless defined?(DM_MIGRATION)
 migration !VERSION!, :!FILENAME! do
   up do
     !UP!
@@ -54,24 +78,24 @@ migration !VERSION!, :!FILENAME! do
 end
 MIGRATION
 
-DM_MODEL_UP_MG =  (<<-MIGRATION).gsub(/^ {6}/, '') unless defined?(DM_MODEL_UP_MG)
+DM_MODEL_UP_MG =  (<<-MIGRATION).gsub(/^/, '    ') unless defined?(DM_MODEL_UP_MG)
 create_table :!TABLE! do
-  column :id, Integer, :serial => true
+  column :id, DataMapper::Property::Integer, :serial => true
   !FIELDS!
 end
 MIGRATION
 
-DM_MODEL_DOWN_MG =  (<<-MIGRATION).gsub(/^ {10}/, '') unless defined?(DM_MODEL_DOWN_MG)
+DM_MODEL_DOWN_MG =  (<<-MIGRATION) unless defined?(DM_MODEL_DOWN_MG)
 drop_table :!TABLE!
 MIGRATION
 
 def create_model_migration(migration_name, name, columns)
   output_model_migration(migration_name, name, columns,
-       :column_format => Proc.new { |field, kind| "column :#{field}, \"#{kind.upcase}\"" },
+       :column_format => Proc.new { |field, kind| "column :#{field}, DataMapper::Property::#{kind.classify}" },
        :base => DM_MIGRATION, :up => DM_MODEL_UP_MG, :down => DM_MODEL_DOWN_MG)
 end
 
-DM_CHANGE_MG = (<<-MIGRATION).gsub(/^ {6}/, '') unless defined?(DM_CHANGE_MG)
+DM_CHANGE_MG = (<<-MIGRATION).gsub(/^/, '    ') unless defined?(DM_CHANGE_MG)
 modify_table :!TABLE! do
   !COLUMNS!
 end
@@ -80,7 +104,7 @@ MIGRATION
 def create_migration_file(migration_name, name, columns)
   output_migration_file(migration_name, name, columns,
     :base => DM_MIGRATION, :change_format => DM_CHANGE_MG,
-    :add => Proc.new { |field, kind| "add_column :#{field}, #{kind.camelize}"  },
+    :add => Proc.new { |field, kind| "add_column :#{field}, DataMapper::Property::#{kind.classify}" },
     :remove => Proc.new { |field, kind| "drop_column :#{field}" }
   )
 end

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

@@ -1,4 +1,4 @@
-MONGOID = (<<-MONGO).gsub(/^ {10}/, '') unless defined?(MONGOID)
+MONGOID = (<<-MONGO) unless defined?(MONGOID)
 
 # Connection.new takes host, port
 host = 'localhost'
@@ -29,11 +29,11 @@ MONGO
 def setup_orm
   require_dependencies 'bson_ext', :require => 'mongo'
   require_dependencies 'mongoid'
-  create_file("config/database.rb", MONGOID.gsub(/!NAME!/, name.underscore))
+  create_file("config/database.rb", MONGOID.gsub(/!NAME!/, name.underscore.gsub('.','_')))
   empty_directory('app/models')
 end
 
-MONGOID_MODEL = (<<-MODEL).gsub(/^ {10}/, '') unless defined?(MONGOID_MODEL)
+MONGOID_MODEL = (<<-MODEL) unless defined?(MONGOID_MODEL)
 class !NAME!
   include Mongoid::Document
   include Mongoid::Timestamps # adds created_at and updated_at fields
@@ -50,9 +50,10 @@ class !NAME!
 end
 MODEL
 
-def create_model_file(name, fields)
-  model_path = destination_root('app/models/', "#{name.to_s.underscore}.rb")
-  field_tuples = fields.collect { |value| value.split(":") }
+# 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].collect { |value| value.split(":") }
   column_declarations = field_tuples.collect { |field, kind| "field :#{field}, :type => #{kind.camelize}" }.join("\n  ")
   model_contents = MONGOID_MODEL.gsub(/!NAME!/, name.to_s.camelize)
   model_contents.gsub!(/!FIELDS!/, column_declarations)

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

@@ -1,4 +1,4 @@
-MONGO = (<<-MONGO).gsub(/^ {10}/, '') unless defined?(MONGO)
+MONGO = (<<-MONGO) unless defined?(MONGO)
 MongoMapper.connection = Mongo::Connection.new('localhost', nil, :logger => logger)
 
 case Padrino.env
@@ -15,7 +15,7 @@ def setup_orm
   empty_directory('app/models')
 end
 
-MM_MODEL = (<<-MODEL).gsub(/^ {10}/, '') unless defined?(MM_MODEL)
+MM_MODEL = (<<-MODEL) unless defined?(MM_MODEL)
 class !NAME!
   include MongoMapper::Document
 
@@ -25,9 +25,10 @@ class !NAME!
 end
 MODEL
 
-def create_model_file(name, fields)
-  model_path = destination_root('app/models/', "#{name.to_s.underscore}.rb")
-  field_tuples = fields.collect { |value| value.split(":") }
+# 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].collect { |value| value.split(":") }
   column_declarations = field_tuples.collect { |field, kind| "key :#{field}, #{kind.camelize}" }.join("\n  ")
   model_contents = MM_MODEL.gsub(/!NAME!/, name.to_s.camelize)
   model_contents.gsub!(/!FIELDS!/, column_declarations)