#!/usr/bin/make -f

include shared.env

-include .env

all: gen-env up down debug shell setup serve switch-channel test-channel \

refresh-code-excerpts check-code check-links test debug-test build \

build-image deploy stage clean reinstall purge

.DEFAULT_GOAL := up

.PHONY: all

FIREBASE_ALIAS ?= default

# =================== Development Commands ==================

# Generate .env file with defaults

# The .env file is used to store local secrets and settings

# NOTE that using a `FIREBASE_TOKEN` is optional and not required.

# If you have generated a token via `firebase login:ci` and it is

# set in your `.env` file, it will be used for deployment. Otherwise,

# the command will use the manual setup described above.

# Usage: `make gen-env`

.env:

touch $@

genenv: .env

@echo "DISABLE_TESTS=1" >> $<

@echo "FLUTTER_BRANCH=stable" >> $<

@echo "FIREBASE_ALIAS=default" >> $<

@echo "FIREBASE_TOKEN=" >> $<

# Start the dev container and serve the Jekyll site. If the

# site is not yet built, this will run build automatically

up:

docker-compose up site

# Bring down the running dev container

down:

docker-compose down

# Run the dev container and enter shell for debugging

debug:

docker-compose run --rm site bash

# Enter the shell of the *running* dev container

shell:

docker-compose exec site bash

# Build the dev container from scratch.

# Runs packages installs a second time for both Gems and NPM to

# overcome inconsistent bugs with missing packages at runtime.

setup:

make clean

docker-compose build --no-cache site

docker-compose run --rm site npm install

docker-compose run --rm site bundle config set force_ruby_platform true

docker-compose run --rm site bundle install

# Serve the Jekyll site with livereload and incremental builds

# NOTE this is run inside of the container on `make up`

serve:

bundle exec jekyll serve \

--host ${SITE_HOST} \

--port ${SITE_PORT} \

--config _config.yml,_config_dev.yml \

--livereload \

--incremental \

--trace

# Test hosting locally with FB emulator

emulate:

firebase emulators:start --only hosting --project ${FIREBASE_ALIAS}

# =================== Testing locally from host ==================

# NOTE that these are for convenience of testing from outside of a container.

# You could just as easily enter a fresh container shell and run these as any

# code changes on host would be reflected inside the container. e.g.

# ```

# docker-compose run --rm site bash

# $ make switch-channel CHANNEL=dev

# $ tool/test.sh --target ${CHANNEL} --check-links --null-safety

# ```

CHANNEL ?= stable

# Convenience command to run inside of a container to

# switch the channel of the flutter submodule.

# NOTE that changes will be reflected in your local flutter repo

# Usage: `make switch-channel CHANNEL=<channel>`

switch-channel:

cd flutter && \

git remote set-branches origin ${CHANNEL} && \

git fetch --depth 1 origin ${CHANNEL} && \

git checkout ${CHANNEL} -- && \

git pull && \

cd .. && \

flutter doctor

# Run tests against a channel

# NOTE this will mirror test artifacts to local via the volume

# Usage: `make test-channel CHANNEL=<channel>`

test-channel:

docker-compose run -d --rm site

docker-compose exec site tool/test.sh --target ${CHANNEL} --check-links --null-safety

docker-compose stop site

# Test refreshing code excerpts

# NOTE this will mirror test artifacts to local via the volume

# Usage: `make refresh-code-excerpts`

refresh-code-excerpts:

docker-compose run -d --rm site

docker-compose exec site tool/refresh-code-excerpts.sh --keep-dart-tool

docker-compose stop site

# Test checking code snippets

# NOTE this will mirror test artifacts to local via the volume

# Usage: `make check-code`

check-code:

docker-compose run -d --rm site

docker-compose exec site tool/check-code.sh --refresh --null-safety

docker-compose stop site

# Test checking links

# NOTE this will mirror test artifacts to local via the volume

# Usage: `make check-links`

check-links:

docker-compose run -d --rm site

docker-compose exec site tool/check-links.sh

docker-compose stop site

# =================== Build / Test / Deploy Commands ==================

FLUTTER_BRANCH ?= stable

TEST_TARGET_CHANNEL ?= stable

