mkbrut 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44490857b7335985f6af254391ecc787fccfcb53bc5a42023462d6bf164a86b7
-  data.tar.gz: c664733ee5228fbe20616d919036c2b4717fad9fb2fdfe78d14da9ffc7118694
+  metadata.gz: 01efe075fd366adf916bf216ee4bca597ac46b4e70cad921e716e4cf9354066c
+  data.tar.gz: 7790e6f5c3d8f35f79a89ec64d3e4879fa8d80fc085cfb608135ec2dc354239e
 SHA512:
-  metadata.gz: f72502451676ded40f36837d6cf214d60ab8a0c4a5d28295cc859ef823ede5235521e04e3ef6497df61770ac69777116b01d6f42903e54160cf88b185ac307c2
-  data.tar.gz: 6c39188a7be33648d0a9907f665088483cdcbbf8f6c0294f4b4e446770e9d21a815877c1431b4adf3d00bb8e40ce1594de81541063e2421e8928a37768fead1c
+  metadata.gz: 9bf39f9ded150a7d98aed61649ad65182110fa52ccbd0ad491d7b40e07e00f63369b42ab0beec97b5cfb349faa8980ff0e8d3f9b8c446aa5bfd0fdf50ed07efb
+  data.tar.gz: d7ecb8ad272923a9f4471963d5535ebad77f8cdf69d786ea35e7a466b239e4062725f94053916ca0321de2010d2b77e9a43315e3464149c376faf8059235af24

data/lib/mkbrut/add_segment.rb

@@ -0,0 +1,38 @@
+require "fileutils"
+require "erb"
+
+module MKBrut
+  class AddSegment
+    def initialize(current_dir:, add_segment_options:, out:, err:)
+      @out = out
+      @add_segment_options = add_segment_options
+
+      @out.puts "Adding #{@add_segment_options.segment_name} to this app"
+
+      if @add_segment_options.dry_run?
+        @out.puts "Dry Run"
+        MKBrut::Ops::BaseOp.dry_run = true
+      end
+
+      templates_dir = Pathname(
+        Gem::Specification.find_by_name("mkbrut").gem_dir
+      ) / "templates"
+
+      @segment = if @add_segment_options.segment_name == "sidekiq"
+                   MKBrut::Segments::Sidekiq.new(
+                     project_root: add_segment_options.project_root,
+                     templates_dir:
+                   )
+                 elsif @add_segment_options.segment_name == "heroku"
+                   MKBrut::Segments::Heroku.new(
+                     project_root: add_segment_options.project_root,
+                     templates_dir:
+                   )
+                 end
+    end
+
+    def add!
+      @segment.add!
+    end
+  end
+end

data/lib/mkbrut/add_segment_options.rb

@@ -0,0 +1,22 @@
+class MKBrut::AddSegmentOptions
+  attr_reader :segment_name, :project_root
+
+  def initialize(
+    segment_name:,
+    project_root:,
+    dry_run: nil,
+    versions: nil,
+    **rest
+  )
+    if segment_name.nil?
+      raise ArgumentError, "segment_name is required"
+    end
+
+    @segment_name =   segment_name
+    @project_root =   project_root
+    @dry_run      = !!dry_run
+    @versions     =   versions
+  end
+
+  def dry_run? = @dry_run
+end

data/lib/mkbrut/app.rb

@@ -47,14 +47,19 @@ module MKBrut
         case segment
         when "heroku"
           @segments << MKBrut::Segments::Heroku.new(
-            app_options:,
-            current_dir:,
+            project_root: @base.project_root,
+            templates_dir:
+          )
+        when "sidekiq"
+          @segments << MKBrut::Segments::Sidekiq.new(
+            project_root: @base.project_root,
             templates_dir:
           )
         else
           raise "Segment #{segment} is not supported"
         end
       end
+      @segments.sort!
     end
 
     def create!

data/lib/mkbrut/base.rb

@@ -8,6 +8,7 @@ class MKBrut::Base
     def session_secret = SecureRandom.hex(64)
   end
 
+  attr_reader :project_root
   def initialize(app_options:, current_dir:, templates_dir:)
     @project_root  = current_dir / app_options.app_name
     @templates_dir = templates_dir / "Base"

data/lib/mkbrut/cli.rb

@@ -11,14 +11,56 @@ module MKBrut
 
     def run
 
-      app_options = parse_options(@args, MKBrut::Versions.new)
-      new_app = MKBrut::App.new(
-        current_dir: Pathname.pwd.expand_path,
-        app_options:,
-        out: PrefixedIO.new(@out, "mkbrut"),
-        err: @err
-      )
-      new_app.create!
+      command = if @args.first == "add-segment"
+                  @args.shift
+                  :add_segment
+                elsif @args.first == "new-app" || @args.first == "new"
+                  @args.shift
+                  :new_app
+                else
+                  :new_app
+                end
+
+      if command == :new_app
+        app_options = parse_options(@args, MKBrut::Versions.new)
+        new_app = MKBrut::App.new(
+          current_dir: Pathname.pwd.expand_path,
+          app_options:,
+          out: PrefixedIO.new(@out, "mkbrut"),
+          err: @err
+        )
+        new_app.create!
+      elsif command == :add_segment
+        add_segment_options = parse_add_segment_options(@args, MKBrut::Versions.new)
+        add_segment = MKBrut::AddSegment.new(
+          current_dir: add_segment_options.project_root,
+          add_segment_options:,
+          out: PrefixedIO.new(@out, "mkbrut"),
+          err: @err
+        )
+        add_segment.add!
+        @out.puts ""
+        @out.puts "Sidekiq has now been set up for your app. The configuration used is"
+        @out.puts "a basic one, suitable for getting started, however you know own this"
+        @out.puts "configuration.  Most of it is in these files:"
+        @out.puts ""
+        @out.puts "    app/config/sidekiq.yml"
+        @out.puts "    app/src/back_end/segments/sidekiq_segment.rb"
+        @out.puts ""
+        @out.puts "You are encouraged to verify everything is set up as follows:"
+        @out.puts ""
+        @out.puts "1. Quit dx/start, and start it back up - this will downloaded and set up ValKey/Redis"
+        @out.puts "2. Re-run bin/setup. This will install needed gems and create binstubs"
+        @out.puts "3. Run the example integration test:"
+        @out.puts ""
+        @out.puts "   bin/test e2e specs/integration/sidekiq_works.spec.rb"
+        @out.puts ""
+        @out.puts "   This will use the actual Sidekiq server, so if it passes, you should"
+        @out.puts "   all set and can start creating jobs"
+        @out.puts ""
+      else
+        raise "Unknown command #{command}"
+      end
       0
     rescue => e
       @err.puts "Error: #{e.message}"
