padrino-gen 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4f2cbd5e5e7dbfaa0374bb83fad39536738fa404938ba59aa1296c65797a20c
-  data.tar.gz: b10595d8cc86921a9c6682cfa633ecacbf9df607925903270ee57c67ca4e2d4e
+  metadata.gz: '039917b81dc2bfbb846774da7452682d6f29af8bc1f4d76609b2ec10d8392912'
+  data.tar.gz: 451d8a83d39747bf6648d0b434f211a4571e5694f5cc70b45e9f9844ef7bfa7c
 SHA512:
-  metadata.gz: 513c6bfd2e9d9b8dde54280fd54fe33fb9f675fb213d14d3a14367f93ceaaf3395d060be2f42655fedeee875b0e0de2721caadcbba0ffffa7ede97e2f7bf50a5
-  data.tar.gz: ddef4dd75dbe398a17faec64813e8d5f798969770148d9a9595aa327748db9ab603b2a49633ee7d74040d5d96b86acaddc69630fd561b39a9a8ede6cf302643c
+  metadata.gz: c0769c35ccfe2cff70e99aa0c137b825e285e831649945d18e07e5ea72b44efcc1214f3fb3ebc63661d0b0c8371e84c78dcb5fff6b7472471c83176e3dd1b40e
+  data.tar.gz: 45b9f905e803023d7932ceb487ade75bbcd5df395754f820cc86626176de272bb422ef5696d3665027b80f7a8f1d34436f266b02c8bb27d9938fbbcce410baf1

data/README.rdoc

@@ -24,13 +24,13 @@ The simplest possible command to generate a base application would be:
 
   $ padrino-gen project demo_project
 
-This would construct a Padrino application DemoApp (which extends from Padrino::Application)
+This would construct a Padrino application DemoProject::App (which extends from Padrino::Application)
 inside the folder 'demo_project' at our current path. Inside the application there would be configuration and
 setup performed for the default components.
 
 You can define specific components to be used:
 
-  $ padrino-gen project demo_project -t rspec -r haml -m rr -s jquery -d sequel
+  $ padrino-gen project demo_project -t rspec -e haml -m rr -s jquery -d sequel
 
 You can also instruct the generator to skip a certain component to avoid using one at all (or to use your own):
 
@@ -39,11 +39,11 @@ You can also instruct the generator to skip a certain component to avoid using o
 The available components and their default options are listed below:
 
 test::       none  (default), bacon, shoulda, cucumber, rspec, minitest, testunit
-renderer::   none  (default), slim, erb, erubis, liquid, haml
-stylesheet:: none  (default), tailwind, less, sass, scss
+renderer::   none  (default), slim, erb, liquid, haml
+stylesheet:: none  (default), tailwind, sass, scss
 mock::       none  (default), mocha, rr
 script::     none  (default), jquery, prototype, mootools, dojo, vite
-orm::        none  (default), mongoid, activerecord, minirecord, sequel, ohm, dynamoid
+orm::        none  (default), mongoid, activerecord, sequel
 
 In addition, you can generate projects based on existing templates:
 

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

@@ -10,6 +10,12 @@ module Padrino
     #
     DEFAULT_HELPER_NAME = 'Helper'.freeze
 
+    ##
+    # The SQL adapters for --adapter, and the ORM components that set up their database with one.
+    #
+    SQL_ADAPTERS = %w[mysql mysql2 mysql-gem postgres sqlite].freeze
+    SQL_ADAPTER_ORMS = %w[activerecord sequel].freeze
+
     ##
     # Common actions needed to support project and component generation.
     #
@@ -59,6 +65,16 @@ module Padrino
       def apply_component_for(choice, component)
         # I need to override Thor#apply because for unknown reason verbose: false break tasks.
         path = File.expand_path(__dir__ + "/components/#{component.to_s.pluralize}/#{choice}.rb")
+        unless File.exist?(path)
+          # An existing project's .components can name a component that has since been removed.
+          available = Dir["#{__dir__}/components/#{component.to_s.pluralize}/*.rb"].map { |lib| File.basename(lib, '.rb') }.sort
+          if choice.to_s.empty?
+            say "The project's .components sets no #{component} component (available: #{available.join(', ')})."
+          else
+            say "The #{choice} #{component} component is no longer available in Padrino (available: #{available.join(', ')})."
+          end
+          exit 1
+        end
         say_status :apply, "#{component.to_s.pluralize}/#{choice}"
         shell.padding += 1
         instance_eval(File.read(path, encoding: 'UTF-8'))
