plutonium 0.39.1 → 0.40.0

data/lib/generators/pu/lib/plutonium_generators/concerns/actions.rb

@@ -430,9 +430,14 @@ module PlutoniumGenerators
       end
 
       def bundle(*gems, **options)
-        gems = Array(gems).join " "
+        gems = Array(gems).flatten
+        # Skip gems already in bundle
+        gems = gems.reject { |g| gem_in_bundle?(g) }
+        return if gems.empty?
+
+        gems_str = gems.join(" ")
         options = hash_to_cli_options options
-        cmd_args = "add #{gems} #{options}"
+        cmd_args = "add #{gems_str} #{options}"
 
         log :bundle, cmd_args
         Bundler.with_unbundled_env do
@@ -440,6 +445,14 @@ module PlutoniumGenerators
         end
       end
 
+      def gem_in_bundle?(name)
+        in_root do
+          return true if File.exist?("Gemfile") && File.read("Gemfile").match?(/gem ['"]#{name}['"]/)
+          return true if File.exist?("Gemfile.lock") && File.read("Gemfile.lock").include?("    #{name} ")
+        end
+        false
+      end
+
       def unbundle(*gems)
         gems = Array(gems).join " "
         cmd_args = "remove #{gems}"
@@ -459,6 +472,14 @@ module PlutoniumGenerators
         end
       end
 
+      def file_includes?(path, check)
+        destination = File.expand_path(path, destination_root)
+        return false unless File.exist?(destination)
+
+        content = File.read(destination)
+        check.is_a?(Regexp) ? content.match?(check) : content.include?(check)
+      end
+
       private
 
       #

data/lib/generators/pu/lib/plutonium_generators/concerns/configures_sqlite.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "psych"
+
+module PlutoniumGenerators
+  module Concerns
+    module ConfiguresSqlite
+      class DatabaseYAML
+        COMMENTED_PROD_DATABASE = "# database: path/to/persistent/storage/production.sqlite3"
+        UNCOMMENTED_PROD_DATABASE = "database: path/to/persistent/storage/production.sqlite3"
+
+        attr_reader :content
+
+        def initialize(path:)
+          @content = File.read(path)
+          # if the production environment has the default commented database value,
+          # uncomment it so that the value can be parsed
+          @content.gsub!(COMMENTED_PROD_DATABASE, UNCOMMENTED_PROD_DATABASE)
+          @stream = Psych.parse_stream(@content)
+          @emission_stream = Psych::Nodes::Stream.new
+          @emission_document = Psych::Nodes::Document.new
+          @emission_mapping = Psych::Nodes::Mapping.new
+        end
+
+        def add_database(name)
+          root = @stream.children.first.root
+          root.children.each_slice(2).map do |scalar, mapping|
+            next unless scalar.is_a?(Psych::Nodes::Scalar)
+            next unless mapping.is_a?(Psych::Nodes::Mapping)
+            next unless mapping.anchor.nil? || mapping.anchor.empty?
+            next if mapping.children.each_slice(2).any? do |key, value|
+              key.is_a?(Psych::Nodes::Scalar) && key.value == name && value.is_a?(Psych::Nodes::Alias) && value.anchor == name
+            end
+
+            new_mapping = Psych::Nodes::Mapping.new
+            if mapping.children.first.value == "<<" # 2-tiered environment
+              new_mapping.children.concat [
+                Psych::Nodes::Scalar.new("primary"),
+                mapping,
+                Psych::Nodes::Scalar.new(name),
+                Psych::Nodes::Alias.new(name)
+              ]
+            else # 3-tiered environment
+              new_mapping.children.concat mapping.children
+              new_mapping.children.concat [
+                Psych::Nodes::Scalar.new(name),
+                Psych::Nodes::Alias.new(name)
+              ]
+            end
+
+            old_environment_entry = emit_pair(scalar, mapping)
+            new_environment_entry = emit_pair(scalar, new_mapping)
+
+            [scalar.value, old_environment_entry, new_environment_entry]
+          end.compact!
+        end
+
+        def new_database(name, migrations_paths: nil)
+          migrations_paths ||= "db/#{name}_migrate"
+          db = Psych::Nodes::Mapping.new(name)
+          db.children.concat [
+            Psych::Nodes::Scalar.new("<<"),
+            Psych::Nodes::Alias.new("default"),
+            Psych::Nodes::Scalar.new("migrations_paths"),
+            Psych::Nodes::Scalar.new(migrations_paths),
+            Psych::Nodes::Scalar.new("database"),
+            Psych::Nodes::Scalar.new("storage/<%= Rails.env %>-#{name}.sqlite3")
+          ]
+          "\n" + emit_pair(Psych::Nodes::Scalar.new(name), db)
+        end
+
+        def database_def_regex(name)
+          /#{name}: &#{name}\n(?:[ \t]+.*\n)+/
+        end
+
+        private
+
+        def emit_pair(scalar, mapping)
+          @emission_mapping.children.clear.concat [scalar, mapping]
+          @emission_document.children.clear.concat [@emission_mapping]
+          @emission_stream.children.clear.concat [@emission_document]
+          output = @emission_stream.yaml.gsub!(/^---/, "").strip!
+          output.gsub!(UNCOMMENTED_PROD_DATABASE, COMMENTED_PROD_DATABASE)
+          output
+        end
+      end
+
+      private
+
+      def database_yaml
+        @database_yaml ||= DatabaseYAML.new(path: File.expand_path("config/database.yml", destination_root))
+      end
+
+      def add_sqlite_database(name, migrations_paths: nil)
+        # Define the new database configuration
+        insert_into_file "config/database.yml",
+          database_yaml.new_database(name, migrations_paths: migrations_paths) + "\n",
+          after: database_yaml.database_def_regex("default"),
+          verbose: false,
+          force: false
+        say_status :def_db, "#{name} (database.yml)"
+
+        # Add the new database to all environments
+        database_yaml.add_database(name)&.each do |environment, old_entry, new_entry|
+          gsub_file "config/database.yml", old_entry, new_entry, verbose: false
+          say_status :add_db, "#{name} -> #{environment} (database.yml)"
+        end
+      end
+
+      def prepare_database(name)
+        Bundler.with_unbundled_env do
+          run "bin/rails db:prepare", env: {"DATABASE" => name}
+        end
+      end
+
+      def add_application_config(config_line, after_pattern: nil)
+        return if file_includes?("config/application.rb", config_line)
+
+        pattern = after_pattern || /^([ \t]*).*?(?=\n\s*end\nend)$/
+        insert_into_file "config/application.rb", after: pattern do
+          if after_pattern
+            "\n\\1#{config_line}"
+          else
+            "\n\n\\1#{config_line}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/pu/lib/plutonium_generators/concerns/mounts_engines.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module PlutoniumGenerators
+  module Concerns
+    module MountsEngines
+      private
+
+      def mount_engine(engine_mount, route_file: "config/routes.rb", authenticated: false)
+        return if file_includes?(route_file, engine_mount)
+
+        if authenticated
+          mount_authenticated_engine(engine_mount, route_file)
+        else
+          insert_into_file route_file, before: /^end\s*\z/ do
+            "  #{engine_mount}\n"
+          end
+        end
+      end
+
+      def mount_authenticated_engine(engine_mount, route_file)
+        ensure_management_constraint
+
+        content = File.read(File.expand_path(route_file, destination_root))
+        # Match constraint block opening - use [ \t]* instead of \s* to avoid matching newlines
+        constraint_match = content.match(/^(\s*)constraints ManagementConstraint do[ \t]*\n/)
+
+        if constraint_match
+          indent = constraint_match[1]
+          # Insert after the opening line (not including any subsequent blank lines)
+          insert_into_file route_file, after: /^#{Regexp.escape(indent)}constraints ManagementConstraint do[ \t]*\n/ do
+            "#{indent}  #{engine_mount}\n"
+          end
+        else
+          # Create new constraint block before the final end
+          insert_into_file route_file, before: /^end\s*\z/ do
+            "  constraints ManagementConstraint do\n    #{engine_mount}\n  end\n"
+          end
+        end
+      end
+
+      def ensure_management_constraint
+        constraint_file = "app/constraints/management_constraint.rb"
+        return if File.exist?(File.expand_path(constraint_file, destination_root))
+
+        create_file constraint_file, <<~RUBY
+          # frozen_string_literal: true
+
+          class ManagementConstraint
+            def self.matches?(request)
+              false # TODO: Implement authentication
+              # Examples:
+              #   Rodauth:    request.env["rodauth.admin"]&.logged_in?
+              #   Devise:     request.env["warden"].user(:admin).present?
+              #   Custom:     request.session[:admin_id].present?
+              #   HTTP Basic: authenticate_with_http_basic(request)
+            end
+
+            # HTTP Basic Auth example:
+            # def self.authenticate_with_http_basic(request)
+            #   auth = Rack::Auth::Basic::Request.new(request.env)
+            #   return false unless auth.provided? && auth.basic?
+            #
+            #   username, password = auth.credentials
+            #   ActiveSupport::SecurityUtils.secure_compare(username, ENV["ADMIN_USERNAME"]) &&
+            #     ActiveSupport::SecurityUtils.secure_compare(password, ENV["ADMIN_PASSWORD"])
+            # end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/generators/pu/lib/plutonium_generators/concerns/package_selector.rb

@@ -37,8 +37,10 @@ module PlutoniumGenerators
 
       def select_package(selected_package = nil, msg: "Select package", pkgs: nil)
         pkgs ||= available_packages
-        if pkgs.include?(selected_package)
-          selected_package
+        # Normalize input to underscore format (e.g., "CustomerPortal" -> "customer_portal")
+        normalized = selected_package&.underscore
+        if pkgs.include?(normalized)
+          normalized
         else
           prompt.select(msg, pkgs)
         end

data/lib/generators/pu/lib/plutonium_generators/model_generator_base.rb

@@ -39,7 +39,13 @@ module PlutoniumGenerators
     def name
       @pu_name ||= begin
         @original_name = @name
-        @name = [main_app? ? nil : selected_destination_feature.underscore, super.singularize.underscore].compact.join "/"
+        resource_name = super.singularize.underscore
+        dest_namespace = main_app? ? nil : selected_destination_feature.underscore
+        # Strip destination namespace from resource name if already present
+        if dest_namespace && resource_name.start_with?("#{dest_namespace}/")
+          resource_name = resource_name.sub("#{dest_namespace}/", "")
+        end
+        @name = [dest_namespace, resource_name].compact.join "/"
         set_destination_root!
         @name
       end

data/lib/generators/pu/lite/litestream/litestream_generator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/plutonium_generators"
+
+module Pu
+  module Lite
+    class LitestreamGenerator < Rails::Generators::Base
+      include PlutoniumGenerators::Generator
+      include PlutoniumGenerators::Concerns::MountsEngines
+
+      desc "Set up Litestream for SQLite replication/backup"
+
+      class_option :route, type: :string, default: "/manage/litestream",
+        desc: "Route path for Litestream UI"
+      class_option :credentials, type: :boolean, default: true,
+        desc: "Configure Litestream to use Rails credentials"
+
+      def start
+        bundle "litestream"
+        run_litestream_install
+        create_litestream_script
+        configure_kamal
+        mount_litestream_engine
+        configure_litestream_initializer
+        show_instructions
+      rescue => e
+        exception "#{self.class} failed:", e
+      end
+
+      private
+
+      def run_litestream_install
+        Bundler.with_unbundled_env do
+          run "bin/rails generate litestream:install"
+        end
+        # Remove puma plugin added by litestream:install
+        run "git checkout -- config/puma.rb 2>/dev/null || true"
+      end
+
+      def create_litestream_script
+        litestream_script = "bin/litestream"
+        return if File.exist?(File.expand_path(litestream_script, destination_root))
+
+        create_file litestream_script, <<~BASH
+          #!/usr/bin/env bash
+          set -e
+          exec bundle exec litestream replicate -config config/litestream.yml
+        BASH
+        chmod litestream_script, 0o755
+      end
+
+      def configure_kamal
+        deploy_file = "config/deploy.yml"
+        return unless File.exist?(File.expand_path(deploy_file, destination_root))
+        return if file_includes?(deploy_file, "litestream:")
+
+        insert_into_file deploy_file, after: /^servers:.*\n/ do
+          <<~YAML
+            litestream:
+              hosts:
+                - <%= ENV['DEPLOY_HOST'] %>
+              cmd: bin/litestream
+          YAML
+        end
+      end
+
+      def mount_litestream_engine
+        mount_engine %(mount Litestream::Engine, at: "#{options[:route]}"), authenticated: true
+      end
+
+      def configure_litestream_initializer
+        return unless options[:credentials]
+
+        initializer_file = "config/initializers/litestream.rb"
+        uncomment_lines initializer_file, /litestream_credentials/
+      end
+
+      def show_instructions
+        say ""
+        say "Litestream Setup Instructions:", :green
+        say "=" * 50
+        say ""
+        say "Litestream requires an S3-compatible storage provider (AWS S3, DigitalOcean Spaces, etc.)"
+        say ""
+
+        if options[:credentials]
+          say "Edit your credentials to store bucket details:"
+          say "  bin/rails credentials:edit"
+          say ""
+          say "Add the following:"
+          say "  litestream:"
+          say "    replica_bucket: <your-bucket-name>"
+          say "    replica_key_id: <public-key>"
+          say "    replica_access_key: <private-key>"
+          say ""
+          say "Verify configuration:"
+          say "  bin/rails litestream:env"
+        else
+          say "Configure Litestream in: config/initializers/litestream.rb"
+        end
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/pu/lite/rails_pulse/rails_pulse_generator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/plutonium_generators"
+
+module Pu
+  module Lite
+    class RailsPulseGenerator < Rails::Generators::Base
+      include PlutoniumGenerators::Generator
+      include PlutoniumGenerators::Concerns::ConfiguresSqlite
+      include PlutoniumGenerators::Concerns::MountsEngines
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Set up Rails Pulse for performance monitoring with SQLite"
+
+      class_option :database, type: :string, default: "rails_pulse",
+        desc: "Database name for Rails Pulse (default: rails_pulse)"
+      class_option :route, type: :string, default: "/manage/pulse",
+        desc: "Route path for Rails Pulse dashboard"
+
+      def start
+        bundle "rails_pulse"
+
+        if options[:database]
+          setup_separate_database
+        else
+          run_rails_pulse_install
+        end
+
+        template "config/initializers/rails_pulse.rb", force: true
+        mount_rails_pulse_engine
+        setup_recurring_tasks if solid_queue_installed?
+      rescue => e
+        exception "#{self.class} failed:", e
+      end
+
+      private
+
+      def run_rails_pulse_install
+        Bundler.with_unbundled_env do
+          run "bin/rails generate rails_pulse:install"
+        end
+      end
+
+      def setup_separate_database
+        @db_name = options[:database]
+
+        # Run install first - creates schema file and migration
+        Bundler.with_unbundled_env do
+          run "bin/rails generate rails_pulse:install --database=separate"
+        end
+
+        # Then add database config
+        add_sqlite_database(@db_name, migrations_paths: "db/rails_pulse_migrate")
+
+        # Finally prepare the database (runs migration that loads schema)
+        prepare_database(@db_name)
+      end
+
+      def mount_rails_pulse_engine
+        mount_engine %(mount RailsPulse::Engine, at: "#{options[:route]}"), authenticated: true
+      end
+
+      def solid_queue_installed?
+        gem_in_bundle?("solid_queue")
+      end
+
+      def setup_recurring_tasks
+        recurring_file = "config/recurring.yml"
+        return unless File.exist?(File.expand_path(recurring_file, destination_root))
+        return if file_includes?(recurring_file, "rails_pulse")
+
+        recurring_tasks = <<~YAML
+
+          rails_pulse_summary:
+            class: RailsPulse::SummaryJob
+            schedule: "5 * * * *" # 5 minutes past every hour
+
+          rails_pulse_cleanup:
+            class: RailsPulse::CleanupJob
+            schedule: "0 1 * * *" # Daily at 1am
+        YAML
+
+        append_to_file recurring_file, recurring_tasks
+      end
+    end
+  end
+end

data/lib/generators/pu/lite/rails_pulse/templates/config/initializers/rails_pulse.rb.tt

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RailsPulse.configure do |config|
+  # Enable/disable Rails Pulse globally
+  config.enabled = Rails.env.production? || Rails.env.development?
+
+  # Asset tracking (disable to reduce noise)
+  config.track_assets = false
+<%- if options[:database] -%>
+
+  # Use separate database for performance data
+  config.connects_to = {database: {writing: :<%= options[:database] %>}}
+<%- end -%>
+end

data/lib/generators/pu/lite/setup/setup_generator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/plutonium_generators"
+
+module Pu
+  module Lite
+    class SetupGenerator < Rails::Generators::Base
+      include PlutoniumGenerators::Generator
+
+      desc "Set up SQLite with proper configuration"
+
+      RAILS_8_VERSION = ::Gem::Version.new("8.0.0")
+
+      def start
+        ensure_sqlite3_version
+
+        # Add enhanced adapter for Rails 7
+        if rails_version < RAILS_8_VERSION
+          bundle "activerecord-enhancedsqlite3-adapter", version: "~> 0.8.0"
+        end
+      rescue => e
+        exception "#{self.class} failed:", e
+      end
+
+      private
+
+      SQLITE3_MIN_VERSION = ::Gem::Version.new("2.0.0")
+
+      def ensure_sqlite3_version
+        current = installed_gem_version("sqlite3")
+        if current.nil?
+          bundle "sqlite3", version: "~> 2.0"
+        elsif current < SQLITE3_MIN_VERSION
+          log :bundle, "updating sqlite3 from #{current} to ~> 2.0"
+          gsub_file "Gemfile", /^gem ["']sqlite3["'].*$/, 'gem "sqlite3", "~> 2.0"'
+          bundle!
+        end
+      end
+
+      def installed_gem_version(gem_name)
+        lockfile = File.join(destination_root, "Gemfile.lock")
+        return nil unless File.exist?(lockfile)
+
+        content = File.read(lockfile)
+        match = content.match(/#{gem_name} \((\d+\.\d+\.\d+)/)
+        ::Gem::Version.new(match[1]) if match
+      end
+
+      def rails_version
+        @rails_version ||= ::Gem::Version.new(Rails::VERSION::STRING).release
+      end
+    end
+  end
+end

data/lib/generators/pu/lite/solid_cable/solid_cable_generator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/plutonium_generators"
+
+module Pu
+  module Lite
+    class SolidCableGenerator < Rails::Generators::Base
+      include PlutoniumGenerators::Generator
+      include PlutoniumGenerators::Concerns::ConfiguresSqlite
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Set up Solid Cable for Action Cable with SQLite"
+
+      class_option :database, type: :string, default: "cable",
+        desc: "Database name for Solid Cable"
+
+      def start
+        @db_name = options[:database]
+
+        bundle "solid_cable"
+        add_sqlite_database(@db_name)
+        run_solid_cable_install
+        configure_cable_yml
+        prepare_database(@db_name)
+      rescue => e
+        exception "#{self.class} failed:", e
+      end
+
+      private
+
+      def run_solid_cable_install
+        Bundler.with_unbundled_env do
+          run "bin/rails generate solid_cable:install", env: {"DATABASE" => @db_name}
+        end
+        run "git checkout -- config/environments/production.rb 2>/dev/null || true"
+      end
+
+      def configure_cable_yml
+        cable_file = "config/cable.yml"
+        remove_file cable_file
+        create_file cable_file, <<~YAML
+          default: &default
+            adapter: solid_cable
+            polling_interval: 1.second
+            keep_messages_around_for: 1.day
+            connects_to:
+              database:
+                writing: #{@db_name}
+
+          development:
+            <<: *default
+            silence_polling: true
+
+          test:
+            <<: *default
+
+          production:
+            <<: *default
+            polling_interval: 0.1.seconds
+        YAML
+      end
+    end
+  end
+end

data/lib/generators/pu/lite/solid_cache/solid_cache_generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/plutonium_generators"
+
+module Pu
+  module Lite
+    class SolidCacheGenerator < Rails::Generators::Base
+      include PlutoniumGenerators::Generator
+      include PlutoniumGenerators::Concerns::ConfiguresSqlite
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Set up Solid Cache with SQLite"
+
+      class_option :database, type: :string, default: "cache",
+        desc: "Database name for Solid Cache"
+      class_option :dev_cache, type: :boolean, default: true,
+        desc: "Enable caching in development"
+
+      def start
+        @db_name = options[:database]
+
+        bundle "solid_cache"
+        add_sqlite_database(@db_name)
+        run_solid_cache_install
+        configure_cache_yml
+        configure_application
+        prepare_database(@db_name)
+        enable_dev_cache if options[:dev_cache]
+      rescue => e
+        exception "#{self.class} failed:", e
+      end
+
+      private
+
+      def run_solid_cache_install
+        Bundler.with_unbundled_env do
+          run "bin/rails generate solid_cache:install", env: {"DATABASE" => @db_name}
+        end
+        run "git checkout -- config/environments/production.rb 2>/dev/null || true"
+      end
+
+      def configure_cache_yml
+        cache_file = "config/cache.yml"
+        gsub_file cache_file, "database: <%= Rails.env %>", "database: #{@db_name}"
+        gsub_file cache_file, "database: cache", "database: #{@db_name}"
+      end
+
+      def configure_application
+        create_file "config/initializers/solid_cache.rb", <<~RUBY
+          # frozen_string_literal: true
+
+          Rails.application.configure do
+            config.cache_store = :solid_cache_store
+          end
+        RUBY
+      end
+
+      def enable_dev_cache
+        Bundler.with_unbundled_env do
+          run "bin/rails dev:cache"
+        end
+      end
+    end
+  end
+end