brut 0.4.0 → 0.8.0

data/mkbrut/bin/build

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "pathname"
+require "fileutils"
+require_relative "../../bin/bin_kit"
+
+def main
+
+  log "Building mkbrut gem"
+  system!("bin/rake build")
+
+end
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: build [options]\n\n    Builds deployable artifacts\n\nOPTIONS"
+
+  opts.on("-h", "--help", "Display this help message") do
+    puts opts
+    exit
+  end
+end.parse!
+
+def require_clean_repo!
+  out, err = capture!("git status --porcelain")
+  if out.to_s.strip != ""
+    log out
+    log err
+    log "Your git repository is not clean. Please commit or stash your changes before running this script."
+    exit 1
+  end
+end
+
+require_clean_repo!
+main
+

data/mkbrut/bin/ci

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+set -e
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
+ROOT_DIR=$(realpath "$SCRIPT_DIR/..")
+
+usage() {
+  echo "Usage: $0"
+  echo
+  echo "    No-op to comply with workspace protocol"
+  echo
+}
+
+for arg in "$@"; do
+  if [ "${arg}" = "-h" ] || [ "${arg}" = "--help" ] || [ "${arg}" = "help" ]; then
+    usage
+    exit 0
+  fi
+done

data/mkbrut/bin/docs

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+set -e
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
+ROOT_DIR=$(realpath "$SCRIPT_DIR/..")
+
+usage() {
+  echo "Usage: $0"
+  echo
+  echo "    No-op to comply with workspace protocol"
+  echo
+}
+
+for arg in "$@"; do
+  if [ "${arg}" = "-h" ] || [ "${arg}" = "--help" ] || [ "${arg}" = "help" ]; then
+    usage
+    exit 0
+  fi
+done