@@ -103,5 +145,45 @@ module MKBrut
       MKBrut::AppOptions.new(**options, versions:)
     end
 
+    def parse_add_segment_options(args, versions)
+      options = {}
+      @option_parser = OptionParser.new do |opts|
+        opts.banner = [
+          "Usage: mkbrut add-segment [options] segment-name",
+          "",
+          "    Adds a segment to an existing Brut-powered app",
+          "",
+          "VERSION",
+          "",
+          "    #{MKBrut::VERSION}",
+          "",
+          "OPTIONS",
+          "",
+        ].join("\n")
+
+        opts.on("-r PROJECT_ROOT_DIR", "--project-root=PROJECT_ROOT_DIR", "Path to the root of the existing Brut app (defaults to current directory)")
+        opts.on("--dry-run", "Only show what would happen, don't actually do anything")
+        opts.on("--[no-]demo", "Include, or not, additional files that demonstrate Brut's features (default is true for now")
+        opts.on("-h", "--help", "Show this help message") do
+          @out.puts @option_parser
+          @out.puts
+          @out.puts "ARGUMENTS"
+          @out.puts
+          @out.puts "    segment-name - name of the segment to add.  Known values:"
+          @out.puts "                   sidekiq - add support for Sidekiq"
+          @out.puts "                   heroku  - add support for Heroku container-based deployment"
+          @out.puts
+          @out.puts "ENVIRONMENT VARIABLES"
+          @out.puts
+          @out.puts "  BRUT_CLI_RAISE_ON_ERROR - if set to 'true', any error will raise an exception instead of printing to stderr"
+          @out.puts
+          exit
+        end
+      end
+
+      @option_parser.parse!(args, into: options)
+      options[:project_root] = Pathname.new(options[:'project-root'] || ".").expand_path
+      MKBrut::AddSegmentOptions.new(segment_name: @args[0], **options, versions:)
+    end
   end
 end 

data/lib/mkbrut/ops/insert_code_in_method.rb

@@ -1,14 +1,25 @@
 class MKBrut::Ops::InsertCodeInMethod < MKBrut::Ops::PrismParsingOp
-  def initialize(file:, class_name:, method_name:, code:, where: :end)
-    @file        = file
-    @class_name  = class_name
-    @method_name = method_name.to_sym
-    @code        = code
-    @where       = where
+  def initialize(file:,
+                 class_name:,
+                 method_name:,
+                 class_method: false,
+                 code:,
+                 ignore_if_file_not_found: false,
+                 where: :end)
+    @file                     = file
+    @class_name               = class_name
+    @method_name              = method_name.to_sym
+    @class_method             = class_method
+    @code                     = code
+    @ignore_if_file_not_found = ignore_if_file_not_found
+    @where                    = where
   end
 
   def call
-    method_node = find_method(class_name: @class_name, method_name: @method_name)
+    if !@file.exist? && @ignore_if_file_not_found
+      return
+    end
+    method_node = find_method(class_name: @class_name, method_name: @method_name, class_method: @class_method)
 
     insertion_point = if @where == :start
                         insertion_point_for_code_at_start_of_method(method_node: method_node)
@@ -42,6 +53,7 @@ private
       }.join("\n") + post_indent
   end
 
+  # XXX: This does not work with non-ASCII strings
   def insertion_point_for_code_at_end_of_method(method_node:)
     line_number_of_method_end = method_node.location.end_line - 1
     length_of_method_end      = @source.lines[line_number_of_method_end].length

data/lib/mkbrut/ops/insert_into_file.rb

@@ -0,0 +1,36 @@
+class MKBrut::Ops::InsertIntoFile < MKBrut::Ops::BaseOp
+  def initialize(file:, content:, before_line:)
+    @file        = file
+    @content     = content
+    @before_line = before_line
+  end
+
+  def call
+
+    contents = File.read(@file)
+    locations = []
+    new_contents = []
+    contents.split("\n").each_with_index do |line, index|
+      if line == @before_line
+        new_contents << @content
+        locations << (index + 1)
+      end
+      new_contents << line
+    end
+    if locations.empty?
+      raise "Did not find line '#{@before_line}' exactly in #{@file}"
+    end
+    if locations.size > 1
+      raise "Found exact line '#{@before_line}' #{locations.size} times in #{@file}, should be exactly once so we know where to insert"
+    end
+
+    if dry_run?
+      puts "Would add to #{@file}, resulting in this content:\n#{new_contents.join("\n")}\n"
+      return
+    end
+
+    File.open(@file, "w") do |file|
+      file.puts new_contents.join("\n")
+    end
+  end
+end

data/lib/mkbrut/ops/prism_parsing_op.rb

@@ -56,10 +56,22 @@ private
     class_node
   end
 
-  def find_method(class_name:, method_name:)
+  def find_method(class_name:, method_name:, class_method: false)
     class_node = find_class(class_name:)
     method_node = class_node.body.body.detect { |node|
-      node.is_a?(Prism::DefNode) && node.name == @method_name
+
+      is_def            = node.is_a?(Prism::DefNode)
+      method_name_match = node.name == @method_name
+      receiver_match    = if class_method
+                            node.receiver.is_a?(Prism::SelfNode)
+                          else
+                            node.receiver.nil?
+                          end
+
+      if is_def && method_name_match && !receiver_match
+        puts "Found method '#{method_name}' in class '#{class_name}' but it was a #{node.receiver.class} receiver"
+      end
+      is_def && method_name_match && receiver_match
     }
 
     if !method_node

data/lib/mkbrut/ops.rb

@@ -8,6 +8,7 @@ module MKBrut
     autoload :InsertRoute, "mkbrut/ops/insert_route"
     autoload :InsertCodeInMethod, "mkbrut/ops/insert_code_in_method"
     autoload :AppendToFile, "mkbrut/ops/append_to_file"
