railstart 0.4.5 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 335bb58fb0448ef183a5dab96d9d866e212d75a09310db0ed4c017d9e27cf327
-  data.tar.gz: 42fea9cfc2d16dc6b167eb8580f108d43a940f6809de97c308cc64d467bb5056
+  metadata.gz: 074af527c055fff27ba43418de8c9c1085cdce74ac7e6bccac0509c32fa7536d
+  data.tar.gz: 8aa05e748770810612c88e8f0ac3b48fe9efdcdedd95278aa499e7387acf0410
 SHA512:
-  metadata.gz: a7b8a26a4060fc6e1c449ab759d5dbbf8911ceba0166a8ce5b094fe81f069ee70b38c9ee88671f38e91eb4f1a6cb4f334815c8457efccc570a9fc57d94f7bf12
-  data.tar.gz: 29d65e728974f716e6d514135f574b48a7b335842c9330e6457553462bf943dcc5b9beead5e5c5bcfb4212a8c6b30301f689df342e861e2e7f83bfce345f6729
+  metadata.gz: '01941cbb9ee8f2e281b70c5abfb2b22088b1b305909b225d3b7ed2a7c8e277deaf5c5e019f8397d3846148f73f3213625668492878db326ff800945357c1f7c8'
+  data.tar.gz: 7d194a1c4372ba55671974b54ed710d19333f6af0626797a743a05d30da982e3bdc08a792c5baca8956680f6bb2e0bd10c0acb76220ae48c89fbd298007b2eef

data/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-07-11
+
+### Added
+- **Ruby 4.0.5 coverage**: Pinned development and release workflows to Ruby 4.0.5 and added exact Ruby 4.0.5 coverage to the existing CI matrix
+- **Rails contract coverage**: Added opt-in `rails new --pretend` checks for the built-in configuration and every shipped preset
+- **Config validation**: Added fail-fast validation for duplicate IDs, invalid defaults, malformed flags, dependency conditions, post-action conditions, and template variable names
+
+### Changed
+- **Development dependencies**: Updated Minitest to 6.0.6, Rake to 13.4.2, RuboCop to 1.88.2, and YARD to 0.9.44
+- **Safe command execution**: Rails generation now executes an argument vector instead of a shell-interpreted command string
+- **Init command**: `railstart init` now generates minimal user overrides so future built-in choices and flags are not shadowed by a copied full configuration
+- **CI quality gate**: CI now runs tests, RuboCop, YARD, gem packaging, executable smoke checks, and Rails CLI contract checks
+
+### Fixed
+- **API-only preset**: The CSS `none` choice now emits `--skip-css` instead of the invalid `--css=none`
+- **Documentation build**: Declared the Markdown documentation dependencies and made YARD fail on warnings
+
 ## [0.4.5] - 2026-04-30
 
 ### Added

data/README.md

@@ -8,6 +8,8 @@ Interactive CLI wizard for generating Rails 8 applications with customizable con
 
 Think of it as `rails new` with an opinion and a friendly interactive experience.
 
+Requires Ruby 3.2 or newer. Development and release tooling use Ruby 4.0.5.
+
 ## Installation
 
 ```bash
@@ -231,11 +233,11 @@ railstart init
 ```
 
 This creates:
-- `~/.config/railstart/config.yaml` - Complete configuration template (copy of rails8_defaults.yaml with all available options)
+- `~/.config/railstart/config.yaml` - Minimal example containing only a few global overrides
 - `~/.config/railstart/presets/` - Directory for your presets
 - `~/.config/railstart/presets/example.yaml` - Example preset to get started
 
-The generated `config.yaml` shows all available questions, choices, flags, and post-actions. You can delete or comment out sections you don't want to customize, and modify the defaults for sections you do want to change.
+Keep `config.yaml` minimal so future built-in choices and flags continue to reach your installation. The full shipped schema remains available in `config/rails8_defaults.yaml`, while `examples/config.yml` provides a larger copyable example.
 
 ### Built-in Defaults
 
@@ -243,20 +245,15 @@ Railstart ships with sensible Rails 8 defaults defined in `config/rails8_default
 
 ### Customize for Your Team
 
-You can create `~/.config/railstart/config.yaml` manually or use `railstart init` to generate a complete template file. The template includes all available options, so you can simply modify the defaults you want to change:
+You can create `~/.config/railstart/config.yaml` manually or use `railstart init` to generate a minimal starting point. Add only the defaults you want to change:
 
 ```yaml