@@ -157,10 +173,105 @@ module Padrino
         choice
       end
 
+      ##
+      # Prompts the user if necessary until options[:adapter] or the answer is a valid SQL adapter, and keeps it.
+      #
+      # @return [String] Name of the SQL adapter.
+      #
+      # @example
+      #   resolve_valid_adapter # => 'sqlite'
+      #
+      def resolve_valid_adapter
+        @_adapter ||= begin
+          adapter = options[:adapter] || stored_adapter || 'sqlite'
+          until SQL_ADAPTERS.include?(adapter)
+            say("Option for --adapter '#{adapter}' is not available.", :red)
+            adapter = ask_valid_option(:adapter, SQL_ADAPTERS, 'Please enter a valid option for adapter:')
+          end
+          adapter
+        end
+      end
+
+      ##
+      # Returns whether `padrino g component` is applying a component the project already has,
+      # rather than adding it or switching to it. Files the project may have edited stay as they are then.
+      #
+      # @param [Symbol] component
+      #   The type of component module.
+      #
+      # @return [Boolean] Whether the chosen component is the one the project has.
+      #
+      def reapplying_component?(component)
+        !@_stored_components.nil? && @_stored_components[component].to_s == @_components[component].to_s
+      end
+
+      ##
+      # Removes the lines the project's mock component added to the test helper, when `padrino g component`
+      # switches to another mock. Each mock file defines mock_setup_lines(test), the lines its setup_mock adds;
+      # the previous mock's file is evaluated on a separate object, so its methods don't replace the new mock's.
+      # Only lines that are still exactly as written (indentation aside) are removed; other edits stay.
+      #
+      # @param [String] test
+      #   The test component the new mock is set up for.
+      #
+      def remove_previous_mock_setup(test)
+        previous = @_stored_components && @_stored_components[:mock].to_s
+        return if previous.nil? || previous.empty? || previous == 'none' || reapplying_component?(:mock)
+        source = File.expand_path("components/mocks/#{previous}.rb", __dir__)
+        return unless File.exist?(source)
+
+        probe = Object.new
+        probe.instance_eval(File.read(source, encoding: 'UTF-8'), source)
+        setup = probe.respond_to?(:mock_setup_lines) && probe.mock_setup_lines(test)
+        return unless setup && File.exist?(destination_root(setup[:path]))
+
+        content = File.binread(destination_root(setup[:path]))
+        # The mocks insert after the same line; if the project edited it, the new mock can't be added, so keep the old one.
+        return unless content.include?(setup[:after].b)
+
+        lines = setup[:text].each_line.map(&:strip).reject(&:empty?).uniq
+        pattern = /^[ \t]*(?:#{lines.map { |line| Regexp.escape(line) }.join('|')})[ \t]*(?:\n|\z)/
+        gsub_file(setup[:path], pattern, '') if content.match?(pattern)
+      end
+
+      ##
+      # Returns whether config/database.rb stays: the orm is the project's, and so is any --adapter given.
+      #
+      # @return [Boolean] Whether to keep an existing database config.
+      #
+      def keep_database_config?
+        # An --adapter corrected at the prompt counts as the corrected one, which resolve_valid_adapter keeps in @_adapter.
+        given = options[:adapter] && (@_adapter || options[:adapter])
+        reapplying_component?(:orm) && [nil, stored_adapter].include?(given)
+      end
+
+      ##
+      # Returns whether the SQL adapter of the project is unknown: it is applying the orm the project
+      # has, without --adapter, in a project that has a database config but no stored adapter
+      # (generated by an older version). The config stays and no driver is added then.
+      #
+      # @return [Boolean] Whether the adapter is unknown.
+      #
+      def adapter_unknown?
+        return @_adapter_unknown if defined?(@_adapter_unknown)
+
+        @_adapter_unknown = reapplying_component?(:orm) && options[:adapter].nil? && stored_adapter.nil? &&
+                            File.exist?(destination_root('config/database.rb'))
+      end
+
+      ##
+      # Returns the SQL adapter stored for the project, if any. Projects generated by older versions have none.
+      #
+      # @return [String, nil] Name of the SQL adapter.
+      #
+      def stored_adapter
+        @_stored_components && @_stored_components[:adapter]
+      end
+
       ##
       # Asks once for one of the valid choices of an option; callers re-ask while the answer is invalid.
       # Thor's limited_to: would repeat the prompt forever at the end of input (no terminal, empty pipe),
-      # so that case raises instead.
+      # so that case raises a Thor::Error instead: the generator's start prints its message and exits with status 1.
       #
       # @param [Symbol] option
       #   The name of the option.
@@ -176,7 +287,7 @@ module Padrino
       #
       def ask_valid_option(option, choices, statement)
         answer = ask("#{statement} [#{choices.join(', ')}]")
-        raise "No input left to choose a valid --#{option}; pass one of: #{choices.join(', ')}" if answer.nil?
+        raise Thor::Error, "No input left to choose a valid --#{option}; pass one of: #{choices.join(', ')}" if answer.nil?
 
         answer
       end
@@ -253,6 +364,10 @@ module Padrino
       def already_exists?(name, project_name = nil)
         project_name = project_name ? (Object.const_get(project_name) rescue nil) : nil
         Object.const_defined?(name) || project_name&.const_defined?(name)
+      rescue ::NameError => e
+        # Only Ruby's rejection of the name itself; a NameError from code that autoloading runs is a real error.
+        raise unless e.instance_of?(::NameError) && e.message.start_with?('wrong constant name')
+        raise Thor::Error, "#{name} is not a valid constant name"
       end
 
       ##
@@ -373,9 +488,18 @@ module Padrino
       #   insert_into_gemfile(name, group: 'test', version: ">1.2.3")
       #
       def insert_into_gemfile(name, options = {})
-        after_pattern = options[:group] ? "#{options[:group].to_s.capitalize} requirements\n" : "Component requirements\n"
-        version       = options.delete(:version)
-        gem_options   = options.map { |k, v| k.to_s == 'require' && [true, false].include?(v) ? "#{k}: #{v}" : "#{k}: '#{v}'" }.join(', ')
+        # Generated Gemfiles only have a "Test requirements" section; other groups go with the components.
+        group_pattern = "#{options[:group].to_s.capitalize} requirements\n" if options[:group]
+        gemfile = destination_root('Gemfile')
+        after_pattern = group_pattern if group_pattern && File.exist?(gemfile) && File.read(gemfile).include?(group_pattern)
+        after_pattern ||= "Component requirements\n"
+        version       = options[:version]
+        gem_options   = options.reject { |k, _| k == :version }.map do |k, v|
+          if v.is_a?(Array) then "#{k}: #{v.inspect}"
+          elsif k.to_s == 'require' && [true, false].include?(v) then "#{k}: #{v}"
+          else "#{k}: '#{v}'"
+          end
+        end.join(', ')
         write_option  = gem_options.empty? ? '' : ", #{gem_options}"
         write_version = version ? ", '#{version}'" : ''
         include_text  = "gem '#{name}'" << write_version << write_option << "\n"
@@ -418,16 +542,18 @@ module Padrino
       #   Name of the initializer.
       # @param [String] data
       #   Text to generate into the initializer file.
+      # @param [Boolean] skip
+      #   Whether to keep an existing initializer file.
       #
       # @example
       #   initializer(:test, "some stuff here")
       #   #=> generates 'lib/test_init.rb'
       #
-      def initializer(name, data = nil)
+      def initializer(name, data = nil, skip: false)
         @_init_name, @_init_data = name, data
         register = data ? "    register #{name.to_s.underscore.camelize}Initializer\n" : "    register #{name}\n"
         inject_into_file destination_root('/app/app.rb'), register, after: "Padrino::Application\n"
-        template 'templates/initializer.rb.tt', destination_root("/config/initializers/#{name}.rb") if data
+        template 'templates/initializer.rb.tt', destination_root("/config/initializers/#{name}.rb"), skip: skip if data
       end
 
       ##
@@ -436,13 +562,15 @@ module Padrino
       #   Name of the middleware.
       # @param [String] source
       #   Text to generate into the middleware file.
+      # @param [Boolean] skip
+      #   Whether to keep an existing middleware file.
       #
       # @example
       #   middleware(:hello, "class Hello\nend")
       #   #=> generates 'lib/hello_middleware.rb'
       #
-      def middleware(name, source)
-        create_file destination_root("lib/#{name}_middleware.rb"), source
+      def middleware(name, source, skip: false)
+        create_file destination_root("lib/#{name}_middleware.rb"), source, skip: skip
         insert_middleware name.to_s.underscore.camelize
       end
 
@@ -505,6 +633,8 @@ module Padrino
         saved = ENV.to_h
         if defined?(Bundler) && Bundler.respond_to?(:original_env)
           original = Bundler.original_env
+          # ceiling: a template's own changes to Bundler's keys (PATH, RUBYOPT, GEM_PATH...) made after Bundler loaded
+          # don't reach its steps; upgrade: re-apply the diff from a snapshot taken when the runner starts.
           BUNDLER_ENV_KEYS.each { |key| original.key?(key) ? ENV[key] = original[key] : ENV.delete(key) }
           ENV.keys.grep(/\ABUNDLER_ORIG_/).each { |key| ENV.delete(key) }
         end
@@ -565,7 +695,8 @@ module Padrino
       end
 
       ##
-      # Ensures that project name is valid, else raise an NameError.
+      # Ensures that project name is valid, else raises a Thor::Error: the generator's start prints its
+      # message and exits with status 1.
       #
       # @param [String] name
       #   Name of project.
@@ -578,9 +709,9 @@ module Padrino
       #
       def valid_constant?(name)
         if name =~ /^\d/
-          raise ::NameError, "Constant name #{name} cannot start with numbers"
+          raise Thor::Error, "Constant name #{name} cannot start with numbers"
         elsif name =~ /^\W/
-          raise ::NameError, "Constant name #{name} cannot start with non-word character"
+          raise Thor::Error, "Constant name #{name} cannot start with non-word character"
         end
       end
 
@@ -596,7 +727,7 @@ module Padrino
       #
       def validate_namespace(name)
         valid_constant? name
-        name.match(/^[[:alnum:]_]+$/) || raise(::NameError, "Namespace '#{name}' must consist only of alphanumeric characters or '_'")
+        name.match(/^[[:alnum:]_]+$/) || raise(Thor::Error, "Namespace '#{name}' must consist only of alphanumeric characters or '_'")
       end
 
       ##
@@ -657,7 +788,7 @@ module Padrino
             [:stylesheet, 'stylesheet engine',  { aliases: '-c', default: :none }]
           ].each do |name, caption, opts|
             opts[:default] = '' if options[:default] == false