+    autoload :InsertIntoFile, "mkbrut/ops/insert_into_file"
     autoload :PrismParsingOp, "mkbrut/ops/prism_parsing_op"
     autoload :AddI18nMessage, "mkbrut/ops/add_i18n_message"
     autoload :AddCSSImport, "mkbrut/ops/add_css_import"

data/lib/mkbrut/segments/bare_bones.rb

@@ -9,6 +9,14 @@ class MKBrut::Segments::BareBones < MKBrut::Base
     @erb_binding   = ErbBindingDelegate.new(app_options)
   end
 
+  def <=>(other)
+    if self.class == other.class
+      0
+    else
+      -1
+    end
+  end
+
   def add!
 
     operations = copy_files(@templates_dir, @project_root) + 

data/lib/mkbrut/segments/demo.rb

@@ -10,6 +10,14 @@ class MKBrut::Segments::Demo < MKBrut::Base
     @erb_binding   = ErbBindingDelegate.new(app_options)
   end
 
+  def <=>(other)
+    if self.class == other.class
+      0
+    else
+      1
+    end
+  end
+
   def add!
     operations = copy_files(@templates_dir, @project_root) + 
                  other_operations(@project_root)

data/lib/mkbrut/segments/heroku.rb

@@ -1,10 +1,9 @@
 class MKBrut::Segments::Heroku < MKBrut::Base
   def self.friendly_name = "Heroku-based Deployment"
 
-  def initialize(app_options:, current_dir:, templates_dir:)
-    @project_root  = current_dir / app_options.app_name
+  def initialize(project_root:, templates_dir:)
+    @project_root  = project_root
     @templates_dir = templates_dir / "segments" / "Heroku"
-    @erb_binding   = MKBrut::ErbBindingDelegate.new(app_options)
   end
 
   def add!
@@ -16,8 +15,29 @@ class MKBrut::Segments::Heroku < MKBrut::Base
     end
   end
 