-# After running `railstart init`, your config.yaml will contain all options.
-# Simply modify the defaults you want to change:
+# After running `railstart init`, config.yaml contains a few example overrides.
+# Keep only the overrides you want to apply to every run:
 
 questions:
   - id: database
-    choices:
-      - name: PostgreSQL (recommended)
-        value: postgresql
-        default: true  # Changed from SQLite to PostgreSQL
-
-  # ... other questions with their full configuration ...
+    default: postgresql
 
 post_actions:
   - id: bundle_install
@@ -356,6 +353,9 @@ Key differences from `command` actions:
 ### Setup
 
 ```bash
+# Install the required Ruby version
+mise install ruby@4.0.5
+
 # Install dependencies
 bundle install
 
@@ -394,7 +394,7 @@ bundle exec rubocop
 bundle exec rubocop -a
 
 # Full check
-bundle exec rake test && bundle exec rubocop
+bundle exec rake test && bundle exec rubocop && bundle exec rake yard && gem build railstart.gemspec
 ```
 
 ## Architecture

data/Rakefile

@@ -13,7 +13,7 @@ begin
   require "yard"
   YARD::Rake::YardocTask.new(:yard) do |t|
     t.files = ["lib/**/*.rb"]
-    t.options = ["--output-dir", "doc", "--markup", "markdown"]
+    t.options = ["--output-dir", "doc", "--markup", "markdown", "--fail-on-warning"]
   end
 rescue LoadError
   # YARD not available

data/config/presets/api-only.yaml

@@ -13,6 +13,7 @@ questions:
       - name: None
         value: none
         default: true
+        rails_flag: "--skip-css"
 
   - id: javascript
     choices:

data/config/rails8_defaults.yaml

@@ -34,6 +34,7 @@ questions:
         value: sass
       - name: None (skip CSS setup)
         value: none
+        rails_flag: "--skip-css"
     rails_flag: "--css=%{value}"
 
   - id: javascript

data/lib/railstart/cli.rb

@@ -257,9 +257,26 @@ module Railstart
     end
 
     def example_user_config
-      # Copy the full rails8_defaults.yaml as the user config template
-      defaults_path = File.expand_path("../../config/rails8_defaults.yaml", __dir__)
-      File.read(defaults_path)
+      <<~YAML
+        ---
+        # User overrides for every Railstart run.
+        #
+        # Keep this file minimal. Entries merge by id with Railstart's built-in
+        # configuration. Overriding a choices array replaces the entire array.
+        # See config/rails8_defaults.yaml in the Railstart repository for the
+        # full schema and every available question, choice, and post-action.
+
+        questions:
+          - id: database
+            default: postgresql
+
+          - id: skip_docker
+            default: true
+
+        post_actions:
+          - id: bundle_install
+            enabled: false
+      YAML
     end
 
     def example_preset_config

data/lib/railstart/command_builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "shellwords"
+
 module Railstart
   # Translates configuration and user answers into a `rails new` command string.
   #
@@ -23,12 +25,28 @@ module Railstart
       # @example
       #   Railstart::CommandBuilder.build("todo", config, answers)
       def build(app_name, config, answers)
-        flags = collect_flags(config["questions"], answers)
-        "rails new #{app_name} #{flags.join(" ")}".strip
+        arguments(app_name, config, answers).map { |argument| display_argument(argument) }.join(" ")
+      end
+
+      # Build process arguments for `rails new` without shell interpretation.
+      #
+      # @param app_name [String] target Rails app name
+      # @param config [Hash] merged configuration from {Railstart::Config.load}
+      # @param answers [Hash] user answers keyed by question id
+      # @return [Array<String>] executable and arguments suitable for `system(*arguments)`
+      def arguments(app_name, config, answers)
+        ["rails", "new", app_name.to_s, *collect_flags(config["questions"], answers)]
       end
 
       private
 
+      def display_argument(argument)
+        value = argument.to_s
+        return value if value.match?(%r{\A[\w@%+=:,./-]+\z})
+
+        Shellwords.escape(value)
+      end
+
       def collect_flags(questions, answers)
         flags = []
         Array(questions).each do |question|

