padrino-gen 0.6.3 → 0.6.7

data/Rakefile

@@ -62,4 +62,4 @@ Rake::RDocTask.new do |rdoc|
   rdoc.title = "padrino-gen #{version}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
-end
+end

data/VERSION

@@ -1 +1 @@
-0.6.3
+0.6.7

data/bin/padrino-gen

@@ -1,10 +1,10 @@
 #!/usr/bin/env ruby
 %w[rubygems thor].each { |gem| require gem }
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
+$:.unshift File.dirname(__FILE__) + "/../lib"
 
 # We try to load the vendored padrino-core if exist
 if File.exist?(File.dirname(__FILE__) + "/../../padrino-core/lib")
-  $LOAD_PATH.unshift File.dirname(__FILE__) + "/../../padrino-core/lib"
+  $:.unshift File.dirname(__FILE__) + "/../../padrino-core/lib"
 end
 
 require 'padrino-gen'

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

@@ -15,16 +15,35 @@ module Padrino
         self.class.send(:include, generator_module_for(choice, component))
         send("setup_#{component}") if respond_to?("setup_#{component}")
       end
-      
+
+      # Returns the related module for a given component and option
+      # generator_module_for('rr', :mock)
+      def generator_module_for(choice, component)
+        "Padrino::Generators::Components::#{component.to_s.capitalize.pluralize}::#{choice.to_s.capitalize}Gen".constantize
+      end
+
       # Includes the component module for the given component and choice
       # Determines the choice using .components file
       # include_component_module_for(:mock)
       # include_component_module_for(:mock, 'rr')
-      def include_component_module_for(component, root=nil, choice=nil)
-        choice = fetch_component_choice(component, root) unless choice
+      def include_component_module_for(component, choice=nil)
+        choice = fetch_component_choice(component) unless choice
         self.class.send(:include, generator_module_for(choice, component))
       end
 
+      
+      # Returns the component choice stored within the .component file of an application
+      # fetch_component_choice(:mock)
+      def fetch_component_choice(component)
+        retrieve_component_config(destination_root('.components'))[component]
+      end
+
+      # Loads the component config back into a hash
+      # i.e retrieve_component_config(...) => { :mock => 'rr', :test => 'riot', ... }
+      def retrieve_component_config(target)
+        YAML.load_file(target)
+      end
+
       # Prompts the user if necessary until a valid choice is returned for the component
       # resolve_valid_choice(:mock) => 'rr'
       def resolve_valid_choice(component)
@@ -43,12 +62,6 @@ module Padrino
         self.class.available_choices_for(component).include? choice.to_sym
       end
 
-      # Returns the related module for a given component and option
-      # generator_module_for('rr', :mock)
-      def generator_module_for(choice, component)
-        "Padrino::Generators::Components::#{component.to_s.capitalize.pluralize}::#{choice.to_s.capitalize}Gen".constantize
-      end
-
       # Creates a component_config file at the destination containing all component options
       # Content is a yamlized version of a hash containing component name mapping to chosen value
       def store_component_config(destination)
@@ -59,38 +72,45 @@ module Padrino
         end
       end
 
-      # Loads the component config back into a hash
-      # i.e retrieve_component_config(...) => { :mock => 'rr', :test => 'riot', ... }
-      def retrieve_component_config(target)
-        YAML.load_file(target)
-      end
-      
-      # Returns the component choice stored within the .component file of an application
-      # fetch_component_choice(:mock)
-      def fetch_component_choice(component, root=nil)
-        comp_path = root ? File.join(root, '.components') : '.components'
-        retrieve_component_config(comp_path)[component]
+      # Returns the root for this thor class (also aliased as destination root).
+      def destination_root(*paths)
+        File.join(@destination_stack.last, paths)
       end
-      
+
       # Returns true if inside a Padrino application
-      def in_app_root?(root=nil)
-        root ? File.exist?(File.join(root, 'config/boot.rb')) : File.exist?('config/boot.rb')
+      def in_app_root?
+        File.exist?(destination_root('config/boot.rb'))
       end
-      
+
       # Returns the app_name for the application at root
       def fetch_app_name(root=nil)
         app_path = root ? File.join(root, 'app/app.rb') : 'app/app.rb'
         @app_name ||= File.read(app_path).scan(/class\s(.*?)\s</).flatten[0]
       end
