docs-kit 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df9e88e060d79197aaf8f9247000b31f5da3568bbf7099f18f59bc216b11e877
-  data.tar.gz: 1fde31a5d995087e06b62f2b58983e73acfc12309d6958db6e913f538894edbf
+  metadata.gz: 4ede4d90b3f6ca240a59c5f13d14967a29cf8a806fa041a3c7edfe65adf1ed2c
+  data.tar.gz: 015f6f05b3d3b09581679810ae41b3486c2428dc219d2d47f32775a40b449759
 SHA512:
-  metadata.gz: 8c8de40c603fa96e5fbee8aa377816894566c3b4f40c632e51d1a1055b875fe48b3349ef9cc833f0bada6b85d3504cfdc433ef27c9cdb9fff16ce30e81f0aa16
-  data.tar.gz: 7230b76a2e9d68d98061c92b2002ad59a2ca9a4609df75d8de2c68f4d911c78938188e1b87d1ced4c3ad7ff52ea4e9e6105fe8b0d2f43c27da826b77297f82fb
+  metadata.gz: 2b315f74f9de60f0e02354b3e8e093a85d06c99dc6bc8e9d1f96ad9ac0abc0bf7fe0d5db37f716b68e1fac2daabcafae1bd69b5c22cf587d7068cfc3b27c3050
+  data.tar.gz: f7868334e630ce1ab3ec99c9fbcfd91fbb6302c0f999c4b87dfc1c04959cbd8aac7cfecb49623ba2e4f2557665dcd844439f1d69211c97d5baa2ba55ad7efd6e

data/README.md

@@ -92,6 +92,39 @@ generators:
 | `ApplicationController#render_page` defined by hand | `DocsKit::Controller#render_page` is included (the generator injects `include DocsKit::Controller`) | Delete the method — keep the `include`. |
 | `app/helpers/icon_helper.rb` | docs-kit renders icons via rails_icons (`DocsUI::Icon`) | Delete the file. |
 | Hand-pinned docs-kit lines in `config/importmap.rb` | the engine auto-pins the `docs-nav` controller and its assets | Delete the manual `pin`/`pin_all_from` lines for docs-kit. |