data/lib/railstart/config.rb

@@ -34,6 +34,8 @@ module Railstart
         user = read_yaml(user_path, required: false)
         preset = preset_path ? read_yaml(preset_path, required: false) : {}
 
+        validate_layer_ids!(builtin, user, preset)
+
         merged = merge_config(builtin, user)
         merged = merge_config(merged, preset) unless preset.empty?
         validate!(merged)
@@ -54,7 +56,7 @@ module Railstart
         return template if template.nil? || (!template.include?("%{") && !template.include?("%<"))
 
         format(template, value: value)
-      rescue KeyError => e
+      rescue KeyError, ArgumentError => e
         raise ConfigError, "Invalid interpolation token in rails_flag \"#{template}\": #{e.message}"
       end
 
@@ -161,64 +163,104 @@ module Railstart
       end
 
       def validate!(config)
-        issues = []
-        question_ids = Array(config["questions"]).map { |e| fetch_id(e) }.compact
+        questions = Array(config["questions"])
+        post_actions = Array(config["post_actions"])
+        issues = validate_questions(questions)
+        issues.concat(validate_post_actions(post_actions, questions))
+        raise ConfigValidationError.new("Invalid configuration", issues: issues) unless issues.empty?
+      end
 
-        MERGEABLE_COLLECTIONS.each do |collection|
-          entries = Array(config[collection])
-          issues.concat(validate_collection(collection, entries, question_ids))
+      def validate_layer_ids!(*layers)
+        issues = layers.flat_map do |layer|
+          MERGEABLE_COLLECTIONS.flat_map do |collection|
+            duplicate_id_issues(collection, Array(layer[collection]))
+          end
         end
         raise ConfigValidationError.new("Invalid configuration", issues: issues) unless issues.empty?
       end
 
-      def validate_collection(name, entries, question_ids = [])
+      def duplicate_id_issues(collection, entries)
+        counts = entries.filter_map { |entry| fetch_id(entry) }.tally
+        counts.filter_map do |id, count|
+          "#{collection} entry id #{id} is defined #{count} times" if count > 1
+        end
+      end
+
+      def validate_questions(entries)
         issues = []
         id_counts = Hash.new(0)
+        question_positions = entries.each_with_index.filter_map do |entry, index|
+          id = fetch_id(entry)
+          [id, index] if id
+        end.to_h
 
         entries.each_with_index do |entry, index|
           unless entry.is_a?(Hash)
-            issues << "#{name} entry at index #{index} must be a Hash"
+            issues << "questions entry at index #{index} must be a Hash"
             next
           end
 
           id = fetch_id(entry)
           if id.nil? || id.to_s.strip.empty?
-            issues << "#{name} entry at index #{index} is missing an id"
+            issues << "questions entry at index #{index} is missing an id"
           else
             id_counts[id] += 1
           end
 
-          if name == "questions"
-            type = entry["type"] || entry[:type]
-            unless QUESTION_TYPES.include?(type)
-              issues << "Question #{id || index} has invalid type #{type.inspect}"
-              next
-            end
+          identifier = id || index
+          type = value_for(entry, "type")
+          unless QUESTION_TYPES.include?(type)
+            issues << "Question #{identifier} has invalid type #{type.inspect}"
+            next
+          end
 
-            issues.concat(validate_question_choices(entry, id || index)) if CHOICE_REQUIRED_TYPES.include?(type)
-          elsif name == "post_actions"
-            issues.concat(validate_post_action_entry(entry, id || index)) if entry.fetch("enabled", true)
+          prompt = value_for(entry, "prompt")
+          issues << "Question #{identifier} is missing a prompt" if prompt.nil? || prompt.to_s.strip.empty?
+          issues.concat(validate_question_choices(entry, identifier)) if CHOICE_REQUIRED_TYPES.include?(type)
+          issues.concat(validate_question_default(entry, identifier, type))
+          issues.concat(validate_flag_source(entry, "Question #{identifier}"))
+          issues.concat(validate_depends_on(entry, identifier, index, question_positions))
+        end
 