data/mkbrut/bin/publish

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+
+set -e
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
+ROOT_DIR=$(realpath "$SCRIPT_DIR/..")
+
+main() {
+  detect_gem_version
+  detect_docker_platform
+  release_gem
+  build_and_maybe_push
+}
+
+log() {
+  echo "[ mkbrut/bin/publish ] ${*}"
+}
+
+usage() {
+  echo "Usage: $0"
+  echo
+  echo "    Publish Ruby Gem and Docker image"
+  echo
+}
+
+release_gem() {
+  log "Releasing Gem"
+  rake release
+  wait_for_rubygems
+}
+
+wait_for_rubygems() {
+  timeout=30
+  interval=2
+  elapsed=0
+
+  log "Waiting ${timeout} seconds for mkbrut $GEM_VERSION to be available on RubyGems"
+  while (( elapsed < timeout )); do
+    if gem list -r "mkbrut" -a | grep -q "$GEM_VERSION"; then
+      log "mkbrut $GEM_VERSION is available on RubyGems"
+      return 0
+    fi
+    sleep $interval
+    (( elapsed += interval ))
+  done
+
+  log "mkbrut $GEM_VERSION is not available on RubyGems after $timeout seconds"
+  log "Something may have gone wrong. Or, it could just be taking a while"
+  log "You can re-run this with -G to bypassing pushing to RubyGems"
+  echo 
+  log "    bin/deploy -G"
+  exit 1
+}
+
+setup_docker_buildx() {
+  local builder_name=mkbrut-builder
+
+  if ! docker buildx ls | grep -q "^$builder_name"; then
+    log "Creating Docker buildx builder: $builder_name"
+    docker buildx create --name "$builder_name" --use
+    docker buildx inspect "$builder_name" --bootstrap
+  else
+    log "Docker buildx builder $builder_name already exists"
+    docker buildx use "$builder_name"
+  fi
+}
+
+detect_gem_version() {
+
+  GEM_VERSION=$( rake -T | grep "rake install " | sed 's/^.*mkbrut-//g' | sed 's/\.gem.*$//g')
+  if [[ "$GEM_VERSION" =~ ^[0-9]+\.[0-9]\.[0-9]+$ ]]; then
+    log "Releasing version ${GEM_VERSION}"
+  else
+    log "Version '${GEM_VERSION}' does not look like a version: X.Y.Z"
+    exit 1
+  fi
+}
+
+detect_docker_platform() {
+
+  KERNEL_NAME_FOR_ARCHITECTURE=$(docker info --format '{{.Architecture}}')
+  OSTYPE=$(docker info --format '{{.OSType}}')
+
+  case "$KERNEL_NAME_FOR_ARCHITECTURE" in
+    "aarch64")
+      DOCKER_NAME_FOR_ARCHITECTURE="arm64"
+      ;;
+    "x86_64")
+      DOCKER_NAME_FOR_ARCHITECTURE="amd64"
+      ;;
+    *)
+      log "Docker reported architecture is $KERNEL_NAME_FOR_ARCHITECTURE - hoping this works"
+      ;;
+  esac
+  HOST_PLATFORM=${OSTYPE}/${DOCKER_NAME_FOR_ARCHITECTURE}
+}
+
+build_and_maybe_push() {
+
+  # See bin/setup for another use of this page
+  local docker_credentials_source="${SCRIPT_DIR}/../dx/credentials/dockerhub.credentials"
+  setup_docker_buildx
+
+  . "${docker_credentials_source}"
+  log "Loging into DockerHub with credentials from ${docker_credentials_source}"
+  docker login --username "${DOCKERHUB_USERNAME}" --password "${DOCKERHUB_PAT}"
+
+  DOCKER_BUILD_PUSH_OR_LOAD=--push
+  DOCKER_PLATFORMS="linux/amd64,linux/arm64"
+
+  log "Building Docker image and pushing to DockerHub"
+
+  docker buildx build \
+    --platform ${DOCKER_PLATFORMS} \
+    ${DOCKER_BUILD_PUSH_OR_LOAD} \
+    --no-cache \
+    --build-arg brut_version="${GEM_VERSION}" \
+    --tag thirdtank/mkbrut:"${GEM_VERSION}" \
+    --tag thirdtank/mkbrut:latest \
+    deploy
+}
+
+for arg in "${@}"; do
+  if [ "${arg}" = "-h" ] || [ "${arg}" = "--help" ] || [ "${arg}" = "help" ]; then
+    usage
+    exit 0
+  fi
+done
+
+main

data/mkbrut/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/mkbrut/bin/setup

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require_relative "../../bin/bin_kit"
+require "optparse"
+require "pathname"
+require "fileutils"
+
+def setup(update_gems:)
+  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
+end
+
+
+options = {
+  update_gems: false,
+}
+OptionParser.new do |opts|
+  opts.on("--update-gems","Update gems get the latest versions consistent with Gemfile / gemspec.") do
+    options[:update_gems] = true
+  end
+end.parse!
+
+setup(**options)

data/mkbrut/deploy/.dockerignore

@@ -0,0 +1,2 @@
+# Nothing in this repo needs to be put into the Docker image
+*

data/mkbrut/deploy/Dockerfile

@@ -0,0 +1,25 @@
+FROM ruby:3.4
+
+SHELL [ "/bin/bash", "-o", "pipefail", "-c" ]
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get -y update
+
+# Update RubyGems and Bundler
+RUN echo "gem: --no-document" >> ~/.gemrc && \
+    gem update --system
+
+ARG brut_version
+RUN gem install --version ${brut_version} mkbrut
+
+ARG user_uid=10001
+ARG user_gid=10002
+
+# Create the user's group ID if it does not exist
+RUN getent group ${user_gid} || groupadd --gid ${user_gid} appgroup
+RUN useradd --uid ${user_uid} --gid ${user_gid} --create-home --home-dir /home/appuser appuser
+
+# NOT including the group here as that will place the user's environment
+# ONLY in that group and not in all the groups in which they are a part.
+USER appuser
+

data/mkbrut/exe/mkbrut

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "mkbrut"
+
+exit MKBrut::CLI.new(args: ARGV).run

