brut 0.14.0 → 0.16.0.pre

data/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/lib/mkbrut/version.rb

@@ -1,3 +1,3 @@
 module MKBrut
-  VERSION = "0.14.0"
+  VERSION = "0.16.0.pre"
 end

data/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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"