+| `Dockerfile` stamped by an older docs-kit (`# docs-kit Dockerfile vX.Y.Z`) | docs-kit ships an optimized, multi-stage Dockerfile; a stale copy misses image-size wins | Diff yours against the current template (`lib/generators/docs_kit/install/templates/Dockerfile.tt` in the gem), adopt the changes or replace it. See [Upgrading your Dockerfile](#upgrading-your-dockerfile). |
+
+### Upgrading your Dockerfile
+
+The generator ships two Docker files:
+
+- **`.dockerignore`** is gem-owned — every `docs_kit:install` (or `--sync`) run
+  **refreshes** it, so you always get the current build-context excludes
+  (`node_modules`, `.git`, `log`, `tmp`, `spec`, `coverage`, …). It carries no
+  site-specific content, so overwriting it is safe.
+- **`Dockerfile`** is site-owned — the generator **never clobbers** it (you tune
+  packages, the `CMD`, extra build steps). Instead it stamps a version marker
+  (`# docs-kit Dockerfile v<VERSION>`) so `--sync` can tell you when yours is
+  stale relative to the gem's current template.
+
+When the site bundles `thruster` (a Rails 8 default), the generated Dockerfile
+fronts Puma with Thruster (`CMD ["./bin/thrust", "./bin/rails", "server"]`) for
+HTTP caching, compression, and X-Sendfile — and the generator scaffolds the
+`bin/thrust` binstub if the app lacks one, since the exec-form CMD needs the
+file to exist in the image. Thruster listens on the routed port
+(`HTTP_PORT=3000` — Kamal's `app_port`) and proxies to Puma on `TARGET_PORT=3001`.
+Without thruster in the *production* bundle (absent, or only in a
+development/test group that `BUNDLE_WITHOUT` excludes) the CMD falls back to
+plain `rails server` — never a thrust CMD that would crash at boot.
+
+When `--sync` reports your Dockerfile is behind, compare it against the shipped
+template and pull in the improvements (or replace it wholesale if you never
+customized it):
+
+```bash
+# The template path is printed by the generator; it lives in the installed gem:
+diff Dockerfile "$(bundle show docs-kit)/lib/generators/docs_kit/install/templates/Dockerfile.tt"
+```
 
 ## Configure (per site)
 
@@ -751,8 +784,9 @@ and applies docs-kit's application template, which:
 - runs `rails g docs_kit:install` (initializers, controllers, a Doc registry, a
   sample guide page, the Bun/Tailwind build, the docs-nav Stimulus wiring),
 - syncs the lucide icons and builds the CSS,
-- scaffolds Kamal (`config/deploy.yml`, `.kamal/secrets`, `Dockerfile`) and a
-  thin `.github/workflows/deploy-docs.yml` that calls the reusable workflow.
+- scaffolds Kamal (`config/deploy.yml`, `.kamal/secrets`, an optimized
+  multi-stage `Dockerfile` + a `.dockerignore`) and a thin
+  `.github/workflows/deploy-docs.yml` that calls the reusable workflow.
 
 Then `cd my-docs && bin/dev`. Already have a Rails app? Run the install generator
 instead:

data/lib/docs_kit/templates/new_site.rb

@@ -4,7 +4,10 @@ require "securerandom"
 
 # Rails application template for a docs-kit docs site. Run via:
 #
-#   rails new my-docs --minimal -a propshaft -j importmap --skip-... -m new_site.rb
+#   rails new my-docs -a propshaft -j importmap --skip-... -m new_site.rb
+#
+# (NOT --minimal — that strips JS the shell needs AND the thruster gem the
+# generated Dockerfile fronts Puma with; exe/docs-kit passes the right flags.)
 #
 # or, more simply, via the `docs-kit new` CLI (exe/docs-kit) which supplies the
 # right `rails new` flags. It:
@@ -101,45 +104,13 @@ after_bundle do
     KAMAL_REGISTRY_PASSWORD=$KAMAL_REGISTRY_PASSWORD
   SH
 
-  create_file "Dockerfile", <<~DOCKER
-    # syntax = docker/dockerfile:1
-    ARG RUBY_VERSION=3.4.2
-    FROM ruby:$RUBY_VERSION-slim AS base
-
-    ARG BUN_VERSION=1.3.2
-    ENV BUN_INSTALL="/usr/local/bun"
-    ENV PATH="/usr/local/bun/bin:$PATH"
-    WORKDIR /rails
-    ENV BUNDLE_WITHOUT="development:test" RAILS_ENV="production"
-
-    RUN apt-get update -qq && \\
-        apt-get install --no-install-recommends -y curl libjemalloc2 && \\
-        rm -rf /var/lib/apt/lists /var/cache/apt/archives
-    RUN gem update --system --no-document && gem install -N bundler
-
-    FROM base AS build
-    RUN apt-get update -qq && \\
-        apt-get install --no-install-recommends -y build-essential git libyaml-dev pkg-config unzip
-    RUN curl -fsSL https://bun.sh/install | bash -s "bun-v${BUN_VERSION}"
-    COPY Gemfile Gemfile.lock ./
-    RUN bundle install && rm -rf ~/.bundle/ "${BUNDLE_PATH}"/ruby/*/cache
-    COPY . .
-    RUN bun install --frozen-lockfile
-    # assets:precompile runs bun run build:css via the css:build rake enhance.
-    RUN SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile
-
-    FROM base
-    # Kamal verifies this label on --skip-push deploy; must equal `service:`.
-    LABEL service="#{service}"
-    COPY --from=build "${BUNDLE_PATH}" "${BUNDLE_PATH}"
-    COPY --from=build /rails /rails
-    RUN groupadd --system --gid 1000 rails && \\
-        useradd rails --uid 1000 --gid 1000 --create-home --shell /bin/bash && \\
-        chown -R 1000:1000 /rails/log /rails/tmp
-    USER 1000:1000
-    EXPOSE 3000
-    CMD ["./bin/rails", "server", "-b", "0.0.0.0"]
-  DOCKER
+  # The Dockerfile + .dockerignore are written by `docs_kit:install` (run above in
+  # after_bundle) so a scaffolded site and an upgrading site share ONE optimized,
+  # version-stamped Dockerfile — no divergent copy to maintain here. The generator
+  # derives the LABEL service from the app dir basename (= app_name); if the site
+  # deploys under a DIFFERENT Kamal service (`--service`), correct the label to
+  # match config/deploy.yml so Kamal's --skip-push validate_image passes.
+  gsub_file "Dockerfile", /LABEL service=".*"/, %(LABEL service="#{service}") if service != app_name
 
   create_file ".github/workflows/deploy-docs.yml", <<~YAML
     name: Deploy docs

data/lib/docs_kit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DocsKit
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

data/lib/generators/docs_kit/install/install_generator.rb

@@ -4,6 +4,7 @@ require "erb"
 require "yaml"
 require "rails/generators/base"
 require_relative "sync_report"
+require_relative "../../../docs_kit/version"
 
 module DocsKit
   module Generators
@@ -178,6 +179,49 @@ module DocsKit
         template "docs_kit_og.rake", "lib/tasks/docs_kit_og.rake"
       end
 
+      # The production Dockerfile — a lean multi-stage build for a standalone
+      # docs site. Site-customizable (a site tunes packages/CMD), so skip when it
+      # exists and point an upgrader at the current template for a manual diff.
+      # The template stamps a `# docs-kit Dockerfile vX.Y.Z` marker so a `--sync`
+      # upgrade (SyncReport) can flag a stale copy. (create_initializer follows
+      # this same skip-if-exists + template-hint pattern.)
+      def create_dockerfile
+        dockerfile = "Dockerfile"
+        if File.exist?(File.join(destination_root, dockerfile))
+          template_path = File.join(self.class.source_root, "Dockerfile.tt")
+          return say_status(:skip, "#{dockerfile} exists — compare with #{template_path} if upgrading", :blue)
+        end
+
+        template "Dockerfile.tt", dockerfile
+      end
+
+      # The .dockerignore — gem-owned build-context trimming (node_modules, .git,
+      # logs, specs, coverage). Refreshed on every run (like create_og_task): it
+      # carries no site-specific content, so a re-run always ships the current
+      # excludes rather than fossilizing an old list.
+      def create_dockerignore
+        copy_file "dockerignore", ".dockerignore", force: true
+      end
+
+      # When the site bundles thruster but lacks the binstub, create it — the
+      # Dockerfile's exec-form `CMD ["./bin/thrust", ...]` needs the file to EXIST
+      # in the image (`bundle install` installs the gem, not app binstubs, and
+      # `COPY . .` can't ship a file the repo doesn't have). Without this, the
+      # image builds green and the container crashes at boot. Skip-if-exists: a
+      # hand-tuned binstub is never touched.
+      def create_thrust_binstub
+        return unless gemfile_bundles_thruster? && !thrust_binstub?
+
+        create_file "bin/thrust", <<~RUBY
+          #!/usr/bin/env ruby
+          require "rubygems"
+          require "bundler/setup"
+
+          load Gem.bin_path("thruster", "thrust")
+        RUBY
+        chmod "bin/thrust", 0o755
+      end
+
       def wire_assets_and_package_json
         # Serve the bun-built CSS from app/assets/builds.
         inject_into_file "config/initializers/assets.rb",
@@ -452,6 +496,56 @@ module DocsKit
         name = defined?(Rails) && Rails.respond_to?(:application) && Rails.application&.class&.module_parent_name
         (name || File.basename(destination_root)).to_s.underscore.humanize
       end
+
+      # The Kamal `service` name stamped as the Dockerfile's LABEL — the app dir
+      # basename (a docs site's repo name), matching the `docs-kit new` default.
+      # Used in Dockerfile.tt via <%= docker_service %>.
+      def docker_service
+        File.basename(destination_root)
+      end
+
+      # The RUBY_VERSION build ARG default: the host's running Ruby (X.Y.Z), so a
+      # site's image matches its dev Ruby. Used in Dockerfile.tt.
+      def ruby_version_arg
+        RUBY_VERSION[/\d+\.\d+\.\d+/] || "3.4.2"
+      end
+
+      # True when the site bundles Thruster (HTTP caching + compression +
+      # X-Sendfile in front of Puma) — a Rails 8 `rails new` ships bin/thrust +
+      # the gem, but docs_kit:install also runs on older apps where a thrust CMD
+      # would crash the container at boot (Gem.bin_path raises). Decides which
+      # CMD Dockerfile.tt emits. A committed binstub is authoritative; otherwise
+      # the Gemfile decides (and create_thrust_binstub scaffolds the binstub).
+      def thruster?
+        thrust_binstub? || gemfile_bundles_thruster?
+      end
+
+      def thrust_binstub?
+        File.exist?(File.join(destination_root, "bin/thrust"))
+      end
+
+      # True when the Gemfile declares thruster where the PRODUCTION bundle sees
+      # it. The Dockerfile sets BUNDLE_WITHOUT="development:test", so a
+      # `group :development do ... end` entry (or an inline `group:` kwarg) must
+      # NOT count — the gem wouldn't be installed and thrust would raise at boot.
+      # Line-level block tracking: any `... do` pushes, `end` pops; a gem line
+      # counts only outside every group block (nested non-group blocks are fine).
+      def gemfile_bundles_thruster?
+        gemfile = File.join(destination_root, "Gemfile")
+        return false unless File.exist?(gemfile)
+
+        block_stack = []
+        File.foreach(gemfile) do |line|
+          if line.match?(/\bdo\s*(\|[^|]*\|)?\s*$/)
+            block_stack.push(line.match?(/^\s*group\b/))
+          elsif line.match?(/^\s*end\b/)
+            block_stack.pop
+          elsif block_stack.none? && line.match?(/^\s*gem\s+["']thruster["']/) && !line.match?(/\bgroup:/)
+            return true
+          end
+        end
+        false
+      end
     end
   end
 end

data/lib/generators/docs_kit/install/sync_report.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../../docs_kit/version"
+
 module DocsKit
   module Generators
     # Detects manual drift in an existing docs site that the install generator
@@ -9,13 +11,21 @@ module DocsKit
     # generator prints these as a checklist during a `--sync` upgrade; the site
     # owner deletes the flagged code by hand.
     #
-    # Two drift items, both from the consumer audits:
+    # Drift items, from the consumer audits:
     #   - ApplicationController hand-defines `render_page` — DocsKit::Controller
     #     (included by the generator for months) already provides it.
     #   - a dead IconHelper copy — the gem renders icons via rails_icons.
+    #   - a Dockerfile stamped by an OLDER docs-kit than the gem now ships — the
+    #     site should diff against the current template and adopt the improvements.
     class SyncReport
       APPLICATION_CONTROLLER = "app/controllers/application_controller.rb"
       ICON_HELPER = "app/helpers/icon_helper.rb"
+      DOCKERFILE = "Dockerfile"
+
+      # Matches the version stamp the Dockerfile template writes, e.g.
+      # `# docs-kit Dockerfile v1.0.2`. Absent on a hand-written Dockerfile a site
+      # brought itself — which we deliberately leave alone (no marker → no warning).
+      DOCKERFILE_MARKER = /docs-kit Dockerfile v(\d+\.\d+\.\d+)/
 
       def initialize(destination_root)
         @root = destination_root
@@ -24,7 +34,7 @@ module DocsKit
       # The drift messages, in the order a site should act on them. Empty when
       # the site is clean.
       def items
-        [render_page_drift, icon_helper_drift].compact
+        [render_page_drift, icon_helper_drift, dockerfile_drift].compact
       end
 
       def clean?
@@ -53,6 +63,22 @@ module DocsKit
           "rails_icons (DocsUI::Icon); delete it."
       end
 
+      # The site's Dockerfile carries a docs-kit version stamp OLDER than the gem
+      # now ships. We never rewrite the site's Dockerfile (it's tuned per site) —
+      # we point the owner at the current template to diff or replace. A file with
+      # no marker (a hand-written Dockerfile) is left alone: no stamp, no warning.
+      def dockerfile_drift
+        source = read(DOCKERFILE)
+        stamped = source&.match(DOCKERFILE_MARKER)
+        return unless stamped
+
+        site_version = stamped[1]
+        return if site_version == DocsKit::VERSION
+
+        "#{DOCKERFILE} is v#{site_version}, docs-kit now ships v#{DocsKit::VERSION} — " \
+          "diff against the template (bin/rails g docs_kit:install shows the path) and adopt the changes."
+      end
+
       def read(rel)
         path = File.join(@root, rel)
         File.exist?(path) ? File.read(path) : nil

data/lib/generators/docs_kit/install/templates/Dockerfile.tt

@@ -0,0 +1,96 @@
+# syntax = docker/dockerfile:1
+# docs-kit Dockerfile v<%= DocsKit::VERSION %> — regenerate/diff: bin/rails g docs_kit:install
+#
+# A standalone docs-kit site: a lean, multi-stage production image. The final
+# stage carries only the runtime (Ruby + the installed bundle + the app), never
+# the build toolchain (build-essential, git, bun) — those live in the throwaway
+# `build` stage. Pair it with the shipped .dockerignore so the build context
+# stays small (no node_modules, .git, logs, specs, coverage).
+#
+# Build context is the app root; `docker build .` (Kamal: context: ".").
+
+ARG RUBY_VERSION=<%= ruby_version_arg %>
+FROM docker.io/library/ruby:$RUBY_VERSION-slim AS base
+
+# Rails app lives here.
+WORKDIR /rails
+
+ARG BUN_VERSION=1.3.2
+ENV BUN_INSTALL="/usr/local/bun" \
+    PATH="/usr/local/bun/bin:$PATH" \
+    BUNDLE_DEPLOYMENT="1" \
+    BUNDLE_PATH="/usr/local/bundle" \
+    BUNDLE_WITHOUT="development:test" \
+    RAILS_ENV="production"
+
+# Base packages the RUNTIME needs (jemalloc for a smaller/faster heap, curl for
+# the container healthcheck). Anything only the build needs goes in `build`.
+RUN apt-get update -qq && \
+    apt-get install --no-install-recommends -y curl libjemalloc2 && \
+    rm -rf /var/lib/apt/lists /var/cache/apt/archives
+
+
+# --- Build stage (throwaway — its layers never reach the final image) ---------
+FROM base AS build
+
+# Toolchain to compile native gems + fetch bun. Skip the apt cleanup: this whole
+# stage is discarded.
+RUN apt-get update -qq && \
+    apt-get install --no-install-recommends -y build-essential git libyaml-dev pkg-config unzip
+RUN curl -fsSL https://bun.sh/install | bash -s -- "bun-v${BUN_VERSION}"
+
+# Install gems first (cached until Gemfile/Gemfile.lock change), then prune the
+# bundler cache + any git-sourced gem checkouts so they don't bloat the layer.
+COPY Gemfile Gemfile.lock ./
+RUN bundle install && \
+    rm -rf ~/.bundle/ "${BUNDLE_PATH}"/ruby/*/cache "${BUNDLE_PATH}"/ruby/*/bundler/gems/*/.git
+
+# Install JS deps (the Tailwind/daisyUI CLI), then the app.
+COPY package.json bun.lock* ./
+RUN bun install --frozen-lockfile
+COPY . .
+
+# assets:precompile runs `bun run build:css` via the css:build rake enhance.
+# Drop the node_modules + bun cache afterwards — the built CSS is all we keep.
+RUN SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile && \
+    rm -rf node_modules .bun tmp/cache
+
+
+# --- Final stage --------------------------------------------------------------
+FROM base
+
+# Kamal's validate_image greps this label on a --skip-push deploy; it must equal
+# `service:` in config/deploy.yml. The reusable deploy workflow also stamps it,
+# but keeping it here means `docker build` alone produces a Kamal-valid image.
+LABEL service="<%= docker_service %>"
+
+# Copy ONLY the built artifacts from the build stage: the installed bundle and
+# the app (with precompiled assets). No toolchain, no node_modules.
+COPY --from=build "${BUNDLE_PATH}" "${BUNDLE_PATH}"
+COPY --from=build /rails /rails
+
+# Run as a non-root user; own only the runtime dirs it writes.
+RUN groupadd --system --gid 1000 rails && \
+    useradd rails --uid 1000 --gid 1000 --create-home --shell /bin/bash && \
+    chown -R 1000:1000 /rails/log /rails/tmp
+USER 1000:1000
+
+EXPOSE 3000
+<% if thruster? -%>
+# Thruster fronts Puma (HTTP caching + compression + X-Sendfile). It listens on
+# HTTP_PORT and proxies to Puma on TARGET_PORT (it sets PORT for the child, which
+# config/puma.rb reads). HTTP_PORT MUST be the port traffic is routed to (Kamal's
+# `app_port`, the EXPOSE above) — Thruster's default is 80, which the non-root
+# user can't reliably bind AND which kamal-proxy (app_port: 3000) would never
+# route to, silently bypassing Thruster straight into Puma.
+ENV HTTP_PORT="3000" \
+    TARGET_PORT="3001"
+CMD ["./bin/thrust", "./bin/rails", "server"]
+<% else -%>
+# No Thruster in this app's bundle — plain Puma. To front it with Thruster
+# (HTTP caching/compression/X-Sendfile): add `gem "thruster"`, then delete this
+# file and re-run `bin/rails g docs_kit:install` — the generator never
+# overwrites an existing Dockerfile, so a re-run alone won't update it. (It
+# also scaffolds the bin/thrust binstub the thrust CMD needs.)
+CMD ["./bin/rails", "server", "-b", "0.0.0.0"]
+<% end -%>

data/lib/generators/docs_kit/install/templates/dockerignore

@@ -0,0 +1,57 @@
+# docs-kit .dockerignore — keep the build context (and image layers) small.
+# Gem-owned: `bin/rails g docs_kit:install` refreshes this on every run.
+# See https://docs.docker.com/build/building/context/#dockerignore-files
+
+# Git metadata — the app build never needs it (a released gem carries its files).
+/.git/
+/.gitignore
+/.gitattributes
+
+# Bundler config (BUNDLE_* env in the Dockerfile drives the install instead).
+/.bundle
+
+# Environment files and credentials — never bake secrets into an image.
+/.env*
+!/.env*.erb
+/config/master.key
+/config/credentials/*.key
+
+# Logs and tempfiles (keep the dirs, drop the contents).
+/log/*
+!/log/.keep
+/tmp/*
+!/tmp/.keep
+/tmp/pids/*
+!/tmp/pids/.keep
+
+# JS deps + generated assets: `bun install` + `assets:precompile` rebuild them.
+/node_modules/
+/app/assets/builds/*
+!/app/assets/builds/.keep
+# Generated by bin/build-css — Tailwind resolves the gem @source globs at build.
+/app/assets/stylesheets/tailwind.sources.css
+/public/assets
+
+# Tests + coverage — not needed to run the site in production.
+/spec/
+/.rspec
+/coverage/
+/spec/examples.txt
+
+# CI / deploy / Docker meta — not part of the runtime image.
+/.github/
+/.kamal/
+/Dockerfile*
+/.dockerignore
+
+# Editor + AI-assistant configs.
+/.claude/
+/.cursor/
+/.vscode/
+/.idea/
+/.ruby-lsp/
+/.solargraph.yml
+
+# Docs-kit's own tooling snapshots (harmless if absent in a consuming site).
+/codedb.snapshot
+/.worktrees/

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: docs-kit
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -233,11 +233,13 @@ files:
 - lib/generators/docs_kit/install/USAGE
 - lib/generators/docs_kit/install/install_generator.rb
 - lib/generators/docs_kit/install/sync_report.rb
+- lib/generators/docs_kit/install/templates/Dockerfile.tt
 - lib/generators/docs_kit/install/templates/agents_md.erb
 - lib/generators/docs_kit/install/templates/application.tailwind.css.erb
 - lib/generators/docs_kit/install/templates/build-css
 - lib/generators/docs_kit/install/templates/build_css.rake
 - lib/generators/docs_kit/install/templates/doc.rb.erb
+- lib/generators/docs_kit/install/templates/dockerignore
 - lib/generators/docs_kit/install/templates/docs_controller.rb.erb
 - lib/generators/docs_kit/install/templates/docs_kit.rb.erb
 - lib/generators/docs_kit/install/templates/docs_kit_og.rake