padrino-gen 0.16.2 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f23d1c3fcf2f3fb73ac268383f3ad934b9cb3a19044fb26e5a1768fb0057034
-  data.tar.gz: 3f8c4eed5f141cdcff42e93236666fe67765ed906a1eeee3e4d77181b4b6a472
+  metadata.gz: '039917b81dc2bfbb846774da7452682d6f29af8bc1f4d76609b2ec10d8392912'
+  data.tar.gz: 451d8a83d39747bf6648d0b434f211a4571e5694f5cc70b45e9f9844ef7bfa7c
 SHA512:
-  metadata.gz: 123166a6d9ef6c9c27d0b12d464380a53ec631e1ac06379f7a6685d6710d834f56f63cb5f044747186d82359aea9370caa45b29e52fd514d6eb82d5794c91270
-  data.tar.gz: 0c9b6c6c90a123b81afdd15311ceba558afd10519506aa416abcddb52c83e0146338946d79a8ba5651f93e23d2d59c593e50d25cdf4e696fd73e3809e165aba4
+  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 datamapper
+  $ 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), less, compass, 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, extcore, dojo
-orm::        none  (default), datamapper, mongomapper, mongoid, activerecord, minirecord, sequel, couchrest, ohm, mongomatic, ripple, dynamoid
+script::     none  (default), jquery, prototype, mootools, dojo, vite
+orm::        none  (default), mongoid, activerecord, sequel
 
 In addition, you can generate projects based on existing templates:
 
@@ -56,9 +56,9 @@ To learn more about the project generator, check out the guide to
 
 Padrino provides support for plugins to be executed within your application. For example:
 
-  $ padrino-gen plugin hoptoad
+  $ padrino-gen plugin bulma
 
-would install the hoptoad middleware into your application automatically.
+would download the Bulma stylesheet into your application's public/stylesheets.
 
 To learn more about the plugin system, check out the guide to
 {Padrino Generators}[http://padrinorb.com/guides/generators/plugins/].

data/lib/padrino-gen/command.rb

@@ -13,6 +13,6 @@ module Padrino
   #
   def self.bin_gen(*args)
     @_padrino_gen_bin ||= [Padrino.ruby_command, File.expand_path('../../bin/padrino-gen', __dir__)]
-    system(*@_padrino_gen_bin, *args)
+    system(*@_padrino_gen_bin, *args.map { |arg| arg.is_a?(Symbol) ? arg.to_s : arg })
   end
 end

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,9 +65,19 @@ 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))
+        instance_eval(File.read(path, encoding: 'UTF-8'))
         shell.padding -= 1
       end
 
@@ -152,11 +168,130 @@ module Padrino
         choice = options[component]
         until valid_choice?(component, choice)
           say("Option for --#{component} '#{choice}' is not available.", :red)
-          choice = ask("Please enter a valid option for #{component}:", limited_to: choices)
+          choice = ask_valid_option(component, choices, "Please enter a valid option for #{component}:")
         end
         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 a Thor::Error instead: the generator's start prints its message and exits with status 1.
+      #
+      # @param [Symbol] option
+      #   The name of the option.
+      # @param [Array<String>] choices
+      #   The valid choices for the option.
+      # @param [String] statement
+      #   The prompt to show.
+      #
+      # @return [String] The answer entered.
+      #
+      # @example
+      #   ask_valid_option(:adapter, %w[mysql sqlite], 'Please, choose a proper adapter:')
+      #
+      def ask_valid_option(option, choices, statement)
+        answer = ask("#{statement} [#{choices.join(', ')}]")
+        raise Thor::Error, "No input left to choose a valid --#{option}; pass one of: #{choices.join(', ')}" if answer.nil?
+
+        answer
+      end
+
       ##
       # Returns true if the option passed is a valid choice for component.
       #
@@ -215,12 +350,24 @@ module Padrino
         File.exist?(destination_root('config/boot.rb'))
       end
 
+      ##
+      # Says that the generator must run at the root of a Padrino application and exits with status 1.
+      #
+      def exit_outside_app_root!
+        say 'You are not at the root of a Padrino application! (config/boot.rb not found)'
+        exit 1
+      end
+
       ##
       # Returns true if constant name already exists.
       #
       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
 
       ##
@@ -315,6 +462,18 @@ module Padrino
         gem_names.reverse_each { |lib| insert_into_gemfile(lib, options) }
       end
 