data/mkbrut/lib/mkbrut/app.rb

@@ -0,0 +1,79 @@
+require "fileutils"
+require "erb"
+require "ostruct"
+
+module MKBrut
+  class App
+    def initialize(current_dir:, app_options:, out:, err:)
+      @out = out
+      @app_options = app_options
+
+      @out.puts "Creating app with these options:\n"
+      @out.puts "App name:      #{app_options.app_name}"
+      @out.puts "App ID:        #{app_options.app_id}"
+      @out.puts "Prefix:        #{app_options.prefix}"
+      @out.puts "Organization:  #{app_options.organization}"
+      @out.puts "Include demo?  #{app_options.demo}\n"
+
+      if app_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"
+
+      @base = MKBrut::Base.new(
+        app_options:,
+        current_dir:,
+        templates_dir:
+      )
+      @segments = [
+        MKBrut::Segments::BareBones.new(
+          app_options:,
+          current_dir:,
+          templates_dir:,
+        )
+      ]
+      if app_options.demo?
+        @segments << MKBrut::Segments::Demo.new(
+          app_options:,
+          current_dir:,
+          templates_dir:
+        )
+      end
+      app_options.segments.each do |segment|
+        case segment
+        when "heroku"
+          @segments << MKBrut::Segments::Heroku.new(
+            app_options:,
+            current_dir:,
+            templates_dir:
+          )
+        else
+          raise "Segment #{segment} is not supported"
+        end
+      end
+    end
+
+    def create!
+      @out.puts "Creating Base app"
+      @base.create!
+      @segments.each do |segment|
+        @out.puts "Creating segment: #{segment.class.friendly_name}"
+        segment.add!
+      end
+      @out.puts "#{@app_options.app_name} was created\n\n"
+      @out.puts "Time to get building:"
+      @out.puts "1. cd #{@app_options.app_name}"
+      @out.puts "2. dx/build"
+      @out.puts "3. dx/start"
+      @out.puts "4. [ in another terminal ] dx/exec bash"
+      @out.puts "5. [ inside the Docker container ] bin/setup"
+      @out.puts "6. [ inside the Docker container ] bin/dev"
+      @out.puts "7. Visit http://localhost:6502 in your browser"
+      @out.puts "8. [ inside the Docker container ] bin/setup help # to see more commands"
+    end
+  end
+end

data/mkbrut/lib/mkbrut/app_id.rb

@@ -0,0 +1,8 @@
+class MKBrut::AppId < MKBrut::InternetIdentifier
+  def self.from_app_name(app_name)
+    self.new(app_name.to_s.gsub(/[^a-zA-Z0-9\-]/, "-").downcase)
+  end
+  def initialize(value)
+    super(:app_id, value)
+  end
+end

data/mkbrut/lib/mkbrut/app_name.rb

@@ -0,0 +1,29 @@
+module MKBrut
+  class AppName
+    def initialize(value)
+      identifier = value.to_s
+      if identifier.empty?
+        raise MKBrut::InvalidIdentifier, "app-name is required"
+      end
+
+      if identifier.length > 63
+        raise MKBrut::InvalidIdentifier, "app-name cannot be longer than 63 characters"
+      end
+
+      if identifier.start_with?("-") || identifier.end_with?("-")
+        raise MKBrut::InvalidIdentifier, "app-name cannot start or end with a hyphen"
+      end
+
+      if identifier.match?(/[^a-zA-Z\-_]/)
+        raise MKBrut::InvalidIdentifier, "app-name can only contain letters, hyphens, and underscores"
+      end
+      if identifier.match?(/__/) || identifier.match?(/--/)
+        raise MKBrut::InvalidIdentifier, "app-name can not have repeating underscores or hyphens"
+      end
+      @identifier = identifier.to_s.gsub(/_/,"-")
+    end
+
+    def to_s = @identifier
+    alias to_str to_s
+  end
+end

