rumrunner 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ead63f96d28a203a6138bad38b5d2a03287807e5d155036493c43e6d3d939333
-  data.tar.gz: a785198de4a88a50d0aa33d05b5fd0a45dfd8aed6c5451d95b4ce021c4993a61
+  metadata.gz: f5b49cf24f5e8eec6a07671a76471effb1cdaa8d81cce8dfc620a1f1c6944417
+  data.tar.gz: 788ce31f54f4d12d03f426ef9533a500d3835e21679782254b3f3ddbb4b8e2cb
 SHA512:
-  metadata.gz: 7ec0fca40235a7b3c6c412d50a86c53f7b3c696de800a899edca238ec4ad769aa4466e1457a60216616ce8cbdc5cf5f9e325981332f0d3a895ddcb056d2134a5
-  data.tar.gz: 9f8a97f043c8b9defd0d97ed3600887901ef80338c51dc2c3b80066b888eafc1a01e24757562a07e4b2c85bd03762530fd99fc556ca8934954c1db6db62749d4
+  metadata.gz: a3a48aee02ab98cfcfe482ee499feaab801e8d63031a27cb67924ffe6336228601e0b7a9959ff318aff48f0659c86b6fd2c1935acb4b22f5db9344a286c6b8fa
+  data.tar.gz: e5fd024b58c08d18f4077e5e43d922f26a46b3fca2822598ee9f1e73ee73675f5dd608cfc898855ec7e8fbb92d0ec2cf26e181292bc9dc5dd4e44a41d252d7e2

data/lib/rumrunner/application.rb

@@ -31,10 +31,14 @@ module Rum
       super "rum", argv
     end
 
+    ##
+    # Return true if any of the default Rumfiles exist
     def rumfile?
       DEFAULT_RAKEFILES.map{|x| File.size? x }.any?
     end
 
+    ##
+    # Run application
     def run(argv = ARGV)
       if argv.first == "init" && !rumfile?
         Rum.init

data/lib/rumrunner/manifest.rb

@@ -269,8 +269,8 @@ module Rum
       desc "Build `#{name}`"
       file name => deps do
         digest = File.read(iidfile)
-        run = Docker::Run.new(options: run_options, image: digest, cmd: ["cat", name], &block)
-        run.with_defaults(rm: true)
+        run = Docker::Run.new(options: run_options, image: digest, cmd: [name], &block)
+        run.with_defaults(rm: true, entrypoint: "cat")
         sh "#{run} > #{name}"
       end
     end

data/lib/rumrunner/version.rb

@@ -1,5 +1,5 @@
 module Rum
   ##
   # Rum Runner gem version.
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumrunner
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Alexander Mancevice
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-13 00:00:00.000000000 Z
+date: 2019-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -118,8 +118,6 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE
-- README.md
 - bin/rum
 - lib/rumrunner.rb
 - lib/rumrunner/application.rb
@@ -147,8 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Rum Runner is a Rake-based utility for building projects with multi-stage

data/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Alexander Mancevice
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/README.md