+  def <=>(other)
+    if self.class == other.class
+      0
+    elsif other.class == MKBrut::Segments::Sidekiq
+      # If both herkou and sidekiq segments are activated, we want to do heroku first,
+      # since Sidekiq will need to modify it.
+      -1
+    else
+      1
+    end
+  end
+
   def other_operations
     [
+      MKBrut::Ops::InsertIntoFile.new(
+        file: @project_root / "Dockerfile.dx",
+        contents: %{
+# Installs the Heroku CLI, per Heroku docs at 
+# https://devcenter.heroku.com/articles/heroku-cli#install-with-ubuntu-debian-apt-get
+RUN curl https://cli-assets.heroku.com/install-ubuntu.sh | sh
+},
+        before_line: "# Up to now, RUN directives ran as the root user.  When using this container"
+      ),
       MKBrut::Ops::AppendToFile.new(
         file: @project_root / ".gitignore",
         content: %{

data/lib/mkbrut/segments/sidekiq.rb

@@ -1,3 +1,138 @@
 # Adds Sidekiq to a Brut app
-class MKBrut::Segments::Sidekiq
+class MKBrut::Segments::Sidekiq < MKBrut::Base
+  def self.friendly_name = "Use Sidekiq to Run Background Jobs"
+  def initialize(project_root:, templates_dir:)
+    @project_root  = project_root
+    @templates_dir = templates_dir / "segments" / "Sidekiq"
+  end
+
+  def add!
+    operations = copy_files(@templates_dir, @project_root) + 
+                 other_operations
+
+    operations.each do |operation|
+      operation.call
+    end
+  end
+
+  def <=>(other)
+    if self.class == other.class
+      0
+    elsif other.class == MKBrut::Segments::Heroku
+      # If both herkou and sidekiq segments are activated, we want to do heroku first,
+      # since Sidekiq will need to modify it.
+      1
+    else
+      -1
+    end
+  end
+
+  def other_operations
+    [
+      MKBrut::Ops::AppendToFile.new(
+        file: @project_root / "docker-compose.dx.yml",
+        content: %{
+  redis:
+    # Change the value to what you are using in production.
+    # If you are using actual Redis, change that here.
+    image: valkey/valkey:8.1
+},
+      ),
+      MKBrut::Ops::AppendToFile.new(
+        file: @project_root / "Procfile.development",
+        content: "sidekiq: bin/run sidekiq\n"
+      ),
+      MKBrut::Ops::AppendToFile.new(
+        file: @project_root / "Procfile.test",
+        content: "sidekiq: bin/run sidekiq\n"
+      ),
+      MKBrut::Ops::AppendToFile.new(
+        file: @project_root / "Gemfile",
+        content: "# Sidekiq is used for background jobs\ngem \"sidekiq\"\n"
+      ),
+      MKBrut::Ops::AppendToFile.new(
+        file: @project_root / ".env.development",
+        content: %{
+# URL of the Redis/ValKey to use for Sidekiq
+SIDEKIQ_REDIS_URL=redis://redis:6379/1
+# Tells Sidekiq which ENV var to use for the Redis/ValKey URL
+REDIS_PROVIDER=SIDEKIQ_REDIS_URL
+# Username for basic auth into the Sidekiq Admin UI
+SIDEKIQ_BASIC_AUTH_USER=sidekiq
+# Passsword for basic auth into the Sidekiq Admin UI
+SIDEKIQ_BASIC_AUTH_PASSWORD=password
+}
+      ),
+      MKBrut::Ops::AppendToFile.new(
+        file: @project_root / ".env.test",
+        content: %{
+SIDEKIQ_REDIS_URL=redis://redis:6379/2
+REDIS_PROVIDER=SIDEKIQ_REDIS_URL
+SIDEKIQ_BASIC_AUTH_USER=sidekiq-test
+SIDEKIQ_BASIC_AUTH_PASSWORD=password
+}
+      ),
+      MKBrut::Ops::InsertIntoFile.new(
+        file: @project_root / "bin" / "test-server",
+        before_line: "wait",
+        content: "bin/run sidekiq &\n",
+      ),
+      MKBrut::Ops::InsertIntoFile.new(
+        file: @project_root / "bin" / "setup",
+        before_line: "  log \"Installing rspec binstubs\"",
+        content: %{log "Installing sidekiq binstubs"
+  system! "bundle binstub sidekiq"
+}
+      ),
+      MKBrut::Ops::InsertIntoFile.new(
+        file: @project_root / "specs" / "spec_helper.rb",
+        before_line: "require \"brut/spec_support\"",
+        content: "require \"sidekiq/testing\""
+      ),
+      MKBrut::Ops::InsertIntoFile.new(
+        file: @project_root / "config.ru",
+        before_line: "bootstrap = Bootstrap.new.bootstrap!",
+        content: "require \"sidekiq/web\"\n"
+      ),
+      MKBrut::Ops::InsertIntoFile.new(
+        file: @project_root / "config.ru",
+        before_line: "  run bootstrap.rack_app",
+        content: %{
+  map "/sidekiq" do
+    use Rack::Auth::Basic, "Sidekiq" do |username, password|
+      [username, password] == [ENV.fetch("SIDEKIQ_BASIC_AUTH_USER"), ENV.fetch("SIDEKIQ_BASIC_AUTH_PASSWORD")]
+    end
+    run Sidekiq::Web.new
+  end
+}
+      ),
+      MKBrut::Ops::InsertCodeInMethod.new(
+        file: @project_root / "app" / "src" / "app.rb",
+        class_name: "App",
+        method_name: "initialize",
+        code: "@sidekiq_segment = SidekiqSegment.new",
+      ),
+      MKBrut::Ops::InsertCodeInMethod.new(
+        file: @project_root / "app" / "src" / "app.rb",
+        class_name: "App",
+        method_name: "boot!",
+        code: "@sidekiq_segment.boot!"
+      ),
+      MKBrut::Ops::InsertCodeInMethod.new(
+        file: project_root / "deploy" / "heroku_config.rb",
+        class_name: "HerokuConfig",
+        method_name: "additional_images",
+        class_method: true,
+        ignore_if_file_not_found: true,
+        code: %{
+{
+  "sidekiq" => {
+    cmd: "bin/run sidekiq",
+  }
+}
+        },
+        where: :end
+      ),
+    ]
+  end
 end

data/lib/mkbrut/segments.rb

@@ -2,7 +2,7 @@ module MKBrut
   module Segments
     autoload :BareBones, "mkbrut/segments/bare_bones"
     autoload :Demo, "mkbrut/segments/demo"
-    autoload :Sidekiq, "mkbrut/segments/demo"
+    autoload :Sidekiq, "mkbrut/segments/sidekiq"
     autoload :Heroku, "mkbrut/segments/heroku"
   end
 end

data/lib/mkbrut/version.rb

@@ -1,3 +1,3 @@
 module MKBrut
-  VERSION = "0.15.0"
+  VERSION = "0.16.0"
 end

data/lib/mkbrut.rb

@@ -3,6 +3,8 @@ module MKBrut
   autoload :AppId, "mkbrut/app_id"
   autoload :AppName, "mkbrut/app_name"
   autoload :AppOptions, "mkbrut/app_options"
+  autoload :AddSegment, "mkbrut/add_segment"
+  autoload :AddSegmentOptions, "mkbrut/add_segment_options"
   autoload :Base, "mkbrut/base"
   autoload :CLI, "mkbrut/cli"
   autoload :ErbBindingDelegate, "mkbrut/erb_binding_delegate"

data/templates/Base/.gitignore

@@ -17,6 +17,9 @@
 
 # This could contain actual secrets and should not be checked in
 /.env.development.local
+# This could also contain actual secrets and should not be checked in - it's configuration
+# per developer, not per app
+/dx/bash_customizations.local
 
 # These are generated artifacts
 /deploy/Dockerfile.*

data/templates/Base/Dockerfile.dx

@@ -25,13 +25,18 @@ ENV DEBIAN_FRONTEND=noninteractive
 # These packages are needed to set up other repos to install other
 # packages and/or are useful in installing other software
 #
+# --mount=type=cache,target=/var/cache/apt means that we'll save
+# the downloaded file used to install between builds, so that if they
+# have not changed, builds will be faster.
+#
 # - ca-certificates  - needed by Postgres client
 # - curl             - needed by various installation instructions
 # - gnupg            - needed to install Docker
 # - lsb-release      - needed by Postgres install instructions
 # - rsync            - needed by Brut's build_assets command
 # - vim              - needed when we want to edit files inside container
-RUN apt-get -y clean && \
+RUN --mount=type=cache,target=/var/cache/apt \
+    apt-get -y clean && \
     apt-get -y update && \
     apt-get install --quiet --yes \
       ca-certificates \
@@ -47,7 +52,8 @@ RUN apt-get -y clean && \
 #
 #     npx playwright install-deps --dry-run chromium
 #
-RUN apt-get install -y --no-install-recommends libasound2 \
+RUN --mount=type=cache,target=/var/cache/apt \
+    apt-get install -y --no-install-recommends libasound2 \
                                                libatk-bridge2.0-0 \
                                                libatk1.0-0 \
                                                libatspi2.0-0 \
@@ -117,10 +123,6 @@ RUN echo "gem: --no-document" >> ~/.gemrc && \
     gem update --system && \
     gem install bundler
 
-# Installs the Heroku CLI, per Heroku docs at 
-# https://devcenter.heroku.com/articles/heroku-cli#install-with-ubuntu-debian-apt-get
-RUN curl https://cli-assets.heroku.com/install-ubuntu.sh | sh
-
 # Up to now, RUN directives ran as the root user.  When using this container
 # for development, we do not want to run as the root user.  On macOS, this is not 
 # a big deal, but in Linux, the root user inside this container can create files
@@ -178,28 +180,23 @@ COPY --chown=appuser:${user_gid} dx/bash_customizations.local /home/appuser/.bas
 # as belonging to.
 USER appuser
 
-# Install NodeJS, per https://nodejs.org/en/download
-#
-# Yes, this is seting up nvm just to install one version of node we will ever user in
-# here and yes, this sucks.  But it's better to use the vendor's official
-# recommendation.
-RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash && \
-    \. "$HOME/.nvm/nvm.sh" && \
-    nvm install 22 && \
-    node -v && nvm current && npm -v
-
-
+# Installs NodeJS from the official image.  This is simpler
+# than the canonical instructions which use NVM.  Inside the container, there
+# is not value to use NVM.
+COPY --from=node:22-slim /usr/local /usr/local
 
 # This arg should have the version of playwright present in the app's Gemfile.lock.
 # This is because the playright NodeJS library and the Ruby gem must have the same
 # version or things won't work right.  The value is blank because it really has to be
 # detected during `dx/build`.
 ARG PLAYWRIGHT_VERSION
+
 # Now install the version of Playwright we detected as well as Chromium. NOTE, we
 # must install Chromium, not chrome, because there is no version of Chrome for an
 # ARM-based Debian linux, which is what this Dockerfile will build on an Apple
-# Silicon Mac.
-RUN \. "$HOME/.nvm/nvm.sh" && \
-    nvm use default && \
-    npm install -g playwright@$PLAYWRIGHT_VERSION && \
+# Silicon Mac. Note that we set NPM_CONFIG_PREFIX so that the global
+# install will work for this user.
+ENV NPM_CONFIG_PREFIX=/home/appuser/.npm-global
+ENV PATH=/home/appuser/.npm-global/bin:$PATH
+RUN npm install -g playwright@$PLAYWRIGHT_VERSION && \
     npx playwright install chromium

data/templates/Base/Gemfile.erb

@@ -40,7 +40,7 @@ gem "pg"
 # We lock the version because it must be the same as the verison
 # of playwright in package.json.  This ensures that we can reliably
 # install the right browsers and that everything will work right.
-gem "playwright-ruby-client", "1.52.0", groups: [ :test ]
+gem "playwright-ruby-client", "1.55.0", groups: [ :test ]
 
 # Sinatra needs a webserver and puma is the best
 gem "puma"

data/templates/Base/bin/run

@@ -1,86 +1,126 @@
-#!/bin/sh
+#!/usr/bin/env bash
 
 set -e 
-SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
-
-usage() {
-  echo "Usage: $0"
-  echo
-  echo "    Run the app in the given RACK_ENV."
-  echo "    You likely want to use bin/dev instead of this command."
-  echo
-  echo "ENVIRONMENT VARIABLES"
-  echo
-  echo "   PORT     - The port to run the app on. Default is 6502"
-  echo "   RACK_ENV - The Rack environment to use. Default is development"
-  echo
-}
-
-for arg in "$@"; do
-  if [ "${arg}" = "-h" ] || [ "${arg}" = "--help" ] || [ "${arg}" = "help" ]; then
-    usage
-    exit 0
-  fi
-done
 
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
 PORT="${PORT:-6502}"
 RACK_ENV="${RACK_ENV:-development}"
 
 export PORT
 export RACK_ENV
 
-set -e 
+declare -A CMD_MAP
+declare -A PIDFILE_MAP
+declare -A CREATES_PIDFILE_MAP
 
-# Everything here is trying its best to prevent more than
-# one server from running, as this is extremely confusing.
-# Note that the puma invocation at the bottom
-# of this script uses the pidfile concept.
-if [ -f tmp/pidfile ]; then
-  echo "[ $0 ] pidfile found"
-  pid=$(cat tmp/pidfile)
-
-  # First, try to gracefully stop the server with kill
-  if ps -p "${pid}" > /dev/null; then
-    echo "[ $0 ] Attempting to kill PID '${pid}'"
-    kill "${pid}"
-  else
-    echo "[ $0 ] PID '${pid}' no longer running"
+kill_previous() {
+  local pidfile=$1
+
+  if [[ -z "$pidfile" ]]; then
+    echo "[ $0 ] Error: no pidfile path given"
+    return 0
   fi
 
-  # Now, wait 5 seconds to see if it stopped
-  if timeout 5 tail --pid="${pid}" -f /dev/null; then
-    echo "[ $0 ] PID '${pid}' stopped. Restarting server"
-  else
-    # if it has not stopeed, use kill -9 which should work.
-    # But, like all things computer, it's not guaranteed.
-    echo "[ $0 ] PID '${pid}' has not stopped. Trying kill -9"
-    kill -9 "${pid}"
-    if timeout 1 tail --pid="${pid}" -f /dev/null; then
-      echo "[ $0 ] PID '${pid}' killed. Restarting server"
+  if [ -f "${pidfile}" ]; then
+    echo "[ $0 ] pidfile found"
+    pid=$(cat "${pidfile}")
+
+    if [[ -z "$pid" || ! "$pid" =~ ^[0-9]+$ ]]; then
+      echo "[ $0 ] Invalid or empty PID in $pidfile: '$pid'; removing"
+      rm -f "$pidfile"
+      return 0
+    fi
+
+    if ps -p "${pid}" > /dev/null; then
+      echo "[ $0 ] Attempting to kill PID '${pid}'"
+      kill "${pid}"
+    else
+      echo "[ $0 ] PID '${pid}' no longer running"
+    fi
+    if timeout 5 tail --pid="${pid}" -f /dev/null; then
+      echo "[ $0 ] PID '${pid}' stopped. Restarting server"
     else
-      echo "[ $0 ] PID '${pid}' still running. Something seriously wrong"
-      echo "[ $0 ] You may need to stop all Docker containers and restart them"
+      echo "[ $0 ] PID '${pid}' has not stopped. Trying kill -9"
+      kill -9 "${pid}"
+      if timeout 1 tail --pid="${pid}" -f /dev/null; then
+        echo "[ $0 ] PID '${pid}' killed. Restarting server"
+      else
+        echo "[ $0 ] PID '${pid}' still running. Something seriously wrong"
+      fi
       exit 1
     fi
+
+  else
+    echo "[ $0 ] No pidfile-Starting up"
   fi
+}
 
-else
-  echo "[ $0 ] No pidfile-Starting up"
+dotenv_run() {
+  local env_files="${SCRIPT_DIR}/../.env.${RACK_ENV}.local,${SCRIPT_DIR}/../.env.${RACK_ENV}"
+  dotenv -f "$env_files" --ignore -- "$@"
+}
+
+
+for f in "$SCRIPT_DIR"/run.*; do
+  if [[ -f "$f" ]]; then
+    echo "[ $0 ] Sourcing $f"
+    . "$f"
+  fi
+done
+
+case $# in
+  0) name="run" ;;
+  1) name="$1" ;;
+  *) echo "Error: too many arguments ($#)." >&2; usage; exit 2 ;;
+esac
+
+if [[ ! -v CMD_MAP[$name] ]]; then
+  echo "[ $0 ] Error: unknown service '$name'." >&2
+  echo -n "[ $0 ] Known services: " >&2
+  printf "%s " "${!CMD_MAP[@]}" >&2
+  echo >&2
+  exit 1
 fi
 
