brut 0.4.0 → 0.8.0

data/mkbrut/templates/Base/bin/setup

@@ -0,0 +1,256 @@
+#!/usr/bin/env ruby
+
+
+require "fileutils"
+require "open3"
+require "optparse"
+require "pathname"
+
+# This is intended to run inside the Workspace (i.e. Docker container) to
+# set up the Foundation, thus enabling development.  This script should:
+#
+# a) Rely only on Ruby and its standard library, since it runs
+#    before any gems are installed
+# b) Be idempotent, with the ability to run in a CI server
+# c) Be organized with the setup method first, as this is the main chunk
+#    of logic, with all other supporting methods following
+#
+# NOTE: It is not clear yet how Brut will manage this file for you, especially
+#       given that you will need to add to it based on your own setup needs.
+#
+#       Take care to only add code and not change what is here.
+
+def setup(update_gems:,update_node:)
+  if update_gems
+    log "Updating gems"
+    system! "bundle update"
+  else
+    log "Installing gems"
+    # Only do bundle install if the much-faster
+    # bundle check indicates we need to
+    system! "bundle check --no-color || bundle install --no-color --quiet"
+  end
+
+  log "Installing puma binstubs"
+  system! "bundle binstub puma"
+
+  log "Installing rspec binstubs"
+  system! "bundle binstub rspec-core"
+
+  # https://github.com/ddollar/foreman/wiki/Don't-Bundle-Foreman
+  log "Installing foreman"
+  system! "gem install foreman"
+
+  # Installs Shopify's LSP. You can remove this if you don't want that,
+  # but this is here to show where to do it vs requiring you to read
+  # documentation.
+  log "Installing Ruby LSP"
+  system! "gem install ruby-lsp"
+
+  if update_node
+    log "Updating Node Modules"
+    system! "npm --no-color --no-progress update"
+  else
+    log "Installing Node Modules"
+    system! "npm --no-color --no-progress install"
+  end
+
+  # In theory, this was installed when the Workspace was setup, but
+  # it doesn't alwaysd work propertly, so this ensures
+  # Chromium is set up.  See comments in Dockerfile.dx as to why
+  # Chromium and not Chrome.
+  log "Re-installing playwright/chromium if needed"
+  system! "node_modules/.bin/playwright install chromium"
+
+  log "Ensuring tmp dir exists"
+  system! "mkdir -p tmp"
+
+  setup_dot_env_local
+
+  log "Setting up databases"
+
+  log "Re-creating development database"
+  system! "bin/db rebuild --env=development"
+
+  log "Re-creating test database"
+  system! "bin/db rebuild --env=test"
+
+  log "Loading seed data into the development database"
+  system! "bin/db seed --env=development"
+
+  log "All set up."
+  help
+end
+
+def setup_dot_env_local() 
+
+  dot_env = ROOT_DIR / ".env.development"
+  if !File.exist?(dot_env)
+    raise "Problem: '#{dot_env}' does not exist"
+  end
+
+  log "Checking #{dot_env} for required local environment variables"
+  previous_comment = ""
+  dot_env_need_local = {}
+  File.read(dot_env).split(/\n/).each do |line|
+    if line =~ /^#(.*)$/
+      previous_comment << line
+    elsif line =~ /^LOCAL:([^=]+)$/
+      dot_env_need_local[$1] = previous_comment
+      previous_comment = ""
+    elsif line =~ /^([^=])+/
+      previous_comment = ""
+    end
+  end
+
+  dot_env_local = ROOT_DIR / ".env.development.local"
+  log "Ensuring '#{dot_env_local}' exists"
+  if !File.exist?(dot_env_local)
+    log "Creating '#{dot_env_local}'"
+    FileUtils.touch dot_env_local
+  end
+
+  log "Checking #{dot_env_local} for values for required local environment variables"
+  local_contents = File.read(dot_env_local).split(/\n/).map { |line|
+    if line =~ /^([^=]+)=(.*)$/
+      var = $1
+      val = $2
+      if dot_env_need_local[var] && val.to_s != ""
+        log "Value for '#{var}' is good"
+        dot_env_need_local.delete(var)
+      end
+    end
+    line
+  }.compact
+
+  dot_env_need_local.each do |var,comment|
+    log "A value is needed locally for '#{var}'"
+    log ""
+    log comment
+    log ""
+    puts "Enter the value below and hit Return"
+    value = gets
+    local_contents << "#{var}=#{value}"
+    log "Got it, thanks"
+  end
+
+  log "Updating '#{dot_env_local}'"
+  File.open(dot_env_local,"w") do |file|
+    local_contents.each do |line|
+      file.puts line
+    end
+  end
+
+  log "Checking that #{dot_env_local} is being ignored"
+  gitignore = ROOT_DIR / ".gitignore"
+  if File.exist?(gitignore)
+    lines = File.read(gitignore).split(/\n/)
+    if lines.include?("/#{dot_env_local.basename}")
+      log "It's there!"
+    else
+      log "It's missing. Adding..."
+      lines << ""
+      lines << "# This contains actual secrets and should not be checked in"
+      lines << "/#{dot_env_local.basename}"
+      File.open(gitignore,"w") do |file|
+        lines.each do |line|
+          file.puts line
+        end
+      end
+    end
+  else
+    log "No #{gitignore}, so make sure you DO NOT CHECK #{dot_env_local} IN!!!"
+  end
+end
+
+# We don't want the setup method to have to do all this error
+# checking, and we also want to explicitly log what we are
+# executing. Thus, we use this method instead of Kernel#system
+def system!(*args)
+  if ENV["BRUT_BIN_KIT_DEBUG"] == "true"
+    log "Executing #{args}"
+    out,err,status = Open3.capture3(*args)
+    if status.success?
+      log "#{args} succeeded"
+    else
+      log "#{args} failed"
+      log "STDOUT:"
+      $stdout.puts out
+      log "STDERR:"
+      $stderr.puts err
+      abort
+    end
+  else
+    log "Executing #{args}"
+    if system(*args)
+      log "#{args} succeeded"
+    else
+      log "#{args} failed"
+      abort
+    end
+  end
+end
+
+# It's helpful to know what messages came from this
+# script, so we'll use log instead of `puts`
+def log(message)
+  puts "[ #{$0} ] #{message}"
+end
+
+ROOT_DIR = ((Pathname(__dir__) / ".." ).expand_path)
+
+def help(option_parser=nil)
+  if option_parser
+    puts option_parser
+    puts
+    puts "OTHER USEFUL COMMANDS"
+  else
+    puts
+    puts "USEFUL COMMANDS"
+  end
+  puts ""
+  puts "  bin/dev"
+  puts "     # run app locally, rebuilding and reloading as needed"
+  puts ""
+  puts "  bin/ci"
+  puts "     # runs all tests and checks as CI would"
+  puts ""
+  puts "  bin/console"
+  puts "     # get an IRB console with the app loaded"
+  puts ""
+  puts "  bin/db"
+  puts "     # interact with the DB for migrations, information, etc"
+  puts ""
+  puts "  bin/dbconsole"
+  puts "     # get a PSQL session to the database"
+  puts ""
+  puts "  bin/scaffold"
+  puts "     # Create various structures in your app, like pages or forms"
+  puts ""
+  puts "  bin/setup help"
+  puts "     # show this help"
+  puts ""
+end
+
+options = {
+  update_gems: false,
+  update_node: false,
+}
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: bin/setup [options]\n\n    Set up the Foundation, allowing for development and testing of the app\n\nOPTIONS\n"
+  opts.on("--update[=TYPE]","Update gems or modules to get the latest versions consistent with Gemfile or package.json. TYPE can be 'all', 'gems', or 'node'. If TYPE is omitted, 'all' is assumed.") do |value|
+    options[:update_gems] = value.nil? || value == "gems"
+    options[:update_node] = value.nil? || value == "node"
+  end
+  opts.on("-h", "--help", "Display this help message") do
+    help(opts)
+    exit
+  end
+end
+option_parser.parse!
+
+if ARGV[0] == "help"
+  help(option_parser)
+else
+  setup(**options)
+end

