railstart 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b7aaa542b7abf7c01dbbbb6bfcb71ce8dede1ae7b1535683e4538ac0aad138e
-  data.tar.gz: 150539a6c55e31e18b33a0852f2e0840057518f5789644073320e060190399bd
+  metadata.gz: 675d33f74310aa870ad6a167cbd585cc643b3e37096d255732bcf900fa7ab65d
+  data.tar.gz: 460628c266ba316d4ad19e148b9e8044912865c98f6c091dd8a1be25653dab71
 SHA512:
-  metadata.gz: e180fd3ba85eaad0ca8f0f20726c66b4567e7799000d7bac4e35919d0519deab21772c1f44968d3ff152a74019e33551c8b0f9cba544f814a3f14b006a3ac7de
-  data.tar.gz: 1733110d3c2f9901d6154a87cd3b479596df1d949fff1b9f02e29cd3415c834eba3eb738d30c7a1f1124c8934338f65ef2fb43e38714775f55c349ae578e7bf7
+  metadata.gz: 344c0860107725a5a56e88bf108a7e7a73891da7f0f7678850af5c47469ed63f91c8c22de71743dc68747557f7d34aac2d001814033dee29533f5b343d8b7e0d
+  data.tar.gz: 2252beeb778c40a048e1156aebd1786a904fa7cf5edec89fd89d924265b223ff742024ceee8491d5b2a5b459a8a560047be60e43a85c13d771ee96db6edd978a

data/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2025-11-22
+
+### Added
+- CLI `--preset` flag now accepts explicit `.yaml`/`.yml` file paths in addition to preset names.
+- **Template post-actions**: New `type: template` post-action type for executing full Rails application templates
+- **TemplateRunner**: New `Railstart::TemplateRunner` class wraps Rails' AppGenerator to run templates with proper context
+- **Template variables**: Template actions support `variables` hash for injecting custom instance variables into templates
+- **Built-in variables**: Templates automatically receive `@app_name` and `@answers` instance variables
+- **Template DSL support**: Full access to Rails template DSL (`gem`, `route`, `initializer`, `after_bundle`, etc.)
+- **Error handling**: New `Railstart::TemplateError` for template execution failures with proper error wrapping
+- **Config validation**: Validation for template post-actions (requires `source`, validates `variables` as Hash)
+- **Documentation**: README section explaining template post-actions vs command actions with security guidance
+
+### Changed
+- **Post-action processing**: Refactored to support both command and template execution types
+- **Directory context**: `run_post_actions` now uses block form of `Dir.chdir` for proper scoping
+- **Config validation**: Enhanced `validate_post_action_entry` to handle multiple action types
+
+### Technical
+- New file: `lib/railstart/template_runner.rb` (77 lines, full YARD docs)
+- New test file: `test/template_runner_test.rb` (comprehensive coverage with mocks)
+- Enhanced `lib/railstart/generator.rb` with template execution flow
+- Enhanced `lib/railstart/config.rb` with template action validation
+- Version bump: 0.3.0 → 0.4.0
+- All tests pass (39 runs, 111 assertions, 0 failures)
+- RuboCop clean (20 files inspected, no offenses)
 
 ## [0.3.0] - 2025-11-22
 

data/README.md