-            if_condition = entry["if"] || entry[:if]
-            if if_condition.is_a?(Hash)
-              ref_question_id = if_condition["question"] || if_condition[:question]
-              if ref_question_id && !question_ids.include?(ref_question_id)
-                issues << "Post-action #{id || index} references unknown question '#{ref_question_id}'"
-              end
-            end
+        id_counts.each do |id, count|
+          issues << "questions entry id #{id} is defined #{count} times" if count > 1
+        end
+
+        issues
+      end
+
+      def validate_post_actions(entries, questions)
+        issues = []
+        id_counts = Hash.new(0)
+        question_ids = questions.filter_map { |entry| fetch_id(entry) }
+
+        entries.each_with_index do |entry, index|
+          unless entry.is_a?(Hash)
+            issues << "post_actions entry at index #{index} must be a Hash"
+            next
           end
+
+          id = fetch_id(entry)
+          if id.nil? || id.to_s.strip.empty?
+            issues << "post_actions entry at index #{index} is missing an id"
+          else
+            id_counts[id] += 1
+          end
+
+          identifier = id || index
+          issues.concat(validate_post_action_entry(entry, identifier))
+          issues.concat(validate_post_action_condition(entry, identifier, question_ids))
         end
 
         id_counts.each do |id, count|
-          issues << "#{name} entry id #{id} is defined #{count} times" if count > 1
+          issues << "post_actions entry id #{id} is defined #{count} times" if count > 1
         end
-
         issues
       end
 
       def validate_question_choices(entry, question_id)
         issues = []
-        choices = entry["choices"] || entry[:choices]
+        choices = value_for(entry, "choices")
 
         if !choices.is_a?(Array) || choices.empty?
           issues << "Question #{question_id} (#{entry["type"]}) must define at least one choice"
@@ -230,43 +272,183 @@ module Railstart
             issues << "Question #{question_id} choice at index #{cidx} must be a Hash"
             next
           end
-          unless choice["name"] || choice[:name]
+          unless key_present?(choice, "name") && !value_for(choice, "name").to_s.strip.empty?
             issues << "Question #{question_id} choice at index #{cidx} missing 'name'"
           end
-          unless choice["value"] || choice[:value]
+          unless key_present?(choice, "value") && !value_for(choice, "value").nil?
             issues << "Question #{question_id} choice at index #{cidx} missing 'value'"
           end
+          if key_present?(choice, "default") && ![true, false].include?(value_for(choice, "default"))
+            issues << "Question #{question_id} choice at index #{cidx} default must be true or false"
+          end
+          issues.concat(validate_flag_source(choice, "Question #{question_id} choice at index #{cidx}"))
         end
 
