dockerfile-rails 1.0.17 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05b8a577ac00405dd179ea5b1cde996561ea653975160a946c204191a0fa0a26
-  data.tar.gz: 2ea30cf471f625e997fca7185bcbc89d59731516cd6165d8553a3c8a59ddcfa5
+  metadata.gz: d20c08de9e4419da64806a66f96edfeb7180e09eca15d1c8bd4a52cbf8372be9
+  data.tar.gz: e6f11bdbc4a56eb235de642a156124e9a84e179bef99a2e16842c419278b8d84
 SHA512:
-  metadata.gz: 1f6ea1a1dc18afd820a0af903385837688f22cac8b11e625e706b6fa2342b850e03f6a0d05606b7ea1c565560993eead3fd31259b1ca34c611b8c0178acdb38a
-  data.tar.gz: 9b9c27e9c40f6b6edac3aa732d0fae0b2b10a68127b229ade66c980e333ba0601e6f85de78f729efa8acf947f797ef0abf8923990f757c57bcf20c58867074be
+  metadata.gz: 9d170c27b085983ea7f58b9ecf0c02ea229d3e43494483f9c4165fe4acad1dedd6b66e4edfaddac73ea08b2157e21a6129f33079e51b98a43c9b00eea5eb5776
+  data.tar.gz: 872b30f56d771d92ec2acac229ff42e8dea97f9971961d17c11dc517b9b7905d31127e395d2e450bdbe87700cdc70bce4a58ded23740a50d08dd747382c02905

data/DEMO.md

@@ -5,24 +5,58 @@ If you have Rails and Docker installed on your machine, running each of these de
 Rails provides a _smoke test_ for new applications that makes sure that you have your software configured correctly enough to serve a page.  The following deploys that smoke test in production.  Once done take a look at the `Dockerfile` file produced.
 
 ```bash
-rails new welcome --minimal
-cd welcome
+rails new demo --minimal
+cd demo
 echo 'Rails.application.routes.draw { root "rails/welcome#index" }' > config/routes.rb
-bundle add dockerfile-rails --group development
+bundle add dockerfile-rails --optimistic --group development
 bin/rails generate dockerfile
-docker buildx build . -t rails-welcome
-docker run -p 3000:3000 -e RAILS_MASTER_KEY=$(cat config/master.key) rails-welcome
+docker buildx build . -t rails-demo
+docker run -p 3000:3000 -e RAILS_MASTER_KEY=$(cat config/master.key) rails-demo
+```
+
+# Demo 2 - Neofetch
+
+Similar in spirit to the previous demo, but installs and runs Linux commands to show container status.
+
+```bash
+rails new demo --minimal
+cd demo
+echo 'Rails.application.routes.draw { root "neofetch#get" }' > config/routes.rb
+
+cat << 'EOF' > app/controllers/neofetch_controller.rb
+require 'open3'
+
+class NeofetchController < ApplicationController
+  def get
+    Open3.pipeline_r('neofetch', 'ansi2html') do |out, threads|
+      # adjust to a two column layout
+      html = out.read
+        .sub(/body \{/, "\\0display: grid; justify-items: center; " +
+          "font-size: 2vw; grid-template-columns: auto auto; ")
+        .sub(/<\/b>\n\s*/, "</b></pre>\n<pre>")
+        .gsub(/^\s+(<|---)/, '\1')
+
+      render html: html.html_safe
+    end
+  end
+end
+EOF
+
+bundle add dockerfile-rails --optimistic --group development
+bin/rails generate dockerfile --add neofetch colorized-logs
+docker buildx build . -t rails-demo
+docker run -p 3000:3000 -e RAILS_MASTER_KEY=$(cat config/master.key) rails-demo
 ```
 
 Add `--load` to the `buildx` command if you want to save the image to local Docker.
 
-# Demo 2 - Action Cable and Active Record
+# Demo 3 - Action Cable and Active Record
 
 Real applications involve a network of services.  The following demo makes use of PostgreSQL and Redis to display a welcome screen with a live, updating, visitors counter. Once done, take a look at the `docker-compose.yml` file produced.
 
 ```bash
-rails new welcome --database postgresql
-cd welcome
+rails new demo --database postgresql
+cd demo
 
 bin/rails generate model Visitor counter:integer
 bin/rails generate controller Visitors counter
@@ -87,7 +121,7 @@ cat << 'EOF' > config/routes.rb
 Rails.application.routes.draw { root "visitors#counter" }
 EOF
 
-bundle add dockerfile-rails --group development
+bundle add dockerfile-rails --optimistic --group development
 bin/rails generate dockerfile --compose
 
 export RAILS_MASTER_KEY=$(cat config/master.key)
@@ -95,14 +129,14 @@ docker compose build
 docker compose up
 ```
 