@@ -309,6 +309,28 @@ post_actions:
       equals: value                 # or includes: [array, values]
 ```
 
+#### Template Post-Actions
+
+Post-actions can now execute full Rails application templates (including [RailsBytes scripts](https://railsbytes.com)) instead of plain shell commands.
+
+```yaml
+post_actions:
+  - id: apply_tailwind_dash
+    name: "Apply Tailwind dashboard template"
+    type: template
+    enabled: false             # keep disabled unless you trust the source
+    prompt: "Run the sample template?"
+    source: "https://railsbytes.com/script/zAasQK"
+    variables:
+      app_label: "internal-tools"  # optional instance variables available inside template
+```
+
+Key differences from `command` actions:
+
+- Set `type: template` and provide a `source` (local path or URL). Railstart streams that template into Rails' own `apply` helper, so all standard DSL commands (`gem`, `route`, `after_bundle`, etc.) are available.
+- `variables` is optional; when present, its keys become instance variables accessible from the template (e.g., `@app_label`). Railstart always exposes `@app_name` and `@answers` for convenience.
+- Template actions still honor `prompt`, `default`, and `if` just like command actions. Keep remote templates disabled by default unless you explicitly trust them.
+
 ## Development
 
 ### Setup

data/lib/railstart/cli.rb

@@ -237,6 +237,10 @@ module Railstart
     end
 
     def preset_file_for(name)
+      if (direct_path = explicit_preset_path(name))
+        return direct_path
+      end
+
       # Check user presets first
       user_path = File.join(PRESET_DIR, "#{name}.yaml")
       return user_path if File.exist?(user_path)
@@ -319,5 +323,14 @@ module Railstart
             enabled: true
       YAML
     end
+
+    def explicit_preset_path(name)
+      return unless name&.match?(/\.ya?ml\z/)
+
+      expanded = File.expand_path(name)
+      return expanded if File.exist?(expanded)
+
+      raise Railstart::ConfigLoadError, "Preset file '#{name}' not found"
+    end
   end
 end

data/lib/railstart/config.rb

@@ -197,12 +197,7 @@ module Railstart
 
             issues.concat(validate_question_choices(entry, id || index)) if CHOICE_REQUIRED_TYPES.include?(type)
           elsif name == "post_actions"
-            if entry.fetch("enabled", true)
-              command = entry["command"] || entry[:command]
-              if command.nil? || command.to_s.strip.empty?
-                issues << "Post-action #{id || index} is enabled but missing a command"
-              end
-            end
+            issues.concat(validate_post_action_entry(entry, id || index)) if entry.fetch("enabled", true)
 
             if_condition = entry["if"] || entry[:if]
             if if_condition.is_a?(Hash)
@@ -246,6 +241,32 @@ module Railstart
         issues
       end
 
+      def validate_post_action_entry(entry, identifier)
+        action_type = (entry["type"] || entry[:type] || "command").to_s
+
+        case action_type
+        when "command"
+          command = entry["command"] || entry[:command]
+          if 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?
+            issues << "Post-action #{identifier} is a template but missing a source"
+          end
+
+          variables = entry["variables"] || entry[:variables]
+          issues << "Post-action #{identifier} template variables must be a Hash" if variables && !variables.is_a?(Hash)
+          issues
+        else
+          ["Post-action #{identifier} has unsupported type '#{action_type}'"]
+        end
+      end
+
       def deep_dup(value)
         case value
         when Hash

data/lib/railstart/errors.rb

@@ -25,4 +25,7 @@ module Railstart
       super(detail)
     end
   end
+
+  # Raised when applying Rails templates fails.
+  class TemplateError < Error; end
 end

data/lib/railstart/generator.rb

@@ -2,6 +2,7 @@
 
 require "tty-prompt"
 require_relative "ui"
+require_relative "template_runner"
 
 module Railstart
   # Orchestrates the interactive Rails app generation flow.
@@ -221,20 +222,30 @@ module Railstart
     end
 
     def run_post_actions
-      Dir.chdir(@app_name)
+      Dir.chdir(@app_name) do
+        template_runner = nil
 
-      Array(@config["post_actions"]).each { |action| process_post_action(action) }
-      puts
-      UI.success("Rails app created successfully at ./#{@app_name}")
+        Array(@config["post_actions"]).each do |action|
+          template_runner ||= TemplateRunner.new(app_path: Dir.pwd) if template_action?(action)
+          process_post_action(action, template_runner)
+        end
+
+        puts
+        UI.success("Rails app created successfully at ./#{@app_name}")
+      end
     rescue Errno::ENOENT
       UI.warning("Could not change to app directory. Post-actions skipped.")
     end
 
-    def process_post_action(action)
+    def process_post_action(action, template_runner)
       return unless should_run_action?(action)
       return unless confirm_action?(action)
 
-      execute_action(action)
+      if template_action?(action)
+        run_template_action(action, template_runner)
+      else
+        run_command_action(action)
+      end
     end
 
     def confirm_action?(action)
@@ -243,12 +254,33 @@ module Railstart
       @prompt.yes?(action["prompt"], default: action.fetch("default", true))
     end
 
-    def execute_action(action)
+    def run_command_action(action)
       UI.info(action["name"].to_s)
       success = system(action["command"])
       UI.warning("Post-action '#{action["name"]}' failed. Continuing anyway.") unless success
     end
 
+    def run_template_action(action, template_runner)
+      return unless template_runner
+
+      UI.info(action["name"].to_s)
+      source = action["source"]
+      variables = template_variables(action)
+      template_runner.apply(source, variables: variables)
+    rescue TemplateError => e
+      UI.warning("Post-action '#{action["name"]}' failed. #{e.message}")
+    end
+
+    def template_variables(action)
+      base = { app_name: @app_name, answers: @answers }
+      extras = action["variables"].is_a?(Hash) ? action["variables"].transform_keys(&:to_sym) : {}
+      base.merge(extras)
+    end
+
+    def template_action?(action)
+      action["type"].to_s == "template"
+    end
+
     def should_run_action?(action)
       return false unless action.fetch("enabled", true)
 

data/lib/railstart/template_runner.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "errors"
+
+module Railstart
+  # Executes Rails application templates (including RailsBytes scripts)
+  # inside a generated application directory.
+  #
+  # Wraps Rails' own AppGenerator so existing template DSL helpers such as
+  # `gem`, `initializer`, `route`, etc. are available without reimplementing
+  # them in Railstart.
+  class TemplateRunner
+    # @param app_path [String] absolute path to the Rails application
+    # @param generator_factory [#call] optional factory for injecting a
+    #   generator (mainly used in tests)
+    # @param shell [Thor::Shell] Thor shell instance for output
+    def initialize(app_path:, generator_factory: nil, shell: Thor::Base.shell.new)
+      @app_path = app_path
+      @shell = shell
+      @generator_factory = generator_factory
+    end
+
+    # Apply a Rails template located at +source+.
+    #
+    # @param source [String] file path or URL
+    # @param variables [Hash] instance variables injected into the template
+    # @return [void]
+    # @raise [Railstart::TemplateError] when Rails cannot be loaded or
+    #   template execution fails
+    def apply(source, variables: {})
+      raise TemplateError, "Template source must be provided" if source.to_s.strip.empty?
+
+      generator = build_generator
+      assign_variables(generator, variables)
+      generator.apply(source)
+    rescue TemplateError
+      raise
+    rescue LoadError => e
+      raise TemplateError, "Rails must be installed to run template post-actions: #{e.message}"
+    rescue StandardError => e
+      raise TemplateError, "Failed to apply template #{source}: #{e.message}"
+    end
+
+    private
+
+    def assign_variables(generator, variables)
+      Array(variables).each do |key, value|
+        generator.instance_variable_set(:"@#{key}", value)
+      end
+    end
+
+    def build_generator
+      generator = generator_factory.call(@app_path)
+      if generator.respond_to?(:destination_root=)
+        generator.destination_root = @app_path
+      elsif generator.respond_to?(:destination_root)
+        generator.instance_variable_set(:@destination_root, @app_path)
+      end
+      generator
+    end
+
+    def generator_factory
+      @generator_factory ||= default_generator_factory
+    end
+
+    def default_generator_factory
+      require "rails/generators"
+      require "rails/generators/rails/app/app_generator"
+
+      shell = @shell
+      lambda do |_app_path|
+        Rails::Generators::AppGenerator.new([], {}, shell: shell)
+      end
+    end
+  end
+end

data/lib/railstart/version.rb

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

data/lib/railstart.rb

@@ -5,6 +5,7 @@ require_relative "railstart/errors"
 require_relative "railstart/config"
 require_relative "railstart/command_builder"
 require_relative "railstart/generator"
+require_relative "railstart/template_runner"
 require_relative "railstart/cli"
 
 # Main namespace for the Railstart gem.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railstart
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - dpaluy
@@ -78,6 +78,7 @@ files:
 - lib/railstart/config.rb
 - lib/railstart/errors.rb
 - lib/railstart/generator.rb
+- lib/railstart/template_runner.rb
 - lib/railstart/ui.rb
 - lib/railstart/version.rb
 homepage: https://github.com/dpaluy/railstart