data/mkbrut/templates/Base/bin/startup-message

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require "yaml"
+require "optparse"
+
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: bin/startup-message\n\n    Outputs a message about where the dev server is running\n\nENVIRONMENT VARIABLES\n\n    PORT - the port configured for bin/run"
+end
+option_parser.parse!
+
+docker_compose_file = Pathname.new(__FILE__).dirname / ".." / "docker-compose.dx.yml"
+
+port_config = nil
+error       = nil
+
+if docker_compose_file.exist?
+  docker_compose = YAML.load_file(docker_compose_file)
+
+  docker_port = begin
+                  ENV.fetch("PORT")
+                rescue KeyError
+                  $stderr.puts "ERROR: The PORT environment variable is not set."
+                  $stderr.puts "       Please set it to the port your app is running on."
+                  exit 1
+                end
+
+  ports_config = docker_compose.dig("services", "app", "ports")
+  error = nil
+  if ports_config
+    port_config = ports_config.detect { |port_mapping|
+      host_port, container_port = port_mapping.split(":")
+      container_port.to_s == docker_port
+    }
+    if !port_config
+      error = "#{docker_compose_file} does not expose the port #{docker_port} for the 'app' service."
+    end
+  else
+    error = "#{docker_compose_file} does not contain a 'ports' section for the 'app' service."
+  end
+else
+  error = "#{docker_compose_file} does not exist. This is assumed to be in placefor your dev environment"
+end
+if !error
+  sleep 2 # allow all other initial output from bin/dev to happen first
+
+  host_port = port_config.split(":")[0]
+
+  url = "http://localhost:#{host_port}"
+
+  $stdout.puts "Your app is now running at"
+  $stdout.puts
+  $stdout.puts "  #{url}"
+  $stdout.puts
+  $stdout.flush # ensure this output happens immediately
+else
+  $stderr.puts "WARN: #{$0} could not figure out what port the app is exposed on"
+  $stderr.puts
+  $stderr.puts "      #{error}"
+  $stderr.puts
+  $stderr.puts "      This won't stop your app from running, but it does mean"
+  $stderr.puts "      there is some issue with your dev environment"
+  $stderr.flush # ensure this error output happens immediately
+end
+sleep