-# Run puma in a UNIX environment provided by dotenv.
-#
-# A few things to note:
-#
-# * dotenv is OK if -f is given non-existent files. That's why this works
-#   in production where there are no .env files.
-# * the `--` marks the end of dotenv's options and the start of the command
-#   to run. That's why the flags given to puma are not interpreted by dotenv
-#   as flags for itself.
-dotenv \
-  -f "${SCRIPT_DIR}/../.env.${RACK_ENV}.local,${SCRIPT_DIR}/../.env.${RACK_ENV}" \
-  --ignore \
-  -- \
-  bin/puma \
-    -C puma.config.rb \
-    --pid tmp/pidfile
+cmd="${CMD_MAP[$name]}"
+creates_pidfile="${CREATES_PIDFILE_MAP[$name]:-false}"
+pidfile="${PIDFILE_MAP[$name]:-}"
+
+echo "[ $0 ]: Command for $name:"
+echo
+echo "          $cmd"
+echo
+
+kill_previous "$pidfile"
+
+if [[ "$creates_pidfile" == true ]]; then
+  echo "[ $0 ] Running '$cmd', which creates its own pidfile"
+  eval "dotenv_run $cmd"
+else
+  # Command wont' create a pidfile, so we will
+  if [[ -z "${pidfile:-}" ]]; then
+    echo "Error: no pidfile path configured for '$name' but creates_pidfile=false." >&2
+    exit 1
+  fi
+  echo "[ $0 ] Running '$cmd', which will not create a pidfile"
+  echo "[ $0 ] We will do that and save it to ${pidfile}"
+
+  echo "[ $0 ] Ensuring $(dirname "$pidfile") exists"
+  mkdir -p "$(dirname "$pidfile")"
+
+  eval "dotenv_run $cmd &"
+  child_pid=$!
+
+  set +e
+  echo "$child_pid" > "$pidfile"
+
+  trap 'kill -TERM "$child_pid" 2>/dev/null' TERM INT
+
+  wait "$child_pid"
+
+  echo "[ $0 ] TERM or INT received, removing ${pidfile} and exiting"
+
+  status=$?
+  rm -f "$pidfile"
+  exit "$status"
+fi