-            component_option name, caption, opts.merge(choices: Dir["#{__dir__}/components/#{name.to_s.pluralize}/*.rb"].map { |lib| File.basename(lib, '.rb').to_sym })
+            component_option name, caption, opts.merge(choices: Dir["#{__dir__}/components/#{name.to_s.pluralize}/*.rb"].map { |lib| File.basename(lib, '.rb') }.sort.map(&:to_sym))
           end
         end
 

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

@@ -4,8 +4,10 @@ module <%= @project_name %>
     register Padrino::Mailer
     register Padrino::Helpers
 <% end -%>
-    set :sessions, same_site: :lax
-    # set :sessions, same_site: :lax, secure: true # Send the session cookie over HTTPS only
+    # The session cookie is Secure (sent over HTTPS only) in production. Over plain HTTP
+    # the app then sends no session cookie, so logins and CSRF-protected forms fail. Behind
+    # a proxy that terminates TLS, have it send X-Forwarded-Proto: https, or set secure: false.
+    set :sessions, same_site: :lax, secure: Padrino.env == :production
 
     ##
     # Caching support.

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

@@ -19,10 +19,16 @@ module Padrino
       def load_boot
         saved_env = { 'BUNDLE_GEMFILE' => ENV['BUNDLE_GEMFILE'], 'PADRINO_LOG_LEVEL' => ENV['PADRINO_LOG_LEVEL'] }
         ENV['PADRINO_LOG_LEVEL'] ||= 'test'