data/mkbrut/lib/mkbrut/app_options.rb

@@ -0,0 +1,36 @@
+class MKBrut::AppOptions
+  attr_reader :app_name, :app_id, :prefix, :organization, :demo, :versions, :segments
+
+  def initialize(
+    app_name:,
+    app_id: nil,
+    prefix: nil,
+    dry_run: nil,
+    organization: nil,
+    demo: false,
+    versions: nil,
+    **rest
+  )
+    if app_name.nil?
+      raise ArgumentError, "app_name is required"
+    end
+
+    @app_name     =   app_name
+    @app_id       =   app_id       || MKBrut::AppId.from_app_name(@app_name)
+    @prefix       =   prefix       || MKBrut::Prefix.from_app_id(@app_id)
+    @organization =   organization || @app_id
+    @dry_run      = !!dry_run
+    @demo         = !!demo
+    @versions     =   versions
+    @segments     = rest.map { |key,value|
+      if key =~ /^segment-(.+)$/ && value
+        $1
+      else
+        nil
+      end
+    }.compact
+  end
+
+  def dry_run? = @dry_run
+  def demo?    = @demo
+end

data/mkbrut/lib/mkbrut/base.rb

@@ -0,0 +1,57 @@
+require "pathname"
+require "securerandom"
+# Constructs the base of any Brut app.
+class MKBrut::Base
+  include MKBrut
+
+  class ErbBinding < MKBrut::ErbBindingDelegate
+    def session_secret = SecureRandom.hex(64)
+  end
+
+  def initialize(app_options:, current_dir:, templates_dir:)
+    @project_root  = current_dir / app_options.app_name
+    @templates_dir = templates_dir / "Base"
+    @erb_binding   = ErbBinding.new(app_options)
+  end
+
+  def create!
+    if @project_root.exist?
+      raise "Project root #{@project_root} already exists"
+    end
+    operations = [ Ops::Mkdir.new(@project_root) ]           + 
+                   copy_files(@templates_dir, @project_root)
+
+    operations.each do |operation|
+      operation.call
+    end
+  end
+
+private
+
+  def filenames_to_always_skip = [ "README.md", "mkicons.sh" ]
+
+  def copy_files(source_dir, destination_root)
+    operations = []
+    Dir.glob("#{source_dir}/*", flags: File::FNM_DOTMATCH).each do |template_file|
+      template_file = Pathname(template_file)
+      if [ ".", ".." ].include?(template_file.basename.to_s)
+        next
+      end
+      if template_file.directory?
+        operations << Ops::Mkdir.new(destination_root / template_file.basename)
+        operations += copy_files(template_file, destination_root / template_file.basename)
+      elsif template_file.extname == ".erb"
+        operations << Ops::RenderTemplate.new(
+          template_file,
+          destination_root:,
+          erb_binding: @erb_binding
+        )
+      elsif filenames_to_always_skip.include?(template_file.basename.to_s)
+        operations << Ops::SkipFile.new(template_file)
+      else
+        operations << Ops::CopyFile.new(template_file, destination_root:)
+      end
+    end
+    operations
+  end
+end

data/mkbrut/lib/mkbrut/cli.rb