BUILD_CONFIGS ?= _config.yml

BUILD_COMMIT := $(shell git rev-parse --short HEAD)

BUILD_TAG = fltbuild

BUILD_NAME = tmpbuild

# Run all tests that would be run inside the container for the

# given target channel on the Github action `test` job.

# WARNING this can take long while to run!

# # Usage: `make test TEST_TARGET_CHANNEL=<channel>`

test:

docker build --rm --target test \

--build-arg TEST_TARGET_CHANNEL=${TEST_TARGET_CHANNEL} \

--build-arg RUBY_VERSION=${RUBY_VERSION} \

--build-arg NODE_VERSION=${NODE_VERSION} -t ${BUILD_TAG}:${BUILD_COMMIT} .

# Allows for firing up a shell with a regular build and

# running shell scripts manually to test the build.

# Usage `make debug-test`

debug-test:

docker build --rm --target dev \

--build-arg RUBY_VERSION=${RUBY_VERSION} \

--build-arg NODE_VERSION=${NODE_VERSION} -t ${BUILD_TAG}:${BUILD_COMMIT} .

docker run --rm -it \

-v ${PWD}/tool:/app/tool ${BUILD_TAG}:${BUILD_COMMIT} bash

docker rmi -f ${BUILD_TAG}:${BUILD_COMMIT}

# Build the production image

# NOTE important to disable tests with the local build as

# those will be run on the Github action.

# Usage: `DISABLE_TESTS=1 make build-image`

build-image:

docker build --rm --target builder \

--build-arg FIREBASE_ALIAS=${FIREBASE_ALIAS} \

--build-arg FIREBASE_TOKEN=${FIREBASE_TOKEN} \

--build-arg FLUTTER_BRANCH=${FLUTTER_BRANCH} \

--build-arg DISABLE_TESTS=${DISABLE_TESTS} \

--build-arg BUILD_COMMIT=${BUILD_COMMIT} \

--build-arg BUILD_CONFIGS=${BUILD_CONFIGS} \

--build-arg RUBY_VERSION=${RUBY_VERSION} \

--build-arg NODE_VERSION=${NODE_VERSION} -t ${BUILD_TAG}:${BUILD_COMMIT} .

# Build the production image and copy site build to local.

# This will reset and also clean up after finished.

# NOTE important to disable tests with the local build as

# those will be run on the Github action.

# Usage: `DISABLE_TESTS=1 make build`

build:

make clean

make build-image

docker run --rm -d --name ${BUILD_NAME} -t ${BUILD_TAG}:${BUILD_COMMIT}

docker cp ${BUILD_NAME}:/app/_site _site

docker stop ${BUILD_NAME}

docker rmi -f ${BUILD_TAG}:${BUILD_COMMIT}

# Deploy the Firebase hosting site from local.

# NOTE that if you have a FIREBASE_TOKEN exported or

# in your local `.env` file, it will be used. This style

# is used inside the Github action.

# Usage: `make deploy`

deploy:

ifndef FIREBASE_TOKEN

firebase deploy -m ${BUILD_COMMIT} --only hosting

else

firebase use ${FIREBASE_ALIAS}

firebase deploy -m ${BUILD_COMMIT} \

--only hosting \

--non-interactive \

--token ${FIREBASE_TOKEN} \

--project ${FIREBASE_ALIAS} \

--debug \

--json

endif

# All in one command to stage your build to a Firebase

# channel on your currently selected project

# Usage: `make stage STAGE_NAME=foo`

STAGE_NAME ?= docs

stage:

make build BUILD_CONFIGS=_config.yml,_config_stage.yml

firebase hosting:channel:deploy ${STAGE_NAME} \

--project ${FIREBASE_ALIAS} \

--token ${FIREBASE_TOKEN}

# =================== Utility Commands ==================

# Clean all caches, and test/build files

clean:

rm -rf _site .jekyll* src/.jekyll* *.log tmp example.g .dart_tool

# Helpful to reinstall all Ruby packages from inside container

reinstall:

rm -f Gemfile.lock

bundle install --redownload

# Purge all running containers and remove the image

purge:

docker-compose down

docker rm -f $(docker ps -aq)

docker rmi flt-dev