-        ENV['BUNDLE_GEMFILE'] = File.join(options[:root], 'Gemfile') if options[:root]
-        boot = options[:root] ? File.join(options[:root], 'config/boot.rb') : 'config/boot.rb'
+        root = File.expand_path(options[:root] || '.')
+        ENV['BUNDLE_GEMFILE'] = File.join(root, 'Gemfile') if options[:root]
+        boot = File.join(root, 'config/boot.rb')
         if File.exist?(boot)
-          require File.expand_path(boot)
+          # Boot from the project root, as `padrino start`, rake and the binstubs do, so that its relative paths
+          # (such as a sqlite database in config/database.rb) don't resolve against the caller's directory.
+          # ceiling: only the boot runs there; a path the project opens lazily after boot (an ActiveRecord connection
+          # to a relative path) still resolves against the caller's directory. Running the whole generator from the
+          # root would cover it.
+          Dir.chdir(root) { require boot }
         else
           require 'padrino-support'
         end

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

@@ -17,7 +17,7 @@ module Padrino
 
       class_option :app,     desc: 'The application name',                                             aliases: '-n', default: nil,         type: :string
       class_option :root,    desc: 'The root destination',                                             aliases: '-r', default: '.',         type: :string
-      class_option :adapter, desc: 'SQL adapter for ORM (sqlite, mysql, mysql2, mysql-gem, postgres)', aliases: '-a', default: 'sqlite',    type: :string
+      class_option :adapter, desc: 'SQL adapter for ORM (sqlite, mysql, mysql2, mysql-gem, postgres)', aliases: '-a', default: nil,         type: :string
 
       defines_component_options default: false
 