@@ -0,0 +1,107 @@
+require "optparse"
+require "pathname"
+
+module MKBrut
+  class CLI
+    def initialize(args:, out: $stdout, err: $stderr)
+      @args    = args
+      @out     = out
+      @err     = err
+    end
+
+    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!
+      0
+    rescue => e
+      @err.puts "Error: #{e.message}"
+      if ENV["BRUT_CLI_RAISE_ON_ERROR"] == "true"
+        raise
+      end
+      1
+    end
+
+    def show_help(versions)
+      @out.puts @option_parser
+      @out.puts
+      @out.puts "ARGUMENTS"
+      @out.puts
+      @out.puts "    app-name - name for your app, which will be the folder where your app's files are created"
+      @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
+    end
+
+  private
+
+
+    def parse_options(args, versions)
+      options = {}
+      @option_parser = OptionParser.new do |opts|
+        opts.accept(MKBrut::Prefix) do |prefix|
+          MKBrut::Prefix.new(prefix)
+        end
+        opts.accept(MKBrut::AppId) do |prefix|
+          MKBrut::AppId.new(prefix)
+        end
+        opts.accept(MKBrut::Organization) do |prefix|
+          MKBrut::Organization.new(prefix)
+        end
+        opts.banner = [
+          "Usage: mkbrut [options] app-name",
+          "",
+          "    Creates a new Brut-powered app",
+          "",
+          "VERSION",
+          "",
+          "    #{MKBrut::VERSION}",
+          "",
+          "OPTIONS",
+          "",
+        ].join("\n")
+
+        opts.on("-a", "--app-id=ID", MKBrut::AppId,
+                "App identifier, which must be able to be used as a hostname or other Internet identifier. Derived from your app name, if omitted")
+
+        opts.on("-o", "--organization=ORG",MKBrut::Organization,
+                "Organization name, e.g. what you'd use for GitHub. Defaults to the app-id value")
+
+        opts.on("-e", "--prefix=PREFIX", MKBrut::Prefix,
+                "Two-character prefix for external IDs and autonomous custom elements. Derived from your app-id, if omitted.")
+
+        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")
+        {
+          "sidekiq" => "Use Sidekiq for background jobs",
+          "heroku" => "Use Heroku for container-based deployment",
+        }.each do |segment,description|
+          opts.on("--segment-#{segment}", description)
+        end
+        opts.on("-h", "--help", "Show this help message") do
+          show_help(versions)
+          exit
+        end
+      end
+
+      @option_parser.parse!(args, into: options)
+      if !options.key?(:demo)
+        options[:demo] = true
+      end
+
+      options[:app_name] = MKBrut::AppName.new(args.first)
+      options[:app_id] = options[:'app-id']
+      options[:dry_run] = !!options[:'dry-run']
+      MKBrut::AppOptions.new(**options.merge(versions:))
+    end
+
+  end
+end 

data/mkbrut/lib/mkbrut/erb_binding_delegate.rb

@@ -0,0 +1,20 @@
+# This exists because ERB can't working with a SimpleDelegator or
+# Delegate.
+class MKBrut::ErbBindingDelegate
+  def initialize(app_options)
+    @app_options = app_options
+  end
+
+  # Not using Delegate because it won't work with ERB binding
+  def method_missing(syn,*args,&block)
+    if args.empty? && @app_options.respond_to?(syn)
+      @app_options.send(syn)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(syn,include_all)
+    @app_options.respond_to?(syn)
+  end
+end

data/mkbrut/lib/mkbrut/internet_identifier.rb

@@ -0,0 +1,32 @@
+module MKBrut
+  class InternetIdentifier
+    def initialize(name, value)
+      @name = name
+      @identifier = value.to_s
+      validate_identifier
+    end
+
+    def to_s = @identifier
+    alias to_str to_s
+
+  private
+
+    def validate_identifier
+      if @identifier.empty?
+        raise MKBrut::InvalidIdentifier, "#{@name} cannot be empty"
+      end
+
+      if @identifier.length > 63
+        raise MKBrut::InvalidIdentifier, "#{@name} cannot be longer than 63 characters"
+      end
+
+      if @identifier.start_with?("-") || @identifier.end_with?("-")
+        raise MKBrut::InvalidIdentifier, "#{@name} cannot start or end with a hyphen"
+      end
+
+      if @identifier.match?(/[^a-zA-Z0-9-]/)
+        raise MKBrut::InvalidIdentifier, "#{@name} can only contain letters, numbers, and hyphens"
+      end
+    end
+  end 
+end

data/mkbrut/lib/mkbrut/invalid_identifier.rb

@@ -0,0 +1,4 @@
+module MKBrut
+  class InvalidIdentifier < ArgumentError
+  end
+end