data/mkbrut/templates/Base/bin/test

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "bundler"
+Bundler.require
+require "pathname"
+
+require "brut/cli/apps/test"
+exit Brut::CLI.app(Brut::CLI::Apps::Test,project_root: Pathname($0).dirname / "..")
+

data/mkbrut/templates/Base/bin/test-server

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+set -e 
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
+ROOT_DIR="${SCRIPT_DIR}/.."
+
+usage() {
+  echo "Usage: $0"
+  echo
+  echo "    Run the app in the test environment, suitable for end-to-end tests"
+  echo "    This will build all assets first, but not rebuild or reload after that"
+  echo
+}
+
+for arg in "$@"; do
+  if [ "${arg}" = "-h" ] || [ "${arg}" = "--help" ] || [ "${arg}" = "help" ]; then
+    usage
+    exit 0
+  fi
+done
+
+RACK_ENV="test"
+export RACK_ENV
+echo "[ bin/test-server ] Building assets"
+"${SCRIPT_DIR}"/build-assets
+
+echo "[ bin/test-server ] Starting server"
+PORT=6503 bin/run &
+wait

data/mkbrut/templates/Base/bin/watch-and-build-assets

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+# This script exists to ensure that chokidar actually terminates when foreman stops all the processes.
+# For whatever reason, if Procfile has the npx chokidar… invocation below, these processes are not
+# stopped.  Putting them into this script addresses that. Cool.
+
+set -e
+
+if [ -z "${1}" ] ; then
+  echo "[ $0 ] error: asset type required. Must be css, js, or images"
+  exit 65
+fi
+usage() {
+  echo "usage: $0 asset_type"
+  echo
+  echo "  Sets up a watching/rebuild command for the given asset. Useful in dev only"
+  echo
+  echo "  asset_types:"
+  echo
+  echo "    - css"
+  echo "    - js"
+  echo "    - images"
+  echo
+}
+for arg in "${@}"; do
+  if [ "${arg}" = "-h" ] || [ "${arg}" = "--help" ] || [ "${arg}" = "help" ]; then
+    usage
+    exit 0
+  fi
+done
+
+asset_type=$1
+watch_dir="app/src/front_end/${asset_type}/**/*"
+build_command="bin/build-assets ${asset_type}"
+
+export SHELL # chokidar needs this for reasons unknown to me
+exec npx chokidar --initial --polling --command "${build_command}" "${watch_dir}"