@@ -28,6 +28,7 @@ module Padrino
         self.destination_root = options[:root]
         if in_app_root?
           @_components = options.class.new(options.slice(*self.class.component_types))
+          @_stored_components = retrieve_component_config(destination_root('.components'))
           @app_name = (options[:app] || 'App').gsub(/\W/, '_').camelize
           if @_components.values.delete_if(&:empty?).empty?
             self.class.start(['-h'])
@@ -41,31 +42,34 @@ module Padrino
             exit
           end
 
-          missing_app = false
-          self.class.component_types.each do |comp|
-            next if @_components[comp].empty?
-
-            choice = @_components[comp] = resolve_valid_choice(comp)
+          # Settle every choice, switch and check before applying any, so a failure leaves the project unchanged.
+          chosen = self.class.component_types.reject { |comp| @_components[comp].empty? }
+          chosen.each { |comp| @_components[comp] = resolve_valid_choice(comp) }
+          chosen.select! do |comp|
+            choice = @_components[comp]
             existing = fetch_component_choice(comp)
             ask = existing != 'none' && existing != choice
-            next if ask && !yes?("Switch #{comp} to '#{choice}' from '#{existing}' ?[yes/no]:")
+            !ask || yes?("Switch #{comp} to '#{choice}' from '#{existing}' ?[yes/no]:")
+          end
 
-            @project_name = fetch_component_choice(:namespace)
-            if comp.to_s == 'test' && !already_exists?(@app_name, @project_name)
-              say "#{@project_name}::#{@app_name} does not exist."
-              say 'Please, change app name.'
-              missing_app = true
-              next
-            end
+          @project_name = fetch_component_choice(:namespace)
+          if chosen.include?(:test) && !already_exists?(@app_name, @project_name)
+            say "#{@project_name}::#{@app_name} does not exist."
+            say 'Please, change app name.'
+            exit 1
+          end
+          resolve_valid_adapter if chosen.include?(:orm) && SQL_ADAPTER_ORMS.include?(@_components[:orm])
 
+          chosen.each do |comp|
+            choice = @_components[comp]
             execute_component_setup(comp, choice)
             store_component_choice(comp, choice)
+            store_component_choice(:adapter, resolve_valid_adapter) if comp.to_s == 'orm' && SQL_ADAPTER_ORMS.include?(choice) && !adapter_unknown?
             if comp.to_s == 'orm' && choice.to_s != 'none'
               inject_into_file destination_root('Rakefile'), "PadrinoTasks.use(:database)\n", before: 'PadrinoTasks.init'
               inject_into_file destination_root('Rakefile'), "PadrinoTasks.use(#{choice.to_sym.inspect})\n", before: 'PadrinoTasks.init'
             end
           end
-          exit 1 if missing_app
         else
           exit_outside_app_root!
         end

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

@@ -28,7 +28,7 @@ module Padrino
             return if migration_exist?(filename)
             model_name = name.to_s.pluralize
             field_tuples = columns.map { |value| value.split(':') }
-            field_tuples.map! { |field, kind, index| [field, kind =~ /datetime/i ? 'DateTime' : kind, index] }
+            field_tuples.map! { |field, kind, *modifiers| [field, kind =~ /datetime/i ? 'DateTime' : kind, *modifiers] }
             column_declarations = field_tuples.flat_map(&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.underscore.camelize).gsub(/!TABLE!/, model_name.underscore)
@@ -70,7 +70,7 @@ module Padrino
             migration_scan = filename.underscore.camelize.scan(/(Add|Remove).*?(?:(?:To|From).+?)*(?:To|From)((?:To|From)?.*?)$/).flatten
             direction, table_name = migration_scan[0].downcase, migration_scan[1].downcase.pluralize if migration_scan.any?
             tuples = direction ? columns.map { |value| value.split(':') } : []
-            tuples.map! { |field, kind, index| [field, kind =~ /datetime/i ? 'DateTime' : kind, index] }
+            tuples.map! { |field, kind, *modifiers| [field, kind =~ /datetime/i ? 'DateTime' : kind, *modifiers] }
             add_columns    = tuples.flat_map(&options[:add]).join("\n      ")
             remove_columns = tuples.flat_map(&options[:remove]).join("\n      ")
             forward_text = change_format.gsub(/!TABLE!/, table_name).gsub(/!COLUMNS!/, add_columns) if tuples.any?
