Add scripts to help with project maintenance

Author: eoinkelly

bin/build

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require "fileutils"
+require "yaml"
+require_relative "./lib/config"
+require_relative "./lib/builder"
+
+# Usage:
+#
+#   $ ./build "all_variants" | "vanilla" | "default" | <ci_config_name>
+#
+# where <ci_config_name> is the name of a file in the `ci/configs` directory
+# (minus the .yml extension)
+#
+# Examples:
+#
+#   $ ./build all_variants  # build every known variant
+#   $ ./build vanilla       # build a vanilla Rails app (which doesn't use our template)
+#   $ ./build default       # build using the default config
+#   $ ./build basic         # build using the basic CI config
+#   $ ./build react         # build using the React CI config
+
+class Main
+  class << self
+    def main
+      configs = Config.resolve_to_configs(ARGV.first)
+
+      puts configs_summary(configs)
+
+      configs.each do |config|
+        Builder.new(config:).build
+      end
+    end
+
+    private
+
+    def configs_summary(configs)
+      <<~EO_HEAD
+        Building apps for #{configs.length} configs:
+          - #{configs.map(&:name).join("\n  - ")}
+
+      EO_HEAD
+    end
+  end
+end
+
+Main.main

bin/compare

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require "fileutils"
+require "pry"
+
+PROJECT_ROOT_PATH = File.absolute_path(File.join(__dir__, "."))
+BUILD_PATH = File.join(PROJECT_ROOT_PATH, "tmp/builds")
+COMPARISONS_REPO_ROOT_PATH = File.join(PROJECT_ROOT_PATH, "tmp/rails-template-variants-comparison")
+ALL_BUILDS = Dir.children(BUILD_PATH)
+
+VANILLA_BUILD_NAME = ALL_BUILDS.find { |build_name| build_name.start_with?("vanilla_") }
+VANILLA_BUILD_PATH = File.join(BUILD_PATH, VANILLA_BUILD_NAME)
+COMPARISON_BUILDS = ALL_BUILDS - [VANILLA_BUILD_NAME]
+
+def copy_build(build_name:, branch_name:, build_path:)
+  system("git checkout -b #{branch_name}")
+
+  # the `.` at the end of the cp command is what copies the contents of the dir
+  # including "hidden" `.` files (the same trick works with shell `cp` command)
+  # FileUtils.cp_r("#{build_path}/.", COMPARISONS_REPO_ROOT_PATH)
+  system("rsync -av --exclude='.git' --exclude='node_modules' --exclude='tmp' #{build_path}/ #{COMPARISONS_REPO_ROOT_PATH}/")
+
+  system("git add .")
+  system("git commit -n -m 'Add #{build_name}'")
+end
+
+def main
+  FileUtils.rm_rf(COMPARISONS_REPO_ROOT_PATH)
+  FileUtils.mkdir_p(COMPARISONS_REPO_ROOT_PATH)
+
+  Dir.chdir(COMPARISONS_REPO_ROOT_PATH) do
+    system("git init")
+    system("git remote add origin [email protected]:ackama/rails-template-variants-comparison.git")
+
+    copy_build(
+      build_name: VANILLA_BUILD_NAME,
+      branch_name: "main",
+      build_path: VANILLA_BUILD_PATH
+    )
+
+    COMPARISON_BUILDS.each do |build_name|
+      build_path = File.join(BUILD_PATH, build_name)
+      keepers = [".git", "."]
+      deletable_files = Dir.glob("{*,.*}").reject { |f| keepers.include?(f) }
+
+      # clean out all the files from the previous build (except .git)
+      FileUtils.rm_rf(deletable_files)
+
+      copy_build(
+        build_name:,
+        branch_name: build_name,
+        build_path:
+      )
+
+      # go back to main before we start the next build
+      system("git checkout main")
+    end
+  end
+end
+
+main

bin/create_prs

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+PROJECT_ROOT_PATH = File.absolute_path(File.join(__dir__, "."))
+BUILD_PATH = File.join(PROJECT_ROOT_PATH, "tmp/builds")
+COMPARISONS_REPO_ROOT_PATH = File.join(PROJECT_ROOT_PATH, "tmp/rails-template-variants-comparison")
+ALL_BUILDS = Dir.children(BUILD_PATH)
+VANILLA_BUILD_NAME = ALL_BUILDS.find { |build_name| build_name.start_with?("vanilla_") }
+COMPARISON_BUILDS = ALL_BUILDS - [VANILLA_BUILD_NAME]
+
+def main
+  Dir.chdir(COMPARISONS_REPO_ROOT_PATH) do
+    COMPARISON_BUILDS.each do |build_name|
+      puts build_name
+      # add --dry-run to test
+      system("gh pr create --title 'Compare #{build_name} against vanilla Rails' --body 'Compare #{build_name} against vanilla Rails' --base main --head #{build_name}")
+    end
+  end
+end
+
+main

bin/lib/builder.rb