data/mkbrut/templates/Base/config.ru

@@ -0,0 +1,16 @@
+require_relative "app/bootstrap"
+bootstrap = Bootstrap.new.bootstrap!
+
+app = Rack::Builder.app do
+  use Rack::Session::Cookie,
+    key: "rack.session",
+    path: "/",
+    expire_after: 31_536_000,
+    same_site: :lax, # this allows links from other domains to send our cookies to us,
+                     # but only if such links are direct/obvious to the user.
+    secret: ENV.fetch("SESSION_SECRET")
+
+  run bootstrap.rack_app
+end
+run app
+

data/mkbrut/templates/Base/docker-compose.dx.yml

@@ -0,0 +1,92 @@
+# This file is heavily documented to explain what is going on and why.
+# If you are reading this, however, you now own this file and can
+# change it how you like. Just be sure you understand how it works in the
+# context of Dockerfile.dx and the files in dx/,
+# which are referred to as the Workspace
+#
+# This file is used to run several Docker containers, based on images, together
+# in a shared private network.  All containers run by this file will be able to see
+# each other over a network, but the only access your host (computer) will have to
+# these services is via explicitly exposed ports.
+
+services:
+  # 'app' is the service where all your dev tools will run. The tests will
+  # run in here as will the dev server.
+  #
+  # You interact with this container via `dx/exec`
+  app:
+    # IMAGE is defined in dx/docker-compose.env and is the name of an image
+    # built LOCALLY (never pushed to DockerHub) that has all the tools needed
+    # for developing your app installed into it.
+    image: ${IMAGE}
+    # This is magic that makes the Docker container stop much more quickly when
+    # you hit Ctrl-C.
+    init: true
+    # There are two types of volumes (drives) mounted.
+    volumes:
+      # This volume is your source code. Its source and target are the same
+      # so that stuff like language servers can work.
+      - type: bind
+        source: ${PWD}
+        target: ${PWD}
+        consistency: "consistent"
+      # This allows docker build commands run inside Docker, referred to
+      # as "docker out of docker". Essentially, Docker binaries installed into
+      # this container will access your host (you computer)'s Docker install.
+      # This is to allow it to build the production images.
+      - type: bind
+        source: "/var/run/docker.sock"
+        target: "/var/run/docker.sock"
+    # This is what is started up when you run `dx/start`. It just
+    # waits forever keeping the container running.
+    command: /home/appuser/show-help-in-app-container-then-wait.sh
+    # The working directory for any command, this is the same as your
+    # project root.
+    working_dir: ${PWD}
+    # This sets environment variables
+    environment:
+      # Because we'll install RubyGems inside our project (mostly to allow
+      # language servers to work), configuration in bash_customizations relies
+      # on this value being set
+      PROJECT_ROOT: ${PWD}
+    # This exposes ports from this running container to your localhost.
+    # In this case, we expose 6502, where the app runs, and 6503, where
+    # the test server runs.
+    #
+    # To change this, the port before the colon is where the app
+    # will be available on your localhost. The port AFTER the colon is where
+    # the app runs in the container.  So: change the port before the colon, and
+    # don't change the one after.
+    #
+    # * 6502 - dev
+    # * 6503 - test server (run by E2E tests)
+    ports:
+      - "6502:6502"
+      - "6503:6503"
+  # This "service" runs Postgres.  The service name ("postgres") is the host
+  # on which the service is available to other containers, namely from the 
+  # app container. You cannot connect to thise service from your host (computer)
+  # directly without additional configuration.
+  postgres:
+    # This image is the name of the image from DockerHub that will be pulled
+    # down to run Postgres.
+    image: postgres:16.4
+    pull_policy: "missing"
+    environment:
+      # Postgres will not work without being told the password. The most
+      # direct way to do that is via this environment variable.
+      POSTGRES_PASSWORD: postgres
+  # This runes otel-deskop-viewer, which will receive OpenTelemetry traces
+  # from your app. You can connect to this to observe those traces.
+  otel-desktop-viewer:
+    # The otel-desktop-viewer maintainers do not maintain a Docker
+    # image of the app. I have made one available on my DockerHub account.
+    # If you want to build your own, see 
+    # https://github.com/CtrlSpice/otel-desktop-viewer?tab=readme-ov-file#via-docker
+    # When you build that image, change the value for image: below to the image
+    # name you chose.
+    image: davetron5000/otel-desktop-viewer:alpine-3
+    # This runs internally on port 8000 but will be available
+    # on port 6504 of your machine.
+    ports:
+      - "6504:8000"