@@ -145,7 +145,8 @@ module Padrino
         #
         def insert_test_suite_setup(suite_text, options = {})
           options = { path: 'test/test_config.rb' }.update(options)
-          create_file(options[:path], suite_text.gsub(/CLASS_NAME/, "#{@project_name}::#{@app_name}"))
+          # --app points the setup at another app, so that run rewrites it.
+          create_file(options[:path], suite_text.gsub(/CLASS_NAME/, "#{@project_name}::#{@app_name}"), skip: reapplying_component?(:test) && !self.options[:app])
         end
 
         ##

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

@@ -1,17 +1,23 @@
+# The lines setup_mock adds for a test component: the helper file, the line they follow, and the lines.
+# A switch to another mock removes them through remove_previous_mock_setup.
+def mock_setup_lines(test)
+  {
+    'rspec' => { path: 'spec/spec_helper.rb', after: "RSpec.configure do |conf|\n", text: "  conf.mock_with :mocha\n" },
+    'minitest' => { path: 'test/test_config.rb', after: "require_relative '../config/boot'\n", text: "require 'mocha/minitest'\n" },
+    'testunit' => { path: 'test/test_config.rb', after: "require_relative '../config/boot'\n", text: "require 'mocha/test_unit'\n" },
+    'shoulda' => { path: 'test/test_config.rb', after: "require \"test/unit\"\n", text: "require 'mocha/test_unit'\n" }
+  }[test.to_s]
+end
+
 def setup_mock
   require_dependencies 'mocha', group: 'test', require: false
 
   test = options[:test].to_s
   test = fetch_component_choice(:test).to_s if test.empty?
-  case test
-  when 'rspec'
-    inject_into_file 'spec/spec_helper.rb', "  conf.mock_with :mocha\n", after: "RSpec.configure do |conf|\n"
-  when 'minitest'
-    inject_into_file 'test/test_config.rb', "require 'mocha/minitest'\n", after: "require_relative '../config/boot'\n"
-  when 'testunit'
-    inject_into_file 'test/test_config.rb', "require 'mocha/test_unit'\n", after: "require_relative '../config/boot'\n"
-  when 'shoulda'
-    inject_into_file 'test/test_config.rb', "require 'mocha/test_unit'\n", after: "require \"test/unit\"\n"
+  if (setup = mock_setup_lines(test))
+    inject_into_file setup[:path], setup[:text], after: setup[:after]
+    # After the insert, so a helper Thor fails to read keeps the previous mock.
+    remove_previous_mock_setup(test)
   else
     say "Mocha is in the Gemfile but not set up for the '#{test}' test component. To use it, require mocha/api " \
         'and call mocha_setup, mocha_verify and mocha_teardown around each test: https://github.com/freerange/mocha#readme', :yellow

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

@@ -1,11 +1,29 @@
+# The lines setup_mock adds for a test component: the helper file, the line they follow, and the lines.
+# A switch to another mock removes them through remove_previous_mock_setup.
+def mock_setup_lines(test)
+  rspec = "  conf.mock_with :rr\n" \
+          "  # On ExampleGroup, not conf.include, so RSpec's own matchers (satisfy) stay ahead of rr's DSL.\n" \
+          "  RSpec::Core::ExampleGroup.include RR::DSL\n"
+  {
+    'rspec' => { path: 'spec/spec_helper.rb', after: "RSpec.configure do |conf|\n", text: rspec },
+    'minitest' => { path: 'test/test_config.rb', after: "require_relative '../config/boot'\n", text: "require 'rr'\n" },
+    'testunit' => { path: 'test/test_config.rb', after: "require_relative '../config/boot'\n", text: "require 'test/unit/rr'\n" },
+    'shoulda' => { path: 'test/test_config.rb', after: "require \"test/unit\"\n", text: "require 'test/unit/rr'\n" }
+  }[test.to_s]
+end
+
 def setup_mock
   require_dependencies 'rr', require: false, group: 'test'