@@ -0,0 +1,100 @@
+##
+# Invokes the template as a user would, not as CI does via the build-and-test script.
+# Automatically removes old DB before generating the app if required
+#
+class Builder
+  def initialize(config:)
+    @config = config
+  end
+
+  def build
+    verify_rails_cmd_is_expected_version!
+
+    Dir.chdir(@config.build_path) do
+      delete_any_previous_build
+      drop_dbs_from_previous_build
+
+      # TODO: how to handle errors? raise? or log and continue? or rename the app dir with a .failed suffix?
+      # TODO: how to handle output? redirect to a file? or sep files for stdout and stderr?
+
+      if @config.vanilla?
+        system(build_vanilla_cmd_env, build_vanilla_cmd)
+      else
+        system(build_cmd_env, build_cmd)
+      end
+    end
+  end
+
+  private
+
+  def base_cmd_parts
+    [
+      "rails new #{@config.app_name}",
+      "-d postgresql",
+      "--skip-javascript",
+      "--skip-kamal",
+      "--skip-solid"
+    ]
+  end
+
+  def verify_rails_cmd_is_expected_version!
+    actual_rails_version = `rails -v`.strip.sub("Rails ", "")
+
+    return if actual_rails_version.start_with?(@config.target_rails_major_minor)
+
+    raise "Expected Rails version #{@config.target_rails_major_minor}, but got #{actual_rails_version}"
+  end
+
+  def delete_any_previous_build
+    FileUtils.rm_rf(@config.app_path)
+  end
+
+  def build_cmd
+    cmd_parts = base_cmd_parts.append("-m #{@config.template_path}")
+
+    puts <<~EO_INFO
+      Building command:: #{cmd_parts.inspect}
+    EO_INFO
+
+    cmd_parts.join(" ")
+  end
+
+  def build_cmd_env
+    cmd_env = {
+      "TARGET_VERSIONS_PATH" => @config.target_versions_path,
+      "CONFIG_PATH" => @config.config_path
+    }
+
+    puts <<~EO_INFO
+      Building ENV: #{cmd_env.inspect}
+    EO_INFO
+
+    cmd_env
+  end
+
+  def build_vanilla_cmd_env
+    {}
+  end
+
+  def build_vanilla_cmd
+    puts <<~EO_INFO
+      Building command: #{base_cmd_parts.inspect}
+    EO_INFO
+
+    base_cmd_parts.join(" ")
+  end
+
+  def print_separator
+    puts ""
+    puts "*" * 80
+    puts ""
+  end
+
+  def drop_dbs_from_previous_build
+    print_separator
+    system "psql -c 'DROP DATABASE IF EXISTS #{@config.app_name}_test;'"
+    system "psql -c 'DROP DATABASE IF EXISTS #{@config.app_name}_development;'"
+    system "psql -c 'DROP DATABASE IF EXISTS #{@config.app_name}_test;'"
+    print_separator
+  end
+end

bin/lib/config.rb

@@ -0,0 +1,96 @@
+class Config
+  PROJECT_ROOT_PATH = File.absolute_path(File.join(__dir__, "../.."))
+  CI_CONFIGS_PATH = File.join(PROJECT_ROOT_PATH, "ci/configs")
+  BUILD_PATH = File.join(PROJECT_ROOT_PATH, "tmp/builds")
+  TEMPLATE_PATH = File.join(PROJECT_ROOT_PATH, "template.rb")
+  TARGET_VERSIONS_PATH = File.join(PROJECT_ROOT_PATH, "target_versions.yml")
+  DEFAULT_CONFIG_NAME = "readme_example".freeze
+  VANILLA_CONFIG_NAME = "vanilla".freeze
+  APP_NAME_SUFFIX = "template_app".freeze
+  CI_CONFIGS = Dir.children(CI_CONFIGS_PATH).map { |f| f.sub(".yml", "") }
+  AVAILABLE_CONFIG_NAMES = [
+    VANILLA_CONFIG_NAME,
+    DEFAULT_CONFIG_NAME,
+    *CI_CONFIGS
+  ].freeze
+  TARGET_RAILS_MAJOR_MINOR = YAML.safe_load_file(TARGET_VERSIONS_PATH).fetch("target_rails_major_minor")
+
+  def self.all_configs
+    AVAILABLE_CONFIG_NAMES.map { |name| new(name:) }
+  end
+
+  ##
+  # Resolves the CLI parameter to a list of Config instances
+  #
+  def self.resolve_to_configs(cli_param)
+    return all_configs if cli_param == "all_variants"
+    return [new(name: cli_param)] if AVAILABLE_CONFIG_NAMES.include?(cli_param)
+
+    [new(name: DEFAULT_CONFIG_NAME)]
+  end
+
+  attr_reader :name, :app_name, :config_path
+
+  def initialize(name:)
+    @name = name
+    @app_name = case name
+                when VANILLA_CONFIG_NAME
+                  "#{name}_#{target_rails_major}_#{APP_NAME_SUFFIX}"
+                else
+                  "#{name}_#{APP_NAME_SUFFIX}"
+                end
+
+    @config_path = case name
+                   when DEFAULT_CONFIG_NAME
+                     File.join(PROJECT_ROOT_PATH, "ackama_rails_template.config.yml")
+                   when VANILLA_CONFIG_NAME
+                     nil
+                   else
+                     File.join(CI_CONFIGS_PATH, "#{name}.yml")
+                   end
+  end
+
+  def vanilla?
+    name == VANILLA_CONFIG_NAME
+  end
+
+  def app_path
+    File.join(BUILD_PATH, app_name)
+  end
+
+  def target_versions_path
+    TARGET_VERSIONS_PATH
+  end
+
+  def build_path
+    BUILD_PATH
+  end
+
+  def template_path
+    return nil if vanilla?
+
+    TEMPLATE_PATH
+  end
+
+  def inspect
+    <<~INSPECT
+      <Config:
+        @name: #{name}
+        @app_name: #{app_name}
+        @config_path: #{config_path}
+        @app_path: #{app_path}
+        @target_versions_path: #{target_versions_path}
+        @build_path: #{build_path}
+        @template_path: #{template_path}
+      >
+    INSPECT
+  end
+
+  def target_rails_major_minor
+    TARGET_RAILS_MAJOR_MINOR
+  end
+
+  def target_rails_major
+    TARGET_RAILS_MAJOR_MINOR.split(".").first
+  end
+end