-      
-      # Constructs a path from the specified app root
-      # app_root_path("app/mailers", "#{@mailer_basename}.rb")
-      def app_root_path(*paths)
-        settings = paths.extract_options!
-        File.join(settings[:root] || options[:root] || '.', *paths)
+
+      # Adds all the specified gems into the Gemfile for bundler
+      # require_dependencies 'active_record'
+      # require_dependencies 'mocha', 'bacon', :only => :testing
+      def require_dependencies(*gem_names)
+        options = gem_names.extract_options!
+        gem_names.reverse.each { |lib| insert_into_gemfile(lib, options) }
+      end
+
+      # Inserts a required gem into the Gemfile to add the bundler dependency
+      # insert_into_gemfile(name)
+      # insert_into_gemfile(name, :only => :testing, :require_as => 'foo')
+      def insert_into_gemfile(name, options={})
+        after_pattern = options[:only] ? "#{options[:only].to_s.capitalize} requirements\n" : "Component requirements\n"
+        gem_options = options.slice(:only, :require_as).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)
+        if behavior == :revoke || !File.read(destination_root('Gemfile')).include?(options[:content])
+          inject_into_file('Gemfile', options[:content], :after => options[:after])
+        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
         # component_option :test, "Testing framework", :aliases => '-t', :choices => [:bacon, :shoulda]

data/lib/padrino-gen/generators/app/Gemfile

@@ -1,5 +1,6 @@
 clear_sources
 source 'http://gemcutter.org'
+
 # Project requirements
 gem 'sinatra'
 gem 'padrino'

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

@@ -3,7 +3,7 @@ PADRINO_ROOT = File.dirname(__FILE__) + '/..' unless defined? PADRINO_ROOT
 
 # Try to load the vendorized padrino.
 Dir[PADRINO_ROOT + "/vendor/padrino/**/lib"].each do |gem|
-  $LOAD_PATH.unshift gem
+  $:.unshift gem
 end
 
 require 'padrino'

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

@@ -9,7 +9,7 @@ module Padrino
 
       # Define the source template root
       def self.source_root; File.dirname(__FILE__); end
-      def self.banner; "padrino-gen project [name] [path] [options]"; end
+      def self.banner; "padrino-gen project [name] [options]"; end
 
       # Include related modules
       include Thor::Actions
@@ -19,15 +19,16 @@ module Padrino
       desc "Description:\n\n\tpadrino-gen project generates a new Padrino project"
 
       argument :name, :desc => "The name of your padrino project"
-      argument :path, :desc => "The path to create your padrino project", :default => "."
+
       class_option :run_bundler, :aliases => '-b', :default => false, :type => :boolean
+      class_option :root, :desc => "The root destination",        :aliases => '-r', :default => ".",   :type => :string
 
       # Definitions for the available customizable components
       component_option :orm,      "database engine",    :aliases => '-d', :choices => [:datamapper, :mongomapper, :activerecord, :sequel, :couchrest]
       component_option :test,     "testing framework",  :aliases => '-t', :choices => [:bacon, :shoulda, :rspec, :testspec, :riot]
       component_option :mock,     "mocking library",    :aliases => '-m', :choices => [:mocha, :rr]
       component_option :script,   "javascript library", :aliases => '-s', :choices => [:jquery, :prototype, :rightjs]
-      component_option :renderer, "template engine",    :aliases => '-r', :choices => [:erb, :haml]
+      component_option :renderer, "template engine",    :aliases => '-e', :choices => [:erb, :haml]
 
       # Show help if no argv given
       def self.start(given_args=ARGV, config={})
@@ -37,9 +38,9 @@ module Padrino
 
       # Copies over the Padrino base application App
       def setup_app
-        self.destination_root = File.join(path, name)
-        @class_name = name.classify
-        directory("app/", self.destination_root)
+        @class_name = name.underscore.classify
+        self.destination_root = File.join(options[:root], name)
+        directory("app/", destination_root)
         store_component_config('.components')
       end
 

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

@@ -3,46 +3,31 @@ module Padrino
     module Components
       module Actions
         BASE_TEST_HELPER = (<<-TEST).gsub(/^ {8}/, '')
-        RACK_ENV = 'test' unless defined?(RACK_ENV)
+        PADRINO_ENV = 'test' unless defined?(PADRINO_ENV)
         require File.dirname(__FILE__) + "/../config/boot"
-        Bundler.require_env(:testing)
         TEST
 