@@ -1,320 +0,0 @@
-[![Rum Runner](https://github.com/amancevice/rumrunner/blob/master/rum-runner.png?raw=true)](https://github.com/amancevice/rumrunner)
-[![Build Status](https://travis-ci.com/amancevice/rumrunner.svg?branch=master)](https://travis-ci.com/amancevice/rumrunner)
-[![Gem Version](https://badge.fury.io/rb/rumrunner.svg)](https://badge.fury.io/rb/rumrunner)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/4b56853acc5cbb254125/test_coverage)](https://codeclimate.com/github/amancevice/rumrunner/test_coverage)
-[![Maintainability](https://api.codeclimate.com/v1/badges/4b56853acc5cbb254125/maintainability)](https://codeclimate.com/github/amancevice/rumrunner/maintainability)
-
-<sub>logo by [seenamavaddat.com](http://seenamavaddat.com/)</sub>
-
-Rum Runner is a Rake-based utility for building multi-stage Dockerfiles.
-
-Users can pair a multi-stage Dockerfile with a Rumfile that uses a Rake-like DSL to customize each stage's build options and dependencies.
-
-The `rum` executable allows users to easily invoke builds, shell-into specific stages for debugging, and export artifacts from built containers.
-
-Rum Runner has the following features:
-* Fully compatible with Rake
-* Rake-like DSL/CLI that enable simple annotation and execution of builds
-* Rumfiles are completely defined in standard Ruby syntax, like Rakefiles
-* Users can chain Docker build stages with prerequisites
-* Artifacts can be exported from stages
-* Shell tasks are automatically provided for every stage
-* Stage, artifact, and shell, steps can be customized
-
-**Origins**
-
-This project was born from using Makefiles to drive multi-stage builds. For the most part this worked really well, but it became a bit of an ordeal to write for more complex projects. This tool is an attempt to recreate that general technique with minimal annotation and limited assumptions.
-
-View the docs on [rubydoc.info](https://www.rubydoc.info/github/amancevice/rumrunner)
-
-## Installation
-
-```bash
-gem install rumrunner
-```
-
-## Quickstart
-
-If you have a multi-stage Dockerfile in your project and are unsure where to begin, use the `rum init` helper to create a template Rumfile for your project:
-
-```bash
-gem install rumrunner
-rum init > Rumfile
-rum --tasks
-```
-
-The `init` command will parse a Dockerfile in the current directory and output a simple Rumfile with each stage and its dependencies declared.
-
-## Example
-
-Imagine a simple multi-stage Dockerfile:
-
-```Dockerfile
-FROM ruby AS build
-# Run build steps here...
-
-FROM ruby AS test
-# Run test steps here...
-
-FROM ruby AS deploy
-# Run deploy steps here...
-```
-
-Create `Rumfile` and describe your build:
-
-```ruby
-rum :image_name do
-  tag "1.2.3"
-
-  stage :build
-  stage :test => :build
-  stage :deploy => :test
-
-  # rum build  => docker build --target build  --tag image_name:1.2.3-build .
-  # rum test   => docker build --target test   --tag image_name:1.2.3-test .
-  # rum deploy => docker build --target deploy --tag image_name:1.2.3-deploy .
-end
-```
-
-Run `rum --tasks` to view the installed tasks:
-
-```bash
-rum build                # Build `build` stage
-rum clean                # Remove any temporary images and products
-rum clean:build          # Remove any temporary images and products through `build` stage
-rum clean:deploy         # Remove any temporary images and products through `deploy` stage
-rum clean:test           # Remove any temporary images and products through `test` stage
-rum clobber              # Remove any generated files
-rum deploy               # Build `deploy` stage
-rum shell:build[shell]   # Shell into `build` stage
-rum shell:deploy[shell]  # Shell into `deploy` stage
-rum shell:test[shell]    # Shell into `test` stage
-rum test                 # Build `test` stage
-```
-
-## Customize Shells
-
-By default, all stages have a `:shell` task that can be invoked to build and shell into a container for a stage. By default the container is run as an ephemeral container (`--rm`) in interactive with TTY allocated and a bash shell open.
-
-Customize the shell for a stage with the `shell` method:
-
-```ruby
-rum :image_name do
-  stage :dev
-
-  shell :dev do
-    entrypoint "/bin/zsh"
-    rm         false
-    volume     "#{Dir.pwd}:/var/task/"
-  end
-
-  # rum dev => docker run --entrypoint /bin/zsh --volume $PWD:/var/task/ ...
-end
-```
-
-## Customize Stages
-
-Stages can be customized with blocks:
-
-```ruby
-rum :image_name do
-  tag "1.2.3"
-
-  stage :build
-
-  stage :test => :build
-
-  stage :deploy => :test do
-    build_arg :AWS_ACCESS_KEY_ID
-    build_arg :AWS_SECRET_ACCESS_KEY
-    build_arg :AWS_DEFAULT_REGION => "us-east-1"
-    label     :Fizz
-  end
-end
-```
-
-Methods invoked inside the stage block are interpreted as options for the eventual `docker build` command.
-
-## Export Artifacts
-
-Use the `artifact` method to specify an artifact to be exported from the image.
-
-```ruby
-rum :image_name do
-  stage :build
-
-  artifact "package.zip" => :build
-end
-```
-
-By default the container simply `cat`s the file from the container to the local file system, but more complex exports can be defined:
-
-```ruby
-rum :image_name do
-  stage :build
-
-  artifact "package.zip" => :build do
-    workdir "/var/task/"
-    cmd     %w[zip -r - .]
-  end
-end
-```
-
-Methods invoked inside the artifact block are interpreted as options for the eventual `docker run` command.
-
-## Default Task
-
-Use the `default` method to set a default task when running the bare `rum` executable:
-
-```ruby
-rum :image_name do
-  stage :build
-
-  artifact "package.zip" => :build
-
-  default "package.zip"
-end
-```
-## Shared ENV variables
-
-The `env` method can be invoked in the `rum` block to declare a value that will be passed to all stages/artifacts/shells. For stages, the value will be passed using the `--build-arg` option; for artifacts and shells, the `--env` option.
-
-```ruby
-rum :image_name do
-  env :FIZZ => :BUZZ
-
-  stage :build
-
-  # rum build => docker build --build-arg FIZZ=BUZZ ...
-end
-```
-
-## Shells
-
-Run a stage task to build the image up to that stage and cache the image digest.
-
-Run with the `:shell` suffix to build the image and then shell into an instance of the image running as a temporary container.
-
-The default shell is `/bin/sh`, but this can be overridden at runtime with the task arg, eg. `rum build:shell[/bin/bash]`
-
-## Build vs. Run
-
-At the core, every directive within the `rum` block will eventually be interpreted as either a `docker build` or a `docker run` command. The type of directive is simply a way of specifying defaults for the command.
-
-If you simply wish to define a named task that executes a build or a run, you can use the `build` or `run` directives:
-
-```ruby
-rum :image_name do
-  env :JAZZ => "fuzz"
-
-  build :fizz do
-    tag  "image_name"
-    path "."
-  end
-
-  run :buzz do
-    rm    true
-    image "image_name"
-    cmd   %w{echo hello}
-  end
-
-  # rum fizz => docker build --build-arg JAZZ=fuzz --tag image_name .
-  # rum buzz => docker run --rm --env JAZZ=fuzz image_name echo hello
-end
-```
-
-Note that the build/run commands will still import any shared ENV values defined above.
-
-If this is undesirable, use the `clear_options` method inside your block to clear ALL the default options:
-
-```ruby
-rum :image_name do
-
-  env :JAZZ => "fuzz"
-
-  run :buzz do
-    clear_options
-    image "image_name"
-    cmd   %w{echo hello}
-  end
-
-  # rum buzz => docker run image_name echo hello
-end
-```
-
-## Blocks
-
-The methods inside blocks for `build`, `run`, `stage`, `artifact`, and `shell` tasks are dynamically handled. Any option you might pass to the `docker run` or `docker build` command can be used.
-
-Simply drop any leading `-`s from the option and convert to snake-case.
-
-Eg,
-
-`--build-arg` becomes `build_arg`
-
-`--env-file` becomes `env_file`.
-
-## Task Naming Convention
-
-As of v0.3, rum runner uses a "verb-first" naming convention (eg. `clean:stage`) for tasks.
-
-To revert to the previous convention of "stage-first" (eg. `stage:clean`) use the environmental variable `RUM_TASK_NAMES`:
-
-```bash
-export RUM_TASK_NAMES=STAGE_FIRST  # => rum stage:clean
-export RUM_TASK_NAMES=VERB_FIRST   # => rum clean:stage (default)
-```
-
-## Image Naming Convention
-
-The name of the images are taken from the first argument to the main block and appended with the name of the stage.
-
-In the above example, built images would build be named:
-
-- `image_name:1.2.3-build`
-- `image_name:1.2.3-test`
-- `image_name:1.2.3-deploy`
-
-The first argument to the main block can be any Docker image reference:
-
-```ruby
-rum :"registry:5000/username/image" do
-  #...
-end
-```
-
-## Digest Location
-
-Images build with the `stage` task have their digests cached for easy lookup.
-
-The default location for the digests is in `.docker`, but that can be modified:
-
-```ruby
-rum :image_name => "tmp" do
-  # ...
-end
-```
-
-## Integrate with Rake
-
-It isn't strictly necessary to include a `Rumfile` in your project. Rum Runner can be included in any `Rakefile` and run with the `rake` command:
-
-```ruby
-# ./Rakefile
-
-require "rumrunner"
-
-namespace :rum do
-  rum :image_name do
-    stage :build
-    stage :test => :build
-  end
-end
-```
-
-```bash
-$ rake --tasks
-
-rake rum:build # ...
-rake rum:test  # ...
-```