-  case options[:test].to_s
-  when 'rspec'
-    inject_into_file 'spec/spec_helper.rb', "require 'rr'\n", after: "'../config/boot'\n"
-  when 'minitest'
-    insert_mocking_include 'RR::Adapters::MiniTest', path: 'test/test_config.rb'
+
+  test = options[:test].to_s
+  test = fetch_component_choice(:test).to_s if test.empty?
+  require_dependencies 'test-unit-rr', require: false, group: 'test' if %w[testunit shoulda].include?(test)
+  if (setup = mock_setup_lines(test))
+    inject_into_file setup[:path], setup[:text], after: setup[:after]
+    # After the insert, so a helper Thor fails to read keeps the previous mock.
+    remove_previous_mock_setup(test)
   else
-    insert_mocking_include 'RR::Adapters::TestUnit', path: 'test/test_config.rb'
+    say "RR is in the Gemfile but not set up for the '#{test}' test component. To use it, require 'rr', include RR::DSL " \
+        'where your tests run, and call RR.reset before and RR.verify after each test: https://github.com/rr/rr#readme', :yellow
   end
 end

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

@@ -115,35 +115,27 @@ def setup_orm
   ar = AR.dup
   db = @project_name.underscore
 
-  begin
-    case adapter ||= options[:adapter]
-    when 'mysql-gem'
-      ar.sub!(/!DB_DEVELOPMENT!/, MYSQL.sub(/!DB_NAME!/, "'#{db}_development'"))
-      ar.sub!(/!DB_PRODUCTION!/, MYSQL.sub(/!DB_NAME!/, "'#{db}_production'"))
-      ar.sub!(/!DB_TEST!/, MYSQL.sub(/!DB_NAME!/, "'#{db}_test'"))
-      require_dependencies 'mysql', version: '~> 2.8.1'
-    when 'mysql', 'mysql2'
-      ar.sub!(/!DB_DEVELOPMENT!/, MYSQL2.sub(/!DB_NAME!/, "'#{db}_development'"))
-      ar.sub!(/!DB_PRODUCTION!/, MYSQL2.sub(/!DB_NAME!/, "'#{db}_production'"))
-      ar.sub!(/!DB_TEST!/, MYSQL2.sub(/!DB_NAME!/, "'#{db}_test'"))
-      require_dependencies 'mysql2'
-    when 'postgres'
-      ar.sub!(/!DB_DEVELOPMENT!/, POSTGRES.sub(/!DB_NAME!/, "'#{db}_development'"))
-      ar.sub!(/!DB_PRODUCTION!/, POSTGRES.sub(/!DB_NAME!/, "'#{db}_production'"))
-      ar.sub!(/!DB_TEST!/, POSTGRES.sub(/!DB_NAME!/, "'#{db}_test'"))
-      require_dependencies 'pg'
-    when 'sqlite'
-      ar.sub!(/!DB_DEVELOPMENT!/, SQLITE.sub(/!DB_NAME!/, "Padrino.root('db', '#{db}_development.db')"))
-      ar.sub!(/!DB_PRODUCTION!/, SQLITE.sub(/!DB_NAME!/, "Padrino.root('db', '#{db}_production.db')"))
-      ar.sub!(/!DB_TEST!/, SQLITE.sub(/!DB_NAME!/, "Padrino.root('db', '#{db}_test.db')"))
-      require_dependencies 'sqlite3'
-    else
-      say "Failed to generate `config/database.rb` for ORM adapter `#{adapter}`", :red
-      raise ArgumentError
-    end
-  rescue ArgumentError
-    adapter = ask_valid_option(:adapter, %w[mysql mysql2 mysql-gem postgres sqlite], 'Please, choose a proper adapter:')
-    retry
+  case (resolve_valid_adapter unless adapter_unknown?)
+  when 'mysql-gem'
+    ar.sub!(/!DB_DEVELOPMENT!/, MYSQL.sub(/!DB_NAME!/, "'#{db}_development'"))
+    ar.sub!(/!DB_PRODUCTION!/, MYSQL.sub(/!DB_NAME!/, "'#{db}_production'"))
+    ar.sub!(/!DB_TEST!/, MYSQL.sub(/!DB_NAME!/, "'#{db}_test'"))
+    require_dependencies 'mysql', version: '~> 2.8.1'
+  when 'mysql', 'mysql2'
+    ar.sub!(/!DB_DEVELOPMENT!/, MYSQL2.sub(/!DB_NAME!/, "'#{db}_development'"))
+    ar.sub!(/!DB_PRODUCTION!/, MYSQL2.sub(/!DB_NAME!/, "'#{db}_production'"))
+    ar.sub!(/!DB_TEST!/, MYSQL2.sub(/!DB_NAME!/, "'#{db}_test'"))
+    require_dependencies 'mysql2'
+  when 'postgres'
+    ar.sub!(/!DB_DEVELOPMENT!/, POSTGRES.sub(/!DB_NAME!/, "'#{db}_development'"))
+    ar.sub!(/!DB_PRODUCTION!/, POSTGRES.sub(/!DB_NAME!/, "'#{db}_production'"))
+    ar.sub!(/!DB_TEST!/, POSTGRES.sub(/!DB_NAME!/, "'#{db}_test'"))
+    require_dependencies 'pg'
+  when 'sqlite'
+    ar.sub!(/!DB_DEVELOPMENT!/, SQLITE.sub(/!DB_NAME!/, "Padrino.root('db', '#{db}_development.db')"))
+    ar.sub!(/!DB_PRODUCTION!/, SQLITE.sub(/!DB_NAME!/, "Padrino.root('db', '#{db}_production.db')"))
+    ar.sub!(/!DB_TEST!/, SQLITE.sub(/!DB_NAME!/, "Padrino.root('db', '#{db}_test.db')"))
+    require_dependencies 'sqlite3'
   end
 
   require_dependencies 'activerecord', require: 'active_record', version: '>= 3.1'