data/templates/Base/bin/run.run

@@ -0,0 +1,4 @@
+PIDFILE="${SCRIPT_DIR}/../tmp/pidfile"
+CMD_MAP[run]="bin/puma --port ${PORT} -C puma.config.rb --environment ${RACK_ENV} --pid ${PIDFILE}"
+PIDFILE_MAP[run]="${PIDFILE}"
+CREATES_PIDFILE_MAP[run]="true"

data/templates/Base/bin/setup

@@ -1,10 +1,11 @@
 #!/usr/bin/env ruby
 
-
 require "fileutils"
 require "open3"
 require "optparse"
 require "pathname"
+require "bundler"
+require "json"
 
 # This is intended to run inside the Workspace (i.e. Docker container) to
 # set up the Foundation, thus enabling development.  This script should:
@@ -21,6 +22,7 @@ require "pathname"
 #       Take care to only add code and not change what is here.
 
 def setup(update_gems:,update_node:)
+  ensure_versions_are_consistent!
   if update_gems
     log "Updating gems"
     system! "bundle update"
@@ -82,6 +84,35 @@ def setup(update_gems:,update_node:)
   help
 end
 
+def ensure_versions_are_consistent!
+  gemfile      = Bundler::Definition.build(ROOT_DIR / "Gemfile", ROOT_DIR / "Gemfile.lock", nil)
+  package_json = JSON.parse(File.read(ROOT_DIR / "package.json"))
+
+  playwright_version = nil
+  gemfile.dependencies.each do |dep|
+    if dep.name == "playwright-ruby-client"
+      if !dep.specific?
+        puts "You must specify an exact/specific version of 'playwright-ruby-client' in your Gemfile"
+        exit 1
+      end
+      playwright_version = dep.requirement.requirements.first[1]
+    end
+  end
+
+  if playwright_version
+    playwright_version_in_package_json = package_json.dig("devDependencies","playwright")
+    if !playwright_version_in_package_json
+      puts "You must have 'playwright' in the devDependencies section of your package.json"
+      exit 1
+    end
+    if playwright_version != playwright_version_in_package_json
+      puts "The version of 'playwright' in package.json (#{playwright_version_in_package_json}) does not match the version of 'playwright-ruby-client' in the Gemfile (#{playwright_version})"
+      puts "They must be exactly the same, or your end-to-end tests may behave strangely"
+      exit 1
+    end
+  end
+end
+
 def setup_dot_env_local
 
   dot_env = ROOT_DIR / ".env.development"

data/templates/Base/dx/bash_customizations

@@ -6,7 +6,3 @@ if [ ! -n "$PROJECT_ROOT" ]; then
 fi
 export GEM_HOME=${PROJECT_ROOT}/local-gems/gem-home
 export PATH=${PATH}:${GEM_HOME}/bin
-# This sets up the Node version so we don't have to do it before every. single.
-# shell. invocation.
-. ~/.nvm/nvm.sh
-nvm use default

data/templates/Base/package.json.erb

@@ -11,7 +11,7 @@
     "esbuild": "^0.20.2",
     "jsdom": "^25.0.1",
     "mocha": "^10.7.3",
-    "playwright": "1.50.1",
+    "playwright": "1.55.0",
     "typescript": "^5.8.3",
     "typescript-language-server": "^4.3.4",
     "vscode-langservers-extracted": "^4.10.0"

data/templates/segments/Heroku/deploy/Dockerfile

@@ -37,7 +37,8 @@ WORKDIR /brut-app
 # - lsb-release is used to generically access information for this OS's version
 # - wget allows us to copy/paste commands from vendors about how to install
 #   software even though it does the same thing as curl
-RUN apt-get update --quiet --yes && \
+RUN --mount=type=cache,target=/var/cache/apt \
+    apt-get update --quiet --yes && \
     apt-get install --no-install-recommends --quiet --yes \
       ca-certificates \
       curl \