-# Demo 3 - API only
+# Demo 4 - API only
 
 This demo deploys a [Create React App](https://create-react-app.dev/) client and a Rails API-only server.  Ruby and Rails version information is retrieved from the server and displayed below a spinning React logo.  Note that the build process installs the
 node moddules and ruby gems in parallel.
 
 ```bash
-rails new welcome --api
-cd welcome
+rails new demo --api
+cd demo
 npx -y create-react-app client
 
 bin/rails generate controller Api versions
@@ -149,22 +183,22 @@ function App() {
 export default App;
 EOF
 
-bundle add dockerfile-rails --group development
+bundle add dockerfile-rails --optimistic --group development
 bin/rails generate dockerfile
 
-docker buildx build . -t rails-welcome
-docker run -p 3000:3000 -e RAILS_MASTER_KEY=$(cat config/master.key) rails-welcome
+docker buildx build . -t rails-demo
+docker run -p 3000:3000 -e RAILS_MASTER_KEY=$(cat config/master.key) rails-demo
 ```
 
-# Demo 4 - Bunding Javascript (esbuild)
+# Demo 5 - Bunding Javascript (esbuild)
 
 While optional, bundling Javascript is a popular choice, and starting with
 Rails 7 there are three options: esbuild, rollup, and webpack.  The
 the following demonstrates Rails 7 with esbuild:
 
 ```bash
-rails new welcome --javascript esbuild
-cd welcome
+rails new demo --javascript esbuild
+cd demo
 
 yarn add react react-dom
 bin/rails generate controller Time index
@@ -269,21 +303,21 @@ cat <<-"EOF" > config/routes.rb
 Rails.application.routes.draw { root "time#index" }
 EOF
 
-bundle add dockerfile-rails --group development
+bundle add dockerfile-rails --optimistic --group development
 bin/rails generate dockerfile
 
-docker buildx build . -t rails-welcome
-docker run -p 3000:3000 -e RAILS_MASTER_KEY=$(cat config/master.key) rails-welcome
+docker buildx build . -t rails-demo
+docker run -p 3000:3000 -e RAILS_MASTER_KEY=$(cat config/master.key) rails-demo
 ```
 
-# Demo 5 - Grover / puppeteer / Chrome
+# Demo 6 - Grover / puppeteer / Chrome
 
 This demo runs only on Intel hardware as Google doesn't supply Chrome
 binaries for Linux on ARM.
 
 ```bash
-rails new welcome --minimal
-cd welcome
+rails new demo --minimal
+cd demo
 bundle add grover
 npm install puppeteer
 
@@ -298,8 +332,8 @@ class GroverController < ApplicationController
 end
 EOF
 
-bundle add dockerfile-rails --group development
+bundle add dockerfile-rails --optimistic --group development
 bin/rails generate dockerfile
-docker buildx build . -t rails-welcome
-docker run -p 3000:3000 -e RAILS_MASTER_KEY=$(cat config/master.key) rails-welcome
+docker buildx build . -t rails-demo
+docker run -p 3000:3000 -e RAILS_MASTER_KEY=$(cat config/master.key) rails-demo
 ```

data/MOTIVATION.md

@@ -0,0 +1,58 @@
+# Ruby on Rails developer profile
+
+Let's start with the target audience of Ruby on Rails, which we can infer from the [web site](https://rubyonrails.org/).
+
+> Learn just what you need to get started, then keep leveling up as you go. Ruby on Rails scales from HELLO WORLD to IPO.
+
+It is fair to conclude from this that a typical Ruby on Rails developer meets some or all of the following characteristics:
+
+ * member of a small team
+ * business subject matter experts
+ * knowledgeable of, or recently introduced to, the Ruby programming language
+
+# Docker developer profile
+
+To illustrate the target audience of Rails Dockerfiles, I'm going to succinctly state some rather basic background information that is necessary to confidently make changes to the Rails 7.1 generated Dockerfiles:
+
+> Most [official Ruby dockerhub images](https://hub.docker.com/_/ruby)
+> are based on Debian [bullseye](https://www.debian.org/releases/bullseye/),
+> which provides a [large number of packages](https://packages.debian.org/stable/)
+> that you can install.
+> Simply find the packages that you need and add them to the `apt-get install` line
+> in the relevant [build stage](https://docs.docker.com/build/building/multi-stage/).
+
+# Intersection of the prior two groups
+
+Based on my experiences at [fly.io](https://fly.io/), the overlap between the members of the first group and the set of people that understand the paragraph in the second section isn't as large as you might think or hope.
+
+The purpose of the Dockerfile generator is to help bridge that gap.
+
+A usage scenario is that a team is formed.  They create an application.  When they started they were provided with a Dockerfile that is capable of deploying a HELLO WORLD application.  After several months of effort they are ready to deploy.  Undoubtedly they made at least one change that will require a modification to the Dockerfile, and find that they don't have the skills necessary to to make that change.
+
+Make no mistake about it, we are talking about intelligent, motivated people.  Just ones that may have never used a Debian Linux operating system before.
+
+# Value Proposition
+
+The goal is, whenever possible, have the following command bring the Dockerfile and associated files up to date with the current application:
+
+```cmd
+bin/rails generate dockerfile
+```
+
+Being able to rerun this command means that each invocation can focus on installing only what is necessary or selected to run this application, and not install other things that may (or may not) be useful later.
+
+While a laudable goad, it clearly is unattainable.  So a second goal is to make solutions to common problems be via one liners that can be shared via FAQs, Stack Overflow, Discourse, Discord, Slack or whatever.
+
+Some examples can be found in [Fly.io's FAQ](https://fly.io/docs/rails/getting-started/dockerfiles/).  The hope is that this generator becomes widely adopted and similar pages adapted to different target audiences pop up everywhere.  That makers of gems with special deployment needs produce pull requests to make it easier for Rails applications that make use of their gems to be deployed.
+
+Of course some will use this only as a starting point and make their own changes.  We welcome that.  Advanced users who need to run it again can use techniques like `git add --patch` to select which changes they want to keep.  Really advanced users will contribute back changes to this gem so that they can avoid the need to patch in the future.
+
+# Futures
+
+This can go in many directions.  Some thoughts.
+
+* While the number of popular gems with special installation requirements is finite, it may make sense to evolve a plug-in architecture where gems take ownership of their own requirements.  [Kuby](https://getkuby.io/) has a plugin system, so we should too.
+
+* [Create React App](https://reactjs.org/docs/create-a-new-react-app.html) has (had? I can't really be sure if this project is going to revive) an interesting approach.  Configuration files are invisible until you eject.  I'd love to see a [future where Dockerfiles were invisible and generated on deploy](https://fly.io/ruby-dispatch/dockerfile-less-deploys/).
+
+* CLIs are wonderful, but many have become spoiled by point and click dashboards.  Changing the problem from "anything you can put into a Dockerfile" to a set of options that can be expressed in a YAML file should enable such dashboards to be created.

data/README.md

@@ -7,6 +7,12 @@ Provides a Rails generator to produce Dockerfiles and related files.  This is be
   * Will set `.node_version`, `packageManager` and install gems if needed to deploy your application.
   * Can produce a `docker-compose.yml` file for locally testing your configuration before deploying.
 
+For more background:
+
+* [Motivation](./MOTIVATION.md) - why this generator was created and what problems it is meant to solve
+* [Demos](./DEMO.md) - scripts to copy and paste into an empty directory to launch demo apps
+* [Test Results](./test/results) - expected outputs for each test
+
 ## Usage
 
 ```
@@ -14,29 +20,29 @@ bundle add dockerfile-rails --optimistic --group development
 bin/rails generate dockerfile
 ```
 
-General option:
+### General option:
 
 * `--force` - overwrite existing files
 
-Runtime Optimizations:
+### Runtime Optimizations:
 
 * `--fullstaq` - use [fullstaq](https://fullstaqruby.org/) [images](https://github.com/evilmartians/fullstaq-ruby-docker) on [quay.io](https://quay.io/repository/evl.ms/fullstaq-ruby?tab=tags&tag=latest)
 * `--jemalloc` - use [jemalloc](https://jemalloc.net/) memory allocator
 * `--swap=n` - allocate swap space.  See [falloc options](https://man7.org/linux/man-pages/man1/fallocate.1.html#OPTIONS) for suffixes
 * `--yjit` - enable [YJIT](https://github.com/ruby/ruby/blob/master/doc/yjit/yjit.md) optimizing compiler
 
-Build optimizations:
+### Build optimizations:
 
 * `--cache` - use build caching to speed up builds
 * `--parallel` - use multi-stage builds to install gems and node modules in parallel
 
-Features:
+### Add a Feature:
 
 * `--ci` - include test gems in deployed image
 * `--compose` - generate a `docker-compose.yml` file
 * `--nginx` - serve static files via [nginx](https://www.nginx.com/)
 
-Dependencies:
+### Add a Database:
 
 Generally the dockerfile generator will be able to determine what dependencies you
 are actually using.  But should you be using DATABASE_URL, for example, at runtime
@@ -47,13 +53,25 @@ additional support may be needed:
 * `--redis` - add redis libraries
 * `--sqlite3` - add sqlite3 libraries
 
-Configuration:
+### Add a package/environment variable/build argument:
+
+Not all of your needs can be determined by scanning your application.  For example, I like to add [vim](https://www.vim.org/) and [procps](https://packages.debian.org/bullseye/procps).
+
+ * `--add package...` - add one or more debian packages
+ * `--arg=name:value` - add a [build argument](https://docs.docker.com/engine/reference/builder/#arg)
+ * `--env=name:value` - add an environment variable
+ * `--remove package...` - remove package from "to be added" list
+
+ Each of these can be tailored to a specific build phase by adding `-base`, `-build`, or `-deploy` after the flag name (e.g `--env-build:`).  If no such suffix is found, the default for arg is `-base`, and the default for the rest is `-deploy`.  Removal of an arg or environment variable is done by leaving the value blank.
+
+### Configuration:
 
 * `--bin-cd` - adjust binstubs to set current working directory
 * `--label=name:value` - specify docker label.  Can be used multiple times.  See [LABEL](https://docs.docker.com/engine/reference/builder/#label) for detail
 * `--no-prepare` - omit `db:prepare`.  Useful for cloud platforms with [release](https://devcenter.heroku.com/articles/release-phase) phases
 * `--platform=s` - specify target platform.  See [FROM](https://docs.docker.com/engine/reference/builder/#from) for details
 * `--precompile=defer` - may be needed when your configuration requires access to secrets that are not available at build time.  Results in larger images and slower deployments.
+* `--root` - run application as root
 
 Options are saved between runs into `config/dockerfile.yml`.  To invert a boolean options, add or remove a `no-` prefix from the option name.
 
@@ -82,12 +100,11 @@ If you are running a single test, the following environment variables settings m
 
 ## Links
 
-Many of the following links relate to the current development status with respect to Rails 7.1 and will be removed once that is resolved.
+The following links relate to the current development status with respect to Rails 7.1 and will be removed once that is resolved.
 
-* [Demos](./DEMO.md) - scripts to copy and paste into an empty directory to launch demo apps
-* [Test Results](./test/results) - expected outputs for each test
 * [Preparations for Rails 7.1](https://community.fly.io/t/preparations-for-rails-7-1/9512) - [Fly.io](https://fly.io/)'s plans and initial discussions with DHH
 * [Rails Dockerfile futures](https://discuss.rubyonrails.org/t/rails-dockerfile-futures/82091/1) - rationale for a generator
 * [Fly Cookbooks](https://fly.io/docs/rails/cookbooks/) - deeper dive into Dockerfile design choices
 * [app/templates/Dockerfile.tt](https://github.com/rails/rails/blob/main/railties/lib/rails/generators/rails/app/templates/Dockerfile.tt) - current Rails 7.1 template
 * Fly.io [Cut over to Rails Dockerfile Generator on Sunday 29 Jan 2023](https://community.fly.io/t/cut-over-to-rails-dockerfile-generator-on-sunday-29-jan-2023/10350)
+* Fly.io [FAQ](https://fly.io/docs/rails/getting-started/dockerfiles/)

data/Rakefile

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 
 # Run `rake release` to release a new version of the gem.
 
-require 'rake/testtask'
+require "rake/testtask"
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['test/test*.rb']
+  t.test_files = FileList["test/test*.rb"]
   t.verbose = true
 end
 
 namespace :test do
   task :capture do
-    ENV['TEST_CAPTURE'] = 'true'
+    ENV["TEST_CAPTURE"] = "true"
     Rake::Task[:test].invoke
   end
 end

data/lib/dockerfile-rails/scanner.rb

@@ -1,26 +1,27 @@
+# frozen_string_literal: true
+
 module DockerfileRails
   module Scanner
     def scan_rails_app
-
       ### ruby gems ###
 
       @gemfile = []
       @git = false
 
-      if File.exist? 'Gemfile.lock'
-        parser = Bundler::LockfileParser.new(Bundler.read_file('Gemfile.lock'))
+      if File.exist? "Gemfile.lock"
+        parser = Bundler::LockfileParser.new(Bundler.read_file("Gemfile.lock"))
         @gemfile += parser.specs.map { |spec, version| spec.name }
-        @git ||= ENV['RAILS_ENV'] != 'test' && parser.specs.any? do |spec|
+        @git ||= ENV["RAILS_ENV"] != "test" && parser.specs.any? do |spec|
           spec.source.instance_of? Bundler::Source::Git
         end
       end
-      
-      if File.exist? 'Gemfile'
+
+      if File.exist? "Gemfile"
         begin
-          gemfile_definition = Bundler::Definition.build('Gemfile', nil, [])
+          gemfile_definition = Bundler::Definition.build("Gemfile", nil, [])
           @gemfile += gemfile_definition.dependencies.map(&:name)
 
-          unless ENV['RAILS_ENV'] == 'test'
+          unless ENV["RAILS_ENV"] == "test"
             @git = !gemfile_definition.spec_git_paths.empty?
           end
         rescue => error
@@ -28,53 +29,53 @@ module DockerfileRails
         end
       end
 
-      @anycable = @gemfile.include? 'anycable-rails'
-      @vips = @gemfile.include? 'ruby-vips'
-      @bootstrap = @gemfile.include? 'bootstrap'
-      @puppeteer = @gemfile.include? 'puppeteer'
-      @bootsnap = @gemfile.include? 'bootsnap'
+      @anycable = @gemfile.include? "anycable-rails"
+      @vips = @gemfile.include? "ruby-vips"
+      @bootstrap = @gemfile.include? "bootstrap"
+      @puppeteer = @gemfile.include? "puppeteer"
+      @bootsnap = @gemfile.include? "bootsnap"
 
       ### database ###
 
-      database = YAML.load_file('config/database.yml', aliases: true).
-        dig('production', 'adapter') rescue nil
+      database = YAML.load_file("config/database.yml", aliases: true).
+        dig("production", "adapter") rescue nil
 
-      if database == 'sqlite3'
+      if database == "sqlite3"
         @sqlite3 = true
-      elsif database == 'postgresql'
+      elsif database == "postgresql"
         @postgresql = true
-      elsif database == 'mysql' or database == 'mysql2'
+      elsif (database == "mysql") || (database == "mysql2")
         @mysql = true
-      elsif database == 'sqlserver'
+      elsif database == "sqlserver"
         @sqlserver = true
       end
 
-      @sqlite3 = true if @gemfile.include? 'sqlite3'
-      @postgresql = true if @gemfile.include? 'pg'
-      @mysql = true if @gemfile.include? 'mysql2'
+      @sqlite3 = true if @gemfile.include? "sqlite3"
+      @postgresql = true if @gemfile.include? "pg"
+      @mysql = true if @gemfile.include? "mysql2"
 
       ### node modules ###
 
       @package_json = []
 
-      if File.exist? 'package.json'
-        @package_json += JSON.load_file('package.json')['dependencies'].keys rescue []
+      if File.exist? "package.json"
+        @package_json += JSON.load_file("package.json")["dependencies"].keys rescue []
       end
 
-      @puppeteer ||= @package_json.include? 'puppeteer'
+      @puppeteer ||= @package_json.include? "puppeteer"
 
       ### cable/redis ###
 
-      @cable = ! Dir['app/channels/*.rb'].empty?
+      @cable = ! Dir["app/channels/*.rb"].empty?
 
       if @cable
         @redis_cable = true
-        if (YAML.load_file('config/cable.yml').dig('production', 'adapter') rescue '').include? 'any_cable'
+        if (YAML.load_file("config/cable.yml").dig("production", "adapter") rescue "").include? "any_cable"
           @anycable = true
         end
       end
 
-      if (IO.read('config/environments/production.rb') =~ /redis/i rescue false)
+      if (IO.read("config/environments/production.rb") =~ /redis/i rescue false)
         @redis_cache = true
       end
 

data/lib/dockerfile-rails.rb

@@ -1,5 +1,7 @@
-require 'rails'
-require 'dockerfile-rails/scanner'
+# frozen_string_literal: true
+
+require "rails"
+require "dockerfile-rails/scanner"
 
 class DockerRailsRailtie < Rails::Railtie
-end
+end