@@ -156,8 +148,8 @@ def setup_orm
     FIBER
   end
 
-  create_file('config/database.rb', ar)
-  middleware :connection_pool_management, CONNECTION_POOL_MIDDLEWARE
+  create_file('config/database.rb', ar, skip: keep_database_config?)
+  middleware :connection_pool_management, CONNECTION_POOL_MIDDLEWARE, skip: reapplying_component?(:orm)
 end
 
 AR_MODEL = <<~MODEL unless defined?(AR_MODEL)
@@ -214,11 +206,24 @@ def ar_reference?(kind)
   %w[references belongs_to].include?(kind.underscore)
 end
 
-# A third field segment, as in user_id:integer:index or email:string:uniq, adds an index.
-def ar_add_column(field, kind, index)
+# Segments after the kind are modifiers, in any order: index or uniq adds one index (uniq wins),
+# as in user_id:integer:index or email:string:uniq. On a reference polymorphic adds a type column,
+# as in commentable:references:polymorphic, and combines with an index: owner:references:polymorphic:uniq.
+def ar_index_modifier(modifiers)
+  if modifiers.include?('uniq') then 'uniq'
+  elsif modifiers.include?('index') then 'index'
+  end
+end
+
+def ar_polymorphic_option(modifiers)
+  ', polymorphic: true' if modifiers.include?('polymorphic')
+end
+
+def ar_add_column(field, kind, modifiers)
+  index = ar_index_modifier(modifiers)
   if ar_reference?(kind)
     index_option = { 'index' => ', index: true', 'uniq' => ', index: { unique: true }' }[index]
-    return "t.#{kind.underscore} :#{field}#{index_option}"
+    return "t.#{kind.underscore} :#{field}#{ar_polymorphic_option(modifiers)}#{index_option}"
   end
 
   columns = ["t.#{kind.underscore.gsub(/_/, '')} :#{field}"]
@@ -227,16 +232,18 @@ def ar_add_column(field, kind, index)
   columns
 end
 
-# Removing a column also removes its indexes.
-def ar_remove_column(field, kind)
-  ar_reference?(kind) ? "t.remove_references :#{field}" : "t.remove :#{field}"
+# Removing a column also removes its indexes. A polymorphic reference also drops its type column.
+def ar_remove_column(field, kind, modifiers)
+  return "t.remove :#{field}" unless ar_reference?(kind)
+
+  "t.remove_references :#{field}#{ar_polymorphic_option(modifiers)}"
 end
 
 def create_model_migration(migration_name, name, columns)
   output_model_migration(
     migration_name, name, columns,
     base: AR_MIGRATION,
-    column_format: proc { |field, kind, index| ar_add_column(field, kind, index) },
+    column_format: proc { |field, kind, *modifiers| ar_add_column(field, kind, modifiers) },
     up: AR_MODEL_UP_MG,
     down: AR_MODEL_DOWN_MG
   )
@@ -253,7 +260,7 @@ def create_migration_file(migration_name, name, columns)
     migration_name, name, columns,
     base: AR_MIGRATION,
     change_format: AR_CHANGE_MG,
-    add: proc { |field, kind, index| ar_add_column(field, kind, index) },
-    remove: proc { |field, kind| ar_remove_column(field, kind) }
+    add: proc { |field, kind, *modifiers| ar_add_column(field, kind, modifiers) },
+    remove: proc { |field, kind, *modifiers| ar_remove_column(field, kind, modifiers) }
   )
 end