data/mkbrut/templates/Base/dx/README.md

@@ -0,0 +1,28 @@
+# Workspace Commands
+
+These commands manage the Workspace, AKA the part of the development environment that
+runs on your computer (sometimes called the *host*).
+
+These are all written in Bash as that is the only environment that can be relied upon to exist on any operating system.
+
+These are designed to be somewhat agnostic of your app and Brut may update some of
+these files if changes are needed.  All app-specific configuration is consolidated
+into just a few files.
+
+These files are owned by Brut and you should avoid editing them:
+
+* `bash_customizations` - Bash configuration
+* `build` - Builds the development docker image
+* `dx.sh.lib` - Shared bash functions
+* `exec` -  Run commands inside a container
+* `prune` - Remove unused containers
+* `README.md` - This file
+* `show-help-in-app-container-then-wait.sh` - Runs inside the app container to keep
+the container up
+* `start` - starts the Workspace/dev environment
+* `stop` - stops the Workspace/dev environment
+
+These files contain project-specific information and Brut will not change them:
+
+* `docker-compose.env` - Configuration values.
+* `bash_customizations.local` - Per-developer bash configuration, **project specific**, **developer specific**, **do not check into version control**.

data/mkbrut/templates/Base/dx/bash_customizations

@@ -0,0 +1,12 @@
+# This sets up RubyGems and Bundler so they install
+# all gems inside this project's root and not into the system
+# location.  This allows LSP servers to work more easily.
+if [ ! -n "$PROJECT_ROOT" ]; then
+  echo "[ bash_customizations ] WARNING: PROJECT_ROOT is not set - this will break RubyGems"
+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/mkbrut/templates/Base/dx/bash_customizations.local

@@ -0,0 +1,8 @@
+# Insert developer-specifilc Bash customizations here.
+# This file is not checked into version control, so you
+# are safe to export EDITOR=vim and avoid any guff from 
+# co-workers.
+
+# Sets up a multi-line prompt since the working directory
+# may be very deep.  Customize or change at your leisure.
+PS1='\[\e[35m\]docker-container\[\e[0m\] - \[\e[37m\]\w\n\[\e[0m\]> '

data/mkbrut/templates/Base/dx/build