@@ -54,16 +55,17 @@ RUN apt-get update --quiet --yes && \
 #
 # Incancation is based on: https://www.postgresql.org/download/linux/debian/
 RUN /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y && \
-    apt-get update && \
-    apt-get --yes --quiet install postgresql-client-16 && \
+    apt-get update --quiet --yes && \
+    apt-get --yes --quiet --no-install-recommends install postgresql-client-16 && \
 		rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*
 
 # Set basic env vars for production
 ENV RACK_ENV="production" \
     BUNDLE_DEPLOYMENT="1" \
     BUNDLE_PATH="/usr/local/bundle" \
-    BUNDLE_WITHOUT="development" \
-    APP_GIT_SHA1="${app_git_sha1}"
+    BUNDLE_WITHOUT="development"
+
+RUN rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*
 
 # This makes a new image that we'll throw away after building
 # needed artifacts.
@@ -74,35 +76,34 @@ FROM base AS build
 # - libpq-dev is needed by postgres
 # - pkg-config is, I guess, not considered "essential" (as in build-essential),
 #   but still needed to install downstream stuff
-RUN apt-get update --quiet --yes && \
+RUN --mount=type=cache,target=/var/cache/apt \
+    apt-get update --quiet --yes && \
     apt-get install --no-install-recommends --quiet --yes \
 			build-essential \
 			git \
       libpq-dev \
 			pkg-config
 
-# Install NodeJS, per https://nodejs.org/en/download
-RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash && \
-    \. "$HOME/.nvm/nvm.sh" && \
-    nvm install 22 && \
-    node -v && nvm current && npm -v
+# Copy NodeJS from the official image. This should be faster than
+# installing it via e.g. nvm
+COPY --from=node:22-slim /usr/local /usr/local
 
-# Copy the app into the file, excluding the contents of .dockerignore
-COPY . .
+# Copy Gemfile only as it may not change between deploys
+COPY Gemfile Gemfile.lock .
 
 # Install RubyGems from app's Gemfile