+        issues.concat(duplicate_choice_issues(choices, question_id, "name"))
+        issues.concat(duplicate_choice_issues(choices, question_id, "value"))
+        default_count = choices.count do |choice|
+          choice.is_a?(Hash) && value_for(choice, "default") == true
+        end
+        if value_for(entry, "type") == "select" && default_count > 1
+          issues << "Question #{question_id} must define at most one default choice"
+        end
+        issues
+      end
+
+      def duplicate_choice_issues(choices, question_id, field)
+        values = choices.filter_map do |choice|
+          value_for(choice, field) if choice.is_a?(Hash) && key_present?(choice, field)
+        end
+        values.tally.filter_map do |value, count|
+          "Question #{question_id} has duplicate choice #{field} #{value.inspect}" if count > 1
+        end
+      end
+
+      def validate_question_default(entry, identifier, type)
+        return [] unless key_present?(entry, "default")
+
+        default = value_for(entry, "default")
+        choices = Array(value_for(entry, "choices"))
+        choice_values = choices.filter_map do |choice|
+          value_for(choice, "value") if choice.is_a?(Hash) && key_present?(choice, "value")
+        end
+
+        case type
+        when "select"
+          return [] if choice_values.include?(default)
+
+          ["Question #{identifier} default #{default.inspect} is not a defined choice"]
+        when "multi_select"
+          return ["Question #{identifier} default must be an Array"] unless default.is_a?(Array)
+
+          unknown = default - choice_values
+          unknown.empty? ? [] : ["Question #{identifier} has unknown default choice #{unknown.first.inspect}"]
+        when "yes_no"
+          [true, false].include?(default) ? [] : ["Question #{identifier} default must be true or false"]
+        else
+          []
+        end
+      end
+
+      def validate_flag_source(source, label)
+        issues = []
+        if key_present?(source, "rails_flag")
+          flag = value_for(source, "rails_flag")
+          if flag.is_a?(String)
+            issues.concat(interpolation_issues(flag, label, "rails_flag"))
+          else
+            issues << "#{label} rails_flag must be a String"
+          end
+        end
+
+        if key_present?(source, "rails_flags")
+          flags = value_for(source, "rails_flags")
+          if !flags.is_a?(Array) || flags.any? { |flag| !flag.is_a?(String) }
+            issues << "#{label} rails_flags must be an Array of Strings"
+          else
+            flags.each { |flag| issues.concat(interpolation_issues(flag, label, "rails_flags")) }
+          end
+        end
+        issues
+      end
+
+      def interpolation_issues(flag, label, field)
+        interpolate_flag(flag, "value")
+        []
+      rescue ConfigError => e
+        ["#{label} has invalid #{field} interpolation: #{e.message}"]
+      end
+
+      def validate_depends_on(entry, identifier, index, question_positions)
+        return [] unless key_present?(entry, "depends_on")
+
+        condition = value_for(entry, "depends_on")
+        return ["Question #{identifier} depends_on must be a Hash"] unless condition.is_a?(Hash)
+
+        issues = unsupported_key_issues(condition, %w[question value], "Question #{identifier} depends_on")
+        reference = value_for(condition, "question")
+        issues << "Question #{identifier} depends_on is missing question" if reference.to_s.strip.empty?
+        issues << "Question #{identifier} depends_on is missing value" unless key_present?(condition, "value")
+        if !reference.to_s.empty? && !question_positions.key?(reference)
+          issues << "Question #{identifier} references unknown question '#{reference}'"
+        elsif question_positions[reference] && question_positions[reference] >= index
+          issues << "Question #{identifier} depends_on must reference an earlier question"
+        end
         issues
       end
 
       def validate_post_action_entry(entry, identifier)
-        action_type = (entry["type"] || entry[:type] || "command").to_s
+        action_type = (value_for(entry, "type") || "command").to_s
+        enabled = entry.fetch("enabled", entry.fetch(:enabled, true))
 
         case action_type
         when "command"
-          command = entry["command"] || entry[:command]
-          if command.nil? || command.to_s.strip.empty?
+          command = value_for(entry, "command")
+          if enabled && (command.nil? || command.to_s.strip.empty?)
             ["Post-action #{identifier} is enabled but missing a command"]
           else
             []
           end
         when "template"
           issues = []
-          source = entry["source"] || entry[:source]
-          if source.nil? || source.to_s.strip.empty?
+          source = value_for(entry, "source")
+          if enabled && (source.nil? || source.to_s.strip.empty?)
             issues << "Post-action #{identifier} is a template but missing a source"
           end
 
-          variables = entry["variables"] || entry[:variables]
+          variables = value_for(entry, "variables")
           issues << "Post-action #{identifier} template variables must be a Hash" if variables && !variables.is_a?(Hash)
+          if variables.is_a?(Hash)
+            variables.each_key do |key|
+              unless /\A[a-zA-Z_]\w*\z/.match?(key.to_s)
+                issues << "Post-action #{identifier} has invalid template variable name #{key.inspect}"
+              end
+            end
+          end
           issues
         else
           ["Post-action #{identifier} has unsupported type '#{action_type}'"]
         end
       end
 
+      def validate_post_action_condition(entry, identifier, question_ids)
+        return [] unless key_present?(entry, "if")
+
+        condition = value_for(entry, "if")
+        return ["Post-action #{identifier} condition must be a Hash"] unless condition.is_a?(Hash)
+
+        issues = unsupported_key_issues(condition, %w[question equals includes], "Post-action #{identifier} condition")
+        reference = value_for(condition, "question")
+        issues << "Post-action #{identifier} condition is missing question" if reference.to_s.strip.empty?
+        if !reference.to_s.empty? && !question_ids.include?(reference)
+          issues << "Post-action #{identifier} references unknown question '#{reference}'"
+        end
+
+        operators = %w[equals includes].select { |key| key_present?(condition, key) }
+        unless operators.one?
+          issues << "Post-action #{identifier} condition must define exactly one of equals or includes"
+        end
+        if key_present?(condition, "includes") && !value_for(condition, "includes").is_a?(Array)
+          issues << "Post-action #{identifier} condition includes must be an Array"
+        end
+        issues
+      end
+
+      def unsupported_key_issues(hash, allowed, label)
+        unsupported = hash.keys.map(&:to_s) - allowed
+        unsupported.map { |key| "#{label} has unsupported key '#{key}'" }
+      end
+
+      def key_present?(hash, key)
+        hash.key?(key) || hash.key?(key.to_sym)
+      end
+
+      def value_for(hash, key)
+        return hash[key] if hash.key?(key)
+
+        hash[key.to_sym]
+      end
+
       def deep_dup(value)
         case value
         when Hash