-        # Adds all the specified gems into the Gemfile for bundler
-        # require_dependencies 'active_record'
-        # require_dependencies 'mocha', 'bacon', :only => :testing
-        def require_dependencies(*gem_names)
-          options = gem_names.extract_options!
-          gem_names.reverse.each { |lib| insert_into_gemfile(lib, options) }
-        end
-
-        # Inserts a required gem into the Gemfile to add the bundler dependency
-        # insert_into_gemfile(name)
-        # insert_into_gemfile(name, :only => :testing, :require_as => 'foo')
-        def insert_into_gemfile(name, options={})
-          after_pattern = options[:only] ? "#{options[:only].to_s.capitalize} requirements\n" : "Component requirements\n"
-          gem_options = options.slice(:only, :require_as).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])
-        end
-
         # For orm database components
         # Generates the model migration file created when generating a new model
         # options => { :base => "....text...", :up => "..text...",
         #             :down => "..text...", column_format => "t.column :#{field}, :#{kind}" }
         def output_model_migration(filename, name, columns, options={})
-          model_name = name.to_s.pluralize
-          field_tuples = fields.collect { |value| value.split(":") }
-          field_tuples.collect! { |field, kind| kind =~ /datetime/i ? [field, 'DateTime'] : [field, kind] } # fix datetime
-          column_declarations = field_tuples.collect(&options[:column_format]).join("\n      ")
-          contents = options[:base].dup.gsub(/\s{4}!UP!\n/m, options[:up]).gsub(/!DOWN!\n/m, options[:down])
-          contents = contents.gsub(/!NAME!/, model_name.camelize).gsub(/!TABLE!/, model_name.underscore)
-          contents = contents.gsub(/!FILENAME!/, filename.underscore).gsub(/!FILECLASS!/, filename.camelize)
-          current_migration_number = return_last_migration_number
-          contents = contents.gsub(/!FIELDS!/, column_declarations).gsub(/!VERSION!/, (current_migration_number + 1).to_s)
-          migration_filename = "#{format("%03d", current_migration_number+1)}_#{filename.underscore}.rb"
-          create_file(app_root_path('db/migrate/', migration_filename), contents, :skip => true)
+          if behavior == :revoke
+            remove_migration(name)
+          else
+            return if migration_exist?(filename)
+            model_name = name.to_s.pluralize
+            field_tuples = fields.collect { |value| value.split(":") }
+            field_tuples.collect! { |field, kind| kind =~ /datetime/i ? [field, 'DateTime'] : [field, kind] } # fix datetime
+            column_declarations = field_tuples.collect(&options[:column_format]).join("\n      ")
+            contents = options[:base].dup.gsub(/\s{4}!UP!\n/m, options[:up]).gsub(/!DOWN!\n/m, options[:down])
+            contents = contents.gsub(/!NAME!/, model_name.camelize).gsub(/!TABLE!/, model_name.underscore)
+            contents = contents.gsub(/!FILENAME!/, filename.underscore).gsub(/!FILECLASS!/, filename.camelize)
+            current_migration_number = return_last_migration_number
+            contents = contents.gsub(/!FIELDS!/, column_declarations).gsub(/!VERSION!/, (current_migration_number + 1).to_s)
+            migration_filename = "#{format("%03d", current_migration_number+1)}_#{filename.underscore}.rb"
+            create_file(destination_root('db/migrate/', migration_filename), contents, :skip => true)
+          end
         end
 
         # For orm database components
@@ -51,33 +36,42 @@ module Padrino
         #              :add => lambda { |field, kind| "add_column :#{table_name}, :#{field}, :#{kind}" },
         #              :remove => lambda { |field, kind| "remove_column :#{table_name}, :#{field}" }
         def output_migration_file(filename, name, columns, options={})