-RUN bundle install --verbose && \
+RUN --mount=type=cache,target=${BUNDLE_PATH}/cache \
+    bundle install --verbose && \
     rm -rf ~/.bundle/ "${BUNDLE_PATH}"/ruby/*/cache "${BUNDLE_PATH}"/ruby/*/bundler/gems/*/.git
 
+COPY package.json package-lock.json ./
 # Install Node Modules from package.json
-RUN \. "$HOME/.nvm/nvm.sh" && \
-    nvm use default && \
-    npm clean-install --no-audit --no-fund --verbose
+RUN npm clean-install --no-audit --no-fund --verbose
+
+COPY . .
 
 # Build all assets
-RUN \. "$HOME/.nvm/nvm.sh" && \
-    nvm use default && \
-    bin/build-assets && \
+RUN bin/build-assets && \
     rm -rf node_modules
 
 # We are now switching back to building the image that will be deployed.
@@ -118,7 +119,8 @@ RUN groupadd --system --gid 1000 brut && \
     chown -R brut:brut logs tmp
 USER 1000:1000
 
+ENV APP_GIT_SHA1="${app_git_sha1}"
+
 # This is used to execute other commands.  When the app is run in production,
 # this script is used to run it.
 ENTRYPOINT ["/brut-app/deploy/docker-entrypoint"]
-

data/templates/segments/Heroku/deploy/heroku_config.rb

@@ -8,19 +8,20 @@ class HerokuConfig
   # The format of this Hash is:
   #
   # {
-  #   "«image name» => {
-  #     cmd: "«command line for Dockerfile RUN directive»",
+  #   *image name* => {
+  #     cmd: *command line for Dockerfile RUN directive*,
   #   }
   # }
   #
-  # For example, if you have the Sidekiq segment installed, `bin/run-sidekiq`
+  # For example, if you have the Sidekiq segment installed, `bin/run sidekiq`
   # runs Sidekiq, so you would return this hash:
   #
   # {
   #   "sidekiq" => {
-  #     cmd: "bin/run-sidekiq",
+  #     cmd: "bin/run sidekiq",
   #   }
   # }
-  def self.additional_images = {}
+  #
+  def self.additional_images
+  end
 end
-

data/templates/segments/Sidekiq/app/boot_sidekiq.rb

@@ -0,0 +1,2 @@
+require_relative "bootstrap"
+bootstrap = Bootstrap.new.bootstrap!

data/templates/segments/Sidekiq/app/config/sidekiq.yml

@@ -0,0 +1,4 @@
+:concurrency: <%= ENV.fetch("SIDEKIQ_CONCURRENCY") { 5 } %>
+:timeout: <%= ENV.fetch("SIDEKIQ_TIMEOUT_SECONDS") { 25 } %>
+:queues:
+  - default

data/templates/segments/Sidekiq/app/src/back_end/jobs/app_job.rb

@@ -0,0 +1,3 @@
+class AppJob
+  include Sidekiq::Job
+end

data/templates/segments/Sidekiq/app/src/back_end/jobs/example_job.rb

@@ -0,0 +1,12 @@
+# This is entirely to allow the integration test to run
+# that verifies you have Sidekqi working and the segment was
+# installed correctly.  Once you have created a real job for
+# your app and done whatever testing you need, please delete
+# this job and the integration test.
+class ExampleJob < AppJob
+  def perform(path_to_file, contents)
+    File.open(path_to_file, "w") do |f|
+      f.puts(contents)
+    end
+  end
+end

data/templates/segments/Sidekiq/app/src/back_end/segments/sidekiq_segment.rb

@@ -0,0 +1,56 @@
+require "sidekiq"
+# Encapsulates all Sidekiq configuraiton beyond what can be done in
+# app/config/sidekiq.yml.  You can edit this as needed.
+class SidekiqSegment
+
+  def initialize
+    Brut.container.store(
+      "flush_spans_in_sidekiq?",
+      "Boolean",
+      "True if sidekiq jobs should flush all OTel spans after the job completes"
+    ) do |project_env|
+      if ENV["FLUSH_SPANS_IN_SIDEKIQ"] == "true"
+        true
+      elsif ENV["FLUSH_SPANS_IN_SIDEKIQ"] == "false"
+        false
+      else
+        project_env.development?
+      end
+    end
+  end
+
+  def boot!
+    Sidekiq.configure_server do |config|
+      config.redis = {
+        # Per https://devcenter.heroku.com/articles/connecting-heroku-redis#connecting-in-ruby
+        ssl_params: {
+          verify_mode: OpenSSL::SSL::VERIFY_NONE,
+        },
+      }
+      config.logger = SemanticLogger["Sidekiq:server"]
+      if Brut.container.flush_spans_in_sidekiq?
+        SemanticLogger[self.class].info("Sidekiq jobs will flush spans")
+        config.server_middleware do |chain|
+          if defined? OpenTelemetry::Instrumentation::Sidekiq::Middlewares::Server::TracerMiddleware
+            chain.insert_before OpenTelemetry::Instrumentation::Sidekiq::Middlewares::Server::TracerMiddleware,
+                                Brut::BackEnd::Sidekiq::Middlewares::Server::FlushSpans
+          else
+            SemanticLogger["Sidekiq:server"].warn("OpenTelemetry::Instrumentation::Sidekiq::Middlewares::Server::TracerMiddleware not defined")
+          end
+        end
+      else
+        SemanticLogger[self.class].info("Sidekiq jobs will not flush spans")
+      end
+    end
+
+    Sidekiq.configure_client do |config|
+      config.redis = {
+        # Per https://devcenter.heroku.com/articles/connecting-heroku-redis#connecting-in-ruby
+        ssl_params: {
+          verify_mode: OpenSSL::SSL::VERIFY_NONE,
+        },
+      }
+      config.logger = SemanticLogger["Sidekiq:client"]
+    end
+  end
+end

data/templates/segments/Sidekiq/bin/run.sidekiq

@@ -0,0 +1,4 @@
+PIDFILE="${SCRIPT_DIR}/../tmp/pidfile.sidekiq"
+CMD_MAP[sidekiq]="bin/sidekiq --config ${SCRIPT_DIR}/../app/config/sidekiq.yml  --require ${SCRIPT_DIR}/../app/boot_sidekiq.rb --verbose"
+PIDFILE_MAP[sidekiq]="${PIDFILE}"
+CREATES_PIDFILE_MAP[sidekiq]="false"

data/templates/segments/Sidekiq/specs/back_end/jobs/example_job.spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+RSpec.describe ExampleJob do
+  implementation_is_trivial
+end

data/templates/segments/Sidekiq/specs/integration/sidekiq_works.spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+require "timeout"
+
+# This test will ensure that Sidekiq segment was installed
+# correctly and your app can use Sidekiq. Once you have
+# created a real job for your app, delete ExampleJob and this test.
+RSpec.describe "Sidekiq is working", e2e: true do
+  it "processes jobs using the real Sidekiq server" do
+    # ExampleJob will write contents to a file.  This 
+    # test will delete that fail, queue the job, then
+    # wait up to 5 seconds for the job to run and create
+    # the file with the contents.  This should be more than
+    # enough time.
+    file = Brut.container.tmp_dir / "sidekiq_test.txt"
+    if file.exist?
+      file.delete
+    end
+
+    # If the file still exists at this point, the test
+    # will pass even if Sidekiq is not working.
+    confidence_check { expect(file.exist?).to eq(false) }
+
+    ExampleJob.perform_async(file.to_s, "test content for file")
+    queue_name = ExampleJob.sidekiq_options["queue"]
+    expect {
+      Timeout.timeout(5) do
+        loop do
+          if file.exist?
+            break
+          end
+          sleep 0.1
+        end
+      end
+    }.not_to raise_error
+    content = File.read(file)
+    expect(content).to eq("test content for file\n")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mkbrut
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Dave Copeland
@@ -34,6 +34,8 @@ extra_rdoc_files: []
 files:
 - exe/mkbrut
 - lib/mkbrut.rb
+- lib/mkbrut/add_segment.rb
+- lib/mkbrut/add_segment_options.rb
 - lib/mkbrut/app.rb
 - lib/mkbrut/app_id.rb
 - lib/mkbrut/app_name.rb
@@ -51,6 +53,7 @@ files:
 - lib/mkbrut/ops/base_op.rb
 - lib/mkbrut/ops/copy_file.rb
 - lib/mkbrut/ops/insert_code_in_method.rb
+- lib/mkbrut/ops/insert_into_file.rb
 - lib/mkbrut/ops/insert_route.rb
 - lib/mkbrut/ops/mkdir.rb
 - lib/mkbrut/ops/prism_parsing_op.rb
@@ -68,7 +71,6 @@ files:
 - lib/mkbrut/versions.rb
 - templates/Base/.dockerignore
 - templates/Base/.env.development.erb
-- templates/Base/.env.development.local
 - templates/Base/.env.test.erb
 - templates/Base/.gitignore
 - templates/Base/.projections.json
@@ -119,6 +121,7 @@ files:
 - templates/Base/bin/dev
 - templates/Base/bin/release
 - templates/Base/bin/run
+- templates/Base/bin/run.run
 - templates/Base/bin/scaffold
 - templates/Base/bin/setup
 - templates/Base/bin/startup-message
@@ -173,6 +176,14 @@ files:
 - templates/segments/Heroku/deploy/Dockerfile
 - templates/segments/Heroku/deploy/docker-entrypoint
 - templates/segments/Heroku/deploy/heroku_config.rb
+- templates/segments/Sidekiq/app/boot_sidekiq.rb
+- templates/segments/Sidekiq/app/config/sidekiq.yml
+- templates/segments/Sidekiq/app/src/back_end/jobs/app_job.rb
+- templates/segments/Sidekiq/app/src/back_end/jobs/example_job.rb
+- templates/segments/Sidekiq/app/src/back_end/segments/sidekiq_segment.rb
+- templates/segments/Sidekiq/bin/run.sidekiq
+- templates/segments/Sidekiq/specs/back_end/jobs/example_job.spec.rb
+- templates/segments/Sidekiq/specs/integration/sidekiq_works.spec.rb
 homepage: https://brutrb.com
 licenses: []
 metadata: {}
@@ -190,7 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Create a new Brut App
 test_files: []

data/templates/Base/.env.development.local

@@ -1,2 +0,0 @@
-# Place developer-specific overrides of .env.development in here, 
-# e.g. API keys needed for local dev. DO NOT CHECK INTO VERSION CONTROL