data/lib/railstart/generator.rb

@@ -16,6 +16,9 @@ module Railstart
   # @example Run generator non-interactively
   #   Railstart::Generator.new("blog", use_defaults: true).run
   class Generator
+    APP_NAME_PATTERN = /\A[a-z0-9_-]+\z/
+    APP_NAME_ERROR = "Must be lowercase letters, numbers, underscores, or hyphens"
+
     #
     # @param app_name [String, nil] preset app name, prompted if nil
     # @param config [Hash, nil] injected config for testing, defaults to Config.load
@@ -46,6 +49,7 @@ module Railstart
       show_welcome_screen unless @use_defaults
 
       ask_app_name unless @app_name
+      validate_app_name!
 
       if @use_defaults
         collect_defaults
@@ -69,10 +73,16 @@ module Railstart
 
     def ask_app_name
       @app_name = @prompt.ask("App name?", default: "my_app") do |q|
-        q.validate(/\A[a-z0-9_-]+\z/, "Must be lowercase letters, numbers, underscores, or hyphens")
+        q.validate(APP_NAME_PATTERN, APP_NAME_ERROR)
       end
     end
 
+    def validate_app_name!
+      return if @app_name.to_s.match?(APP_NAME_PATTERN)
+
+      raise Error, "Invalid app name '#{@app_name}': #{APP_NAME_ERROR}"
+    end
+
     def collect_defaults
       Array(@config["questions"]).each do |question|
         next if should_skip_question?(question)
@@ -121,9 +131,7 @@ module Railstart
 
     def ask_select(question)
       # Convert to hash format: { 'Display Name' => 'value' }
-      choices = question["choices"].each_with_object({}) do |choice, hash|
-        hash[choice["name"]] = choice["value"]
-      end
+      choices = question["choices"].to_h { |choice| [choice["name"], choice["value"]] }
       default_val = find_default(question)
 
       # TTY::Prompt expects 1-based index for default
@@ -134,9 +142,7 @@ module Railstart
 
     def ask_multi_select(question)
       # Convert to hash format: { 'Display Name' => 'value' }
-      choices = question["choices"].each_with_object({}) do |choice, hash|
-        hash[choice["name"]] = choice["value"]
-      end
+      choices = question["choices"].to_h { |choice| [choice["name"], choice["value"]] }
 
       # Transform value-based defaults to name-based defaults for TTY::Prompt
       # Config uses stable values (e.g., "action_mailer"), TTY::Prompt needs display names
@@ -210,6 +216,7 @@ module Railstart
     end
 
     def generate_app
+      arguments = CommandBuilder.arguments(@app_name, @config, @answers)
       command = CommandBuilder.build(@app_name, @config, @answers)
 
       UI.info("Running: #{command}")
@@ -217,9 +224,9 @@ module Railstart
 
       # Run rails command outside of bundler context to use system Rails
       success = if defined?(Bundler)
-                  Bundler.with_unbundled_env { system(command) }
+                  Bundler.with_unbundled_env { system(*arguments) }
                 else
-                  system(command)
+                  system(*arguments)
                 end
 
       return if success

data/lib/railstart/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Railstart
-  VERSION = "0.4.5"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railstart
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.5.0
 platform: ruby
 authors:
 - dpaluy
@@ -86,7 +86,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-  homepage_uri: https://github.com/dpaluy/railstart
   documentation_uri: https://rubydoc.info/gems/railstart
   source_code_uri: https://github.com/dpaluy/railstart
   changelog_uri: https://github.com/dpaluy/railstart/blob/master/CHANGELOG.md
@@ -105,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Rails application starter and development utilities
 test_files: []