+      ##
+      # Returns true if the project runs on Falcon, which serves each request in
+      # a fiber. Uses the --server option when generating a project, and the
+      # project's Gemfile when adding a component later.
+      #
+      def falcon_server?
+        return options[:server] == 'falcon' if options[:server]
+
+        gemfile = destination_root('Gemfile')
+        File.exist?(gemfile) && File.read(gemfile).match?(/^\s*gem ['"]falcon['"]/)
+      end
+
       ##
       # Inserts a required gem into the Gemfile to add the bundler dependency.
       #
@@ -329,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"
@@ -347,7 +515,7 @@ module Padrino
       #   method hook to call from Padrino, i.e :after_load, :before_load.
       #
       # @example
-      #   insert_hook("DataMapper.finalize", :after_load)
+      #   insert_hook("SomeORM.finalize", :after_load)
       #
       def insert_hook(include_text, where)
         inject_into_file('config/boot.rb', "  #{include_text}\n", after: "Padrino.#{where} do\n")
@@ -374,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
 
       ##
@@ -392,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
 
@@ -436,11 +608,46 @@ module Padrino
       #
       def run_bundler
         say 'Bundling application dependencies using bundler...', :yellow
-        in_root { run 'bundle install --binstubs' }
+        in_root do
+          with_project_bundle_env do
+            run 'bundle install'
+            run 'bundle binstubs --all'
+          end
+        end
       end
 
+      # The variables Bundler sets up for its children (Bundler::EnvironmentPreserver::BUNDLER_KEYS).
+      BUNDLER_ENV_KEYS = %w[BUNDLE_BIN_PATH BUNDLE_GEMFILE BUNDLE_LOCKFILE BUNDLER_VERSION BUNDLER_SETUP GEM_HOME
+                            GEM_PATH MANPATH PATH RB_USER_INSTALL RUBYLIB RUBYOPT].freeze
+
       ##
-      # Raise SystemExit if the app does not exist.
+      # Runs the block with the environment for a command run on the project: the project's Gemfile
+      # and lockfile, and none of the Bundler setup (RUBYOPT=-rbundler/setup, BUNDLE_GEMFILE...) that a
+      # caller's `bundle exec` or binstub exported. Other variables are passed on as they are. With
+      # +setup+, the command loads the project's bundle first, as `bundle exec` would in the project.
+      #
+      # @param [Boolean] setup
+      #   Whether the command requires bundler/setup.
+      #
+      def with_project_bundle_env(setup: false)
+        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
+        ENV['BUNDLE_GEMFILE'] = destination_root('Gemfile')
+        ENV['BUNDLE_LOCKFILE'] = destination_root('Gemfile.lock')
+        ENV['RUBYOPT'] = ['-rbundler/setup', ENV['RUBYOPT']].compact.join(' ') if setup
+        yield
+      ensure
+        ENV.replace(saved) if saved
+      end
+
+      ##
+      # Exits with status 1 if the app does not exist.
       #
       # @param [String] app
       #   Directory name of application.
@@ -456,7 +663,7 @@ module Padrino
         say "Unable to locate '#{app.underscore.camelize}' application        "
         say '================================================================='
         say
-        raise SystemExit
+        exit 1
       end
 
       ##
@@ -488,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.
@@ -501,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
 
@@ -519,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
 
       ##
@@ -580,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
 
@@ -598,6 +806,13 @@ module Padrino
           @require_arguments
         end
 
+        ##
+        # Tells Thor to exit with status 1 when it rejects the arguments, e.g. a missing required argument.
+        #
+        def exit_on_failure?
+          true
+        end
+
         ##
         # Returns the compiled list of component types which can be specified.
         #

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

@@ -4,7 +4,10 @@ module <%= @project_name %>
     register Padrino::Mailer
     register Padrino::Helpers
 <% end -%>
-    enable :sessions
+    # 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/app.rb

@@ -43,7 +43,7 @@ module Padrino
             elsif !options[:force]
               say "#{@app_name} already exists."
               say 'Please, change the name.'
-              return
+              exit 1
             end
           end
 
@@ -67,7 +67,7 @@ module Padrino
           say "This application has been mounted to /#{@app_name.downcase}"
           say "You can configure a different path by editing 'config/apps.rb'"
         else
-          say 'You are not at the root of a Padrino application! (config/boot.rb not found)'
+          exit_outside_app_root!
         end
       end
     end

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

@@ -17,11 +17,18 @@ module Padrino
       # custom generators, so is necessary know who are.
       #
       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
@@ -29,8 +36,7 @@ module Padrino
         puts "=> Problem loading #{boot}"
         puts ["=> #{e.message}", *e.backtrace].join("\n  ")
       ensure
-        ENV.delete('BUNDLE_GEMFILE')
-        ENV.delete('PADRINO_LOG_LEVEL')
+        ENV.update(saved_env) # restores the caller's values, or removes the ones it didn't have
       end
 
       ##
@@ -43,10 +49,14 @@ module Padrino
         generator_class = Padrino::Generators.mappings[generator_kind]
 
         if generator_class
-          args = ARGV.empty? && generator_class.require_arguments? ? ['-h'] : ARGV
-          generator_class.start(args)
+          if ARGV.empty? && generator_class.require_arguments?
+            generator_class.start(['-h'])
+            exit 1
+          end
+          generator_class.start(ARGV)
         else
           puts "Please specify generator to use (#{Padrino::Generators.mappings.keys.join(', ')})"
+          exit 1 unless generator_kind == :help
         end
       end
     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,30 +42,36 @@ module Padrino
             exit
           end
 
-          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.'
-              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
         else
-          say 'You are not at the root of a Padrino application! (config/boot.rb not found)'
+          exit_outside_app_root!
         end
       end
     end

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

@@ -28,8 +28,8 @@ 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| kind =~ /datetime/i ? [field, 'DateTime'] : [field, kind] }
-            column_declarations = field_tuples.map(&options[:column_format]).join("\n      ")
+            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)
             contents = contents.gsub(/!FILENAME!/, filename.underscore).gsub(/!FILECLASS!/, filename.underscore.camelize)
@@ -70,9 +70,9 @@ 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| kind =~ /datetime/i ? [field, 'DateTime'] : [field, kind] }
-            add_columns    = tuples.map(&options[:add]).join("\n      ")
-            remove_columns = tuples.map(&options[:remove]).join("\n      ")
+            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?
             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))
@@ -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
 
         ##