-          change_format = options[:change_format]
-          migration_scan = filename.camelize.scan(/(Add|Remove)(?:.*?)(?:To|From)(.*?)$/).flatten
-          direction, table_name = migration_scan[0].downcase, migration_scan[1].downcase.pluralize if migration_scan.any?
-          tuples = direction ? columns.collect { |value| value.split(":") } : []
-          tuples.collect! { |field, kind| kind =~ /datetime/i ? [field, 'DateTime'] : [field, kind] } # fix datetime
-          add_columns    = tuples.collect(&options[:add]).join("\n    ")
-          remove_columns = tuples.collect(&options[:remove]).join("\n    ")
-          forward_text = change_format.gsub(/!TABLE!/, table_name).gsub(/!COLUMNS!/, add_columns) if tuples.any?
-          back_text    = change_format.gsub(/!TABLE!/, table_name).gsub(/!COLUMNS!/, remove_columns) if tuples.any?
-          contents = options[:base].dup.gsub(/\s{4}!UP!\n/m,   (direction == 'add' ? forward_text.to_s : back_text.to_s))
-          contents.gsub!(/\s{4}!DOWN!\n/m, (direction == 'add' ? back_text.to_s : forward_text.to_s))
-          contents = contents.gsub(/!FILENAME!/, filename.underscore).gsub(/!FILECLASS!/, filename.camelize)
-          current_migration_number = return_last_migration_number
-          contents.gsub!(/!VERSION!/, (current_migration_number + 1).to_s)
-          migration_filename = "#{format("%03d", current_migration_number+1)}_#{filename.underscore}.rb"
-          # migration_filename = "#{Time.now.strftime("%Y%m%d%H%M%S")}_#{filename.underscore}.rb"
-          create_file(app_root_path('db/migrate/', migration_filename), contents)
+          if behavior == :revoke
+            remove_migration(name)
+          else
+            return if migration_exist?(filename)
+            change_format = options[:change_format]
+            migration_scan = filename.camelize.scan(/(Add|Remove)(?:.*?)(?:To|From)(.*?)$/).flatten
+            direction, table_name = migration_scan[0].downcase, migration_scan[1].downcase.pluralize if migration_scan.any?
+            tuples = direction ? columns.collect { |value| value.split(":") } : []
+            tuples.collect! { |field, kind| kind =~ /datetime/i ? [field, 'DateTime'] : [field, kind] } # fix datetime
+            add_columns    = tuples.collect(&options[:add]).join("\n    ")
+            remove_columns = tuples.collect(&options[:remove]).join("\n    ")
+            forward_text = change_format.gsub(/!TABLE!/, table_name).gsub(/!COLUMNS!/, add_columns) if tuples.any?
+            back_text    = change_format.gsub(/!TABLE!/, table_name).gsub(/!COLUMNS!/, remove_columns) if tuples.any?
+            contents = options[:base].dup.gsub(/\s{4}!UP!\n/m,   (direction == 'add' ? forward_text.to_s : back_text.to_s))
+            contents.gsub!(/\s{4}!DOWN!\n/m, (direction == 'add' ? back_text.to_s : forward_text.to_s))
+            contents = contents.gsub(/!FILENAME!/, filename.underscore).gsub(/!FILECLASS!/, filename.camelize)
+            current_migration_number = return_last_migration_number
+            contents.gsub!(/!VERSION!/, (current_migration_number + 1).to_s)
+            migration_filename = "#{format("%03d", current_migration_number+1)}_#{filename.underscore}.rb"
+            create_file(destination_root('db/migrate/', migration_filename), contents, :skip => true)
+          end
         end
 
         # For migration files
         # returns the number of the latest(most current) migration file
         def return_last_migration_number
-          Dir[app_root_path('db/migrate/*.rb')].map do |f|
+          Dir[destination_root('db/migrate/*.rb')].map do |f|
             File.basename(f).match(/^(\d+)/)[0].to_i
           end.max.to_i || 0
         end
 
+        # Return true if the migration already exist
+        def migration_exist?(filename)
+          Dir[destination_root("db/migrate/*_#{filename.underscore}.rb")].size > 0
+        end
+
         # For model destroy option
         # removes the initial migration file of model
         def remove_model_migration(name)
@@ -87,10 +81,15 @@ module Padrino
         # For the removal of migration files
         # removes the migration file based on the migration name
         def remove_migration(name)