@@ -0,0 +1,107 @@
+#!/bin/bash
+
+set -e
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
+
+. "${SCRIPT_DIR}/dx.sh.lib"
+
+read_custom_build_args() {
+  build_args_file="${SCRIPT_DIR}/build.args"
+  if [ -e "${build_args_file}" ]; then
+    for arg in `grep -v '^#' "${build_args_file}"`; do
+      BUILD_ARGS+=(--build-arg ${arg})
+    done
+  fi
+}
+
+setup_local_user_build_args() {
+  require_command "id"
+  require_command "uname"
+  user_uid=$(id -u)
+  user_gid=$(id -g)
+  docker_gid=
+  sadly_user_must_be_added_to_root=
+  OS=$(uname)
+  if [ "${OS}" == "Darwin" ] ; then
+    docker_gid=$(stat -f %g /var/run/docker.sock)
+    sadly_user_must_be_added_to_root="0,"
+  else
+    if [ "${OS}" == "Linux" ] ; then
+      docker_gid=$(stat -c %g /var/run/docker.sock)
+    else
+      log "Could not determine OS, which is needed to know how to invoke stat to figure out the group id of /var/run/docker.sock"
+      log "Docker commands will not work"
+    fi
+  fi
+  echo user_uid=${user_uid}                                                 >> "${SCRIPT_DIR}"/build.args
+  echo user_gid=${user_gid}                                                 >> "${SCRIPT_DIR}"/build.args
+  echo docker_gid=${docker_gid}                                             >> "${SCRIPT_DIR}"/build.args
+  echo sadly_user_must_be_added_to_root=${sadly_user_must_be_added_to_root} >> "${SCRIPT_DIR}"/build.args
+}
+
+initialize_build_args() {
+  echo "# This is generated - see build.pre" > "${SCRIPT_DIR}"/build.args
+}
+
+setup_playright_build_args() {
+  require_command "grep"
+  require_command "sed"
+
+  if [ ! -e "${SCRIPT_DIR}"/Gemfile.lock ]; then
+    log "Could not find Gemfile.lock, which is needed to determine the playwright-ruby-client version"
+    log "Assuming your app is brand-new, this should be OK"
+    echo "# When this file was created, there was no Gemfile.lock, so"               >> "${SCRIPT_DIR}"/build.args
+    echo "# it was not possible to determine which version of Playright was set up." >> "${SCRIPT_DIR}"/build.args
+    echo "# Once you've build your app and installed gems, you are "                 >> "${SCRIPT_DIR}"/build.args
+    echo "# encouraged to re-run \`dx/build\` to address this issue."                >> "${SCRIPT_DIR}"/build.args
+    echo PLAYWRIGHT_VERSION=latest                                                   >> "${SCRIPT_DIR}"/build.args
+  else
+    PLAYWRIGHT_VERSION=$(grep playwright-ruby-client Gemfile.lock  | grep '(' | sed 's/^.*(//' | sed 's/).*$//' | grep -v ^=)
+    if [ -z "${PLAYWRIGHT_VERSION}" ]; then
+      log "Could not find precise version of playwright-ruby-client from Gemfile.lock"
+      log "This means that your playwright-ruby-client version and playwright NPM modules may be out of sync and may not work"
+      echo "# When this file was created, Gemfile.lock did not"                    >> "${SCRIPT_DIR}"/build.args
+      echo "# contain playwrith-ruby-client.  This means it"                       >> "${SCRIPT_DIR}"/build.args
+      echo "# it was not possible to determine which version of"                   >> "${SCRIPT_DIR}"/build.args
+      echo "# Playright was set up. If you aren't using Playwright,"               >> "${SCRIPT_DIR}"/build.args
+      echo "# that's fine, this won't cause issues"                                >> "${SCRIPT_DIR}"/build.args
+      echo "# If you ARE using Playwright, something may be wrong with your setup" >> "${SCRIPT_DIR}"/build.args
+      echo PLAYWRIGHT_VERSION=latest                                               >> "${SCRIPT_DIR}"/build.args
+    else
+      echo PLAYWRIGHT_VERSION=${PLAYWRIGHT_VERSION} >> "${SCRIPT_DIR}"/build.args
+    fi
+  fi
+}
+
+require_command "docker"
+load_docker_compose_env
+
+usage_on_help "Builds the Docker image based on the Dockerfile" "" "build.pre" "build.post" "${@}"
+
+if ! exec_hook_if_exists "build.pre" Dockerfile.dx "${IMAGE}"; then
+  log "build.pre failed"
+  exit 1
+fi
+BUILD_ARGS=()
+
+initialize_build_args
+setup_local_user_build_args
+setup_playright_build_args
+read_custom_build_args
+
+docker build \
+  --file Dockerfile.dx \
+  --tag "${IMAGE}" \
+  ${BUILD_ARGS[@]} \
+  ./
+
+if ! exec_hook_if_exists "build.post" Dockerfile.dx "${IMAGE}"; then
+  log "build.pre failed"
+  exit 1
+fi
+
+log "🌈" "Your Docker image has been built tagged '${IMAGE}'"
+log "🔄" "You can now run dx/start to start it up, though you may need to stop it first with Ctrl-C"
+
+# vim: ft=bash