-          migration_path =  Dir[app_root_path('db/migrate/*.rb')].select do |f| 
-            File.basename(f).match(/#{name.to_s.underscore}/)
-          end.first
-          remove_file migration_path if migration_path && File.exist?(migration_path)
+          migration_path =  Dir[destination_root('db/migrate/*.rb')].find do |f| 
+            File.basename(f) =~ /#{name.to_s.underscore}/
+          end
+          return unless migration_path
+          if behavior == :revoke # we need to reverse the operation for revoke
+            create_file migration_path
+          else
+            remove_file migration_path
+          end
         end
 
         # For testing components
@@ -109,8 +108,8 @@ module Padrino
         # => inject_into_file("test/test_config.rb", "  include Mocha::API\n", :after => /class.*?\n/)
         def insert_mocking_include(library_name, options={})
           options.reverse_merge!(:indent => 2, :after => /class.*?\n/, :path => "test/test_config.rb")
-          return unless File.exist?(File.join(self.destination_root, options[:path]))
-          include_text = indent_spaces(options[:indent]) + "include #{library_name}\n"
+          return unless File.exist?(destination_root(options[:path]))
+          include_text = indent_spaces(2) + "include #{library_name}\n"
           inject_into_file(options[:path], include_text, :after => options[:after])
         end
 

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

@@ -6,31 +6,50 @@ module Padrino
         module ActiverecordGen
 
           AR = (<<-AR).gsub(/^ {10}/, '')
-          module DatabaseSetup
-            def self.registered(app)
-              app.configure { ActiveRecord::Base.logger = logger }
-              app.configure :development do
-                ActiveRecord::Base.establish_connection(
-                  :adapter => 'sqlite3',
-                  :database => Padrino.root('db', "development.db")
-                )
-              end
-
-              app.configure :production do
-                ActiveRecord::Base.establish_connection(
-                  :adapter => 'sqlite3',
-                  :database => Padrino.root('db', "production.db")
-                )
-              end
-
-              app.configure :test do
-                ActiveRecord::Base.establish_connection(
-                  :adapter => 'sqlite3',
-                  :database => Padrino.root('db', "test.db")
-                )
-              end
-            end
-          end
+          ##
+          # You can use other adapters like:
+          # 
+          #   ActiveRecord::Base.configurations[:development] = {
+          #     :adapter  => "mysql",
+          #     :host     => "localhost",
+          #     :username => "myuser",
+          #     :password => "mypass",
+          #     :database => "somedatabase"
+          #   )
+          #
+          ActiveRecord::Base.configurations[:development] = {
+            :adapter => 'sqlite3',
+            :database => Padrino.root('db', "development.db")
+          }
+
+          ActiveRecord::Base.configurations[:production] = {
+            :adapter => 'sqlite3',
+            :database => Padrino.root('db', "production.db")
+          }
+
+          ActiveRecord::Base.configurations[:test] = {
+            :adapter => 'sqlite3',
+            :database => Padrino.root('db', "test.db")
+          }
+
+          # Setup our logger
+          ActiveRecord::Base.logger = logger
+
+          # Include Active Record class name as root for JSON serialized output.
+          ActiveRecord::Base.include_root_in_json = 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
+
+          # 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 estabilish connection with our db
+          ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[Padrino.env])
           AR
 
           RAKE = (<<-RAKE).gsub(/^ {10}/, '')
@@ -51,7 +70,7 @@ module Padrino
 
 
           def setup_orm
-            require_dependencies 'activerecord'
+            require_dependencies 'active_record'
             create_file("config/database.rb", AR)
             create_file("Rakefile", RAKE.gsub(/APP_CLASS/, @class_name))
             empty_directory('app/models')
@@ -64,7 +83,7 @@ module Padrino
           MODEL
 
           def create_model_file(name, fields)
-            model_path = app_root_path('app/models/', "#{name.to_s.underscore}.rb")
+            model_path = destination_root('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
@@ -83,8 +102,6 @@ module Padrino
 
           AR_MODEL_UP_MG = (<<-MIGRATION).gsub(/^ {6}/, '')
           create_table :!TABLE! do |t|
-            # t.column <name>, <type>
-            # t.column :age, :integer
             !FIELDS!
           end
           MIGRATION
@@ -96,7 +113,7 @@ module Padrino
           def create_model_migration(migration_name, name, columns)
             output_model_migration(migration_name, name, columns,
                  :base => AR_MIGRATION,
-                 :column_format => lambda { |field, kind| "t.column :#{field}, :#{kind.underscore.gsub(/_/, '')}"  },
+                 :column_format => lambda { |field, kind| "t.#{kind.underscore.gsub(/_/, '')} :#{field}" },
                  :up => AR_MODEL_UP_MG, :down => AR_MODEL_DOWN_MG)
           end
 
@@ -109,7 +126,7 @@ module Padrino
           def create_migration_file(migration_name, name, columns)
             output_migration_file(migration_name, name, columns,
                 :base => AR_MIGRATION, :change_format => AR_CHANGE_MG,
-                :add => lambda { |field, kind| "t.column :#{field}, :#{kind.underscore.gsub(/_/, '')}" },
+                :add => lambda { |field, kind| "t.#{kind.underscore.gsub(/_/, '')} :#{field}" },
                 :remove => lambda { |field, kind| "t.remove :#{field}" })
           end
 

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

@@ -6,13 +6,12 @@ module Padrino
         module CouchrestGen
 
           COUCHREST = (<<-COUCHREST).gsub(/^ {10}/, '')
-          module DatabaseSetup
-            def self.registered(app)
-              app.configure(:development) { set :couchdb, CouchRest.database!("your_dev_db_here") }
-              app.configure(:production)  { set :couchdb, CouchRest.database!("your_production_db_here") }
-              app.configure(:test)        { set :couchdb, CouchRest.database!("your_test_db_here") }
-            end
+          case Padrino.env
+            when :development then COUCHDB = "your_db_name_development"
+            when :production  then COUCHDB = "your_db_name_production"
+            when :test        then COUCHDB = "your_db_name_test"
           end
+          CouchRest.database!(COUCHDB)
           COUCHREST
 
           def setup_orm
@@ -25,7 +24,7 @@ module Padrino
           class !NAME! < CouchRest::ExtendedDocument
             include CouchRest::Validation
 
-            use_database app { couchdb }
+            use_database COUCHDB
 
             unique_id :id
             # property <name>
@@ -34,8 +33,7 @@ module Padrino
           MODEL
 
           def create_model_file(name, fields)
-            model_path = app_root_path('app/models/', "#{name.to_s.underscore}.rb")
-            return false if File.exist?(model_path)
+            model_path = destination_root('app/models/', "#{name.to_s.underscore}.rb")
             field_tuples = 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)

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

@@ -5,20 +5,25 @@ module Padrino
 
         module DatamapperGen
           DM = (<<-DM).gsub(/^ {10}/, '')
-          module DatabaseSetup
-            def self.registered(app)
-              app.configure               { DataMapper.logger = logger }
-              app.configure(:development) { DataMapper.setup(:default, "sqlite3://" + Padrino.root('db', "development.db")) }
-              app.configure(:production)  { DataMapper.setup(:default, "sqlite3://" + Padrino.root('db', "production.db")) }
-              app.configure(:test)        { DataMapper.setup(:default, "sqlite3://" + Padrino.root('db', "test.db")) }
-            rescue ArgumentError => e
-              logger.error "Database options need to be configured within 'config/database.rb'!" if app.logging?
-            end
+          ##
+          # A MySQL connection:
+          # DataMapper.setup(:default, 'mysql://user:password@localhost/the_database_name')
+          #
+          # # A Postgres connection:
+          # DataMapper.setup(:default, 'postgres://user:password@localhost/the_database_name')
+          #
+
+          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"))
           end
           DM
 
           def setup_orm
-            require_dependencies 'dm-core', 'dm-validations'
+            require_dependencies 'dm-core', 'dm-validations', 'dm-aggregates', 'dm-timestamps'
             create_file("config/database.rb", DM)
             empty_directory('app/models')
           end
@@ -34,8 +39,7 @@ module Padrino
           MODEL
 
           def create_model_file(name, fields)
-            model_path = app_root_path('app/models/', "#{name.to_s.underscore}.rb")
-            return false if File.exist?(model_path)
+            model_path = destination_root('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.collect! { |field, kind| kind =~ /datetime/i ? [field, 'DateTime'] : [field, kind] } # fix datetime

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

@@ -6,25 +6,12 @@ module Padrino
         module MongomapperGen
 
           MONGO = (<<-MONGO).gsub(/^ {10}/, '')
-          class MongoDBConnectionFailure < RuntimeError; end
+          MongoMapper.connection = Mongo::Connection.new('localhost', nil, :logger => logger)
 
-          module DatabaseSetup
-            def self.registered(app)
-              app.configure :development do
-                MongoMapper.connection = Mongo::Connection.new('localhost', nil, :logger => logger)
-                MongoMapper.database = 'your_dev_db_here'
-              end
-
-              app.configure :production do
-                MongoMapper.connection = Mongo::Connection.new('localhost', nil, :logger => logger)
-                MongoMapper.database = 'your_production_db_here'
-              end
-
-              app.configure :test do
-                MongoMapper.connection = Mongo::Connection.new('localhost', nil, :logger => logger)
-                MongoMapper.database = 'your_test_db_here'
-              end
-            end
+          case Padrino.env
+            when :development then MongoMapper.database = 'your_db_development'
+            when :production  then MongoMapper.database = 'your_db_production'
+            when :test        then MongoMapper.database = 'your_db_test'
           end
           MONGO
 
@@ -44,8 +31,7 @@ module Padrino
           MODEL
 
           def create_model_file(name, fields)
-            model_path = app_root_path('app/models/', "#{name.to_s.underscore}.rb")
-            return false if File.exist?(model_path)
+            model_path = destination_root('app/models/', "#{name.to_s.underscore}.rb")
             field_tuples = 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)