roro 0.3.18 → 0.3.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 28419719167db581fa026244d2628fa4c86c9d3b
-  data.tar.gz: b46403289b09d42a550ac9dff3a4edcc717f2c63
+SHA256:
+  metadata.gz: 041c08174ce7ef8801ff96de5579a5af5475ccea54855a34352ca85a820b95be
+  data.tar.gz: 7f2bbabd5f24a2e1410dbb24d961cbea46bd7cf79ab1629c6f7109b108868f93
 SHA512:
-  metadata.gz: 3b2075ccae46a264f2d64bf2d2c09fb678bf95a44d534b0263dcb2a9e5cbf6345663d683bea3219ec728512e65eca391e1715a7334d304d4e46411a3e75f6ec1
-  data.tar.gz: 5ef3392e89e8e72af5e190a79f45ff7e107db744c0fe2a886b6e0e11bf6829c0fc723c6e298c0ad51d20a7b4882dbd84035b3b966a2eabdf5484e4c32827ae28
+  metadata.gz: 3c9ecbf3a06d7146e01913113af6d3e83393de5cf5ac2b7dcd840ecaf9c16e4fe5f75609916b1f43b0cab7f2321f038ab457be6d8843bd39c756aa6fe6db0868
+  data.tar.gz: 6c112af32e6b2693a87a1888455796a6883941057f64ef0ce16d43b978a39fae10f251451701e95995833077fef60b5eed467fa2cd836fd78c33ef39cfe55d8d

data/.circleci/config.yml

@@ -1,93 +1,130 @@
-aliases:
-  - &workspace-location
-    at: /tmp/workspace
-  - &copy-ci-dotenv | 
-    cp -rf /tmp/workspace/roro .
-  - &source-ci-variables | 
-    echo 'source roro/containers/app/ci.env' >> $BASH_ENV
-    source $BASH_ENV
+version: 2.1
+
+executors:
+  ruby-executor:
+    docker:
+      - image: cimg/ruby:2.7
+  linux:
+    docker:
+      - image: cimg/ruby:2.7
+  mac:
+    macos:
+      xcode: 11.4
+  ruby:
+    parameters:
+      version:
+        description: "version tag"
+        default: "2.5"
+        type: string
+    docker:
+      - image: cimg/ruby:<<parameters.version>>
 
 defaults: &defaults
-  executor: machine-executor
-  working_directory: ~/project
+  executor: ruby
 
 major_only: &major_only
   filters:
     branches:
-      only: master, release
- 
-version: 2.1
+      only: master
 
-executors:
-  machine-executor: 
-    machine: true
-  ruby-executor: 
-    docker:
-      - image: cimg/ruby:2.7
-      
-jobs:
+release: &release
+  filters:
+    branches:
+      only: release
+
+commands:
+  run-test-case:
+    parameters:
+      answers:
+        type: string
+        default: "1\n2"
+      os:
+        type: executor
+    steps:
+      - run: |
+          rake install &&
+          printf "<< parameters.answers >>\ny\ny\ny\ny\ny\ny\ny$var\n" | roro rollon
+      - run: echo 'success'
 
+jobs:
   build:
     <<: *defaults
     steps:
       - checkout
-  
-  test-rollon-rails: 
-    executor: ruby-executor
-    steps: 
-      - checkout 
+
+  test-against-ruby:
+    parameters:
+      version:
+        description: "version tag"
+        default: "3.0"
+        type: string
+    executor:
+      name: ruby
+      version: <<parameters.version>>
+    steps:
+      - checkout
+      - run: gem install bundler
+      - run: bundle
+      - run: bundle exec rake test
+
+  test-rollon:
+    parameters:
+      answers:
+        type: string
+        default: "1\n4"
+      os:
+        type: executor
+        default: linux
+    executor: << parameters.os >>
+    steps:
+      - checkout
       - setup_remote_docker:
           version: 19.03.12
       - run: |
-          rake install 
-          mkdir greenfield
-          cd greenfield
-          (yes || true) | roro greenfield
+          rake install &&
+          printf "<< parameters.answers >>\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny$var\n" | roro rollon
       - run: echo 'success'
-  
-  test:
-    <<: *defaults
-    steps:
-      - checkout
-      - run: RUBY_VERSION=2.5 docker-compose build ruby_gem
-      - run: RUBY_VERSION=2.5 docker-compose up -d --force-recreate ruby_gem
-      - run: RUBY_VERSION=2.5 docker-compose run ruby_gem bundle exec rake test
-      - run: RUBY_VERSION=2.6 docker-compose build ruby_gem
-      - run: RUBY_VERSION=2.6 docker-compose up -d --force-recreate ruby_gem
-      - run: RUBY_VERSION=2.6 docker-compose run ruby_gem bundle exec rake test
-      - run: RUBY_VERSION=2.7 docker-compose build ruby_gem
-      - run: RUBY_VERSION=2.7 docker-compose up -d --force-recreate ruby_gem
-      - run: RUBY_VERSION=2.7 docker-compose run ruby_gem bundle exec rake test    
-      
+
   release:
     <<: *defaults
     steps:
       - checkout
-      - run: gem install roro
-      - run: roro generate::exposed ci
-      - run: | 
-          echo $(cat ./roro/containers/ruby_image/ci.env) >> $BASH_ENV
-          source $BASH_ENV
-      - run: chmod +x ./.circleci/setup-gem-credentials.sh
-      - run: ./.circleci/setup-gem-credentials.sh
-      - run: chmod 0600 ~/.gem/credentials
-      - run: git checkout .
-      - run: gem release
-  
+      - run: rake install
+      - run: |
+          export CI_KEY="Bx2LCiZo7Gedfz1OV9vh3w=="
+          roro generate:exposed ci
+#      - run: |
+#          echo $(cat ./mise/containers/ruby_image/env/ci.env) >> $BASH_ENV
+#          source $BASH_ENV
+#      - run: echo $RUBYGEMS_API_KEY
+#      - run: chmod +x ./.circleci/setup-gem-credentials.sh
+#      - run: ./.circleci/setup-gem-credentials.sh
+#      - run: chmod 0600 ./.gem/credentials
+#      - run: git checkout .
+#      - run: gem release
+
 workflows:
-  version: 2
-    
-  build-cli: 
-    jobs: 
-      - build 
-      - test-rollon-rails: 
+  matrix-test-rollon:
+    jobs:
+      - test-rollon:
           <<: *major_only
-      - test:
+          matrix:
+            parameters:
+              answers: ["1\n1", "1\n2", "1\n3", "1\n4", "1\n5", "2\n1", "3\n1", "3\n2"]
+              os: [linux]
+
+  matrix-test-against-rubies:
+    jobs:
+      - test-against-ruby:
           <<: *major_only
-      
+          matrix:
+            parameters:
+              version: [ "2.5", "2.6", "2.7", "3.0" ]
+
+  gem-release:
+    jobs:
+      - build
       - release:
-          requires: 
+          requires:
             - build
-          filters:
-            branches:
-              only: release      
+          <<: *release

data/.gitignore

@@ -10,16 +10,42 @@ Gemfile.lock
 
 roro/**/*.env
 roro/**/*.key
-
 *.key
 *.env
+!/lib/roro/stacks/**/*.key
+!/lib/roro/stacks/**/*.env
+!test/**/*.key
+!test/**/*.env
 !/.gitignore
 *.gem
 tmp/*
-!tmp/.keep 
-sandbox/*
-!sandbox/.keep 
-!sandbox/greenfield
-sandbox/greenfield/*
-!sandbox/greenfield/.keep
-TUTORIAL.md
+!tmp/.keep
+TUTORIAL.md
+
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.7.2

data/Gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+# git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in roro.gemspec
 gemspec

data/Guardfile

@@ -1,15 +1,27 @@
-options = {
-  all_on_start: false,
-  all_after_pass: false, 
-}
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
 
-guard :minitest, options do
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest, test_folders: ['test', 'lib/roro/stacks'] do
+  # with Minitest::Unit
+  watch(%r{^lib/roro/stacks/(.*)\/?(.*)_test\.rb$})
+  watch(%r{^lib/roro/stacks/(.*/)?([^/]+)\.yml$})      { |m| "lib/roro/stacks/#{m[1]}test" }
+  watch(%r{^lib/roro/stacks/(.*/)?templates/(.*)$}) { |m| "lib/roro/stacks/#{m[1]}test" }
 
   watch(%r{^test/(.*)\/?(.*)_test\.rb$})
-  watch(%r{^test/helpers/(.*)\.rb$})          { 'test' }
-  watch(%r{^test/test_helper\.rb$})           { 'test' }
-  watch(%r{^lib/roro/(.+)\.rb$})              { |m| "test/#{m[1]}_test.rb" }
-  watch(%r{^lib/roro/cli/(.+)\.rb$})          { |m| "test/cli/#{m[1]}_test.rb" }
-  watch(%r{^lib/roro/cli/(.+)\.yml$})         { |m| "test/cli" }
-  watch(%r{^lib/roro/cli/(.+)\.tt$})          { |m| "test/cli" }
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}#{m[2]}_test.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
 end

data/README.md

@@ -1,12 +1,11 @@
 # RoRo
 
-RoRo is a containerization and continuous integration framework for Ruby applications. Like Rails, it favors convention over configuration. It aims to provide everything you need to:
+RoRo is a set of tools and stories for building, running continuous integration tests on, and deploying your containerized projects. It aims to provide everything you need to:
 
-1. Greenfield a Rails app in its own container that can talk to a separate Postgresql container.
-2. Containerize your existing application and database in development.
-3. Run your tests with Guard in a separate container.
-4. Roll your containers onto CircleCI for testing.
-5. Roll your containers off of CircleCI to your servers.
+1. Greenfield a new project with a containerized app and database and other containers you might need.
+2. Containerize your project's existing application, database, and services.
+3. Roll your project into ci/cd.
+4. Roll your project onto production servers with kubernetes.
 
 ## Getting started
 
@@ -25,10 +24,10 @@ Commands:
   roro expose          # Expose encrypted files
   roro generate_key    # Generate a key for each environment
   roro generate_keys   # Generates keys for all environments. If you have .en...
-  roro greenfield      # Greenfield a brand new rails app using Docker's inst...
+  roro omakase      # Greenfield a brand new rails backend using Docker's inst...
   roro help [COMMAND]  # Describe available commands or one specific command
   roro obfuscate       # obfuscates any files matching the pattern ./docker/*...
-  roro rollon          # Generates files necessary to greenfield a new app wi...
+  roro rollon          # Generates files necessary to omakase a new backend wi...
   roro ruby_gem        # Generate files for containerized gem testing, Circle...
 ```
 
@@ -56,7 +55,7 @@ docker-compose version 1.21.0, build 5920eb0
 ```bash
 $ mkdir -p handsome_app
 $ cd handsome_app
-$ roro greenfield
+$ roro omakase
 ```
 
 It'll take a few minutes for Docker to download your images, copy your files, and build your application but once finished, you'll see the Rails welcome screen at [http://localhost:3000](http://localhost:3000/). 
@@ -95,7 +94,7 @@ As with greenfielding above, wait a few minutes, and when it's finished, open [h
 From another terminal: 
 
 ```bash
-$ docker-compose exec app bundle exec guard
+$ docker-compose exec backend bundle exec guard
 ```
 
 To use LiveReoload with Guard, install the Chrome [extension](https://chrome.google.com/webstore/detail/livereload/jnihajbhpnppcggbcgedagnkighmdlei?hl=en):

data/bin/console

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/smart.env ruby
 
 require "bundler/setup"
 require "roro"

data/bin/setup

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/smart.env bash
 set -euo pipefail
 IFS=$'\n\t'
 set -vx

data/docker-compose.yml

@@ -5,11 +5,11 @@ services:
   ruby_gem:
     build:
       context: .
-      dockerfile: roro/containers/ruby_image/Dockerfile
-    environment:
-      - RUBY_VERSION=${RUBY_VERSION}
+      dockerfile: mise/containers/ruby_gem/Dockerfile
     volumes:
       - gem_cache:/gems
+    environment:
+      RUBY_VERSION: '2.5'
 
 volumes:
   gem_cache:

data/lib/roro/cli/generate/generate.rb

@@ -1 +1,52 @@
-require_relative 'config/rails'
+# frozen_string_literal: true
+
+module Roro
+  class CLI < Thor
+    method_option :environments,
+                 type: :array,
+                 aliases: :e,
+                 banner: 'one, two, three',
+                 desc: 'The environments to generate:',
+                 default: %w[base ci development production]
+
+    method_option :containers,
+                 type: :array,
+                 aliases: :c,
+                 banner: 'container_one, container_two, container_three',
+                 default: %w[backend database frontend],
+                 desc: 'The containers to generate:'
+
+    method_option :mise_en_place,
+                 type: :string,
+                 aliases: :m,
+                 default: 'mise',
+                 desc: "The name of your mise en place folder. This is where your container folders, environment files, scripts, and keys will live"
+
+    method_option :keys,
+                 type: :array,
+                 aliases: :k,
+                 banner: 'one.key two.key three.key',
+                 default: %w[base ci development production],
+                 desc: 'The names of your keys to generate. If none supplied, Roro will infer them from your .env files:'
+
+    desc 'generate', 'Generate stuff.'
+    map 'generate'  => 'generate'
+
+    def generate
+      order = %w[mise_en_place containers environments keys]
+      order.each do |item|
+        value = options[item]
+        case item
+        when 'mise_en_place'
+          generate_mise(value)
+        when 'containers'
+          generate_containers(*value)
+        when 'environments'
+          generate_environments(*value)
+        when 'keys'
+          generate_keys(*value)
+        end
+      end
+    end
+  end
+end

data/lib/roro/cli/generate/generate_containers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Roro
+  # Where all the generation, configuration, greenfielding happens.
+  class CLI < Thor
+    desc 'generate:containers', 'Generate containers.'
+    map 'generate:containers' => 'generate_containers'
+    method_options :containers => :array
+    def generate_containers(*containers)
+      mise = Roro::CLI.mise
+      containers = options['containers'] || containers.empty? ? %w[frontend backend database] : containers
+      # siblings = Dir.glob('./*').select do |f|
+      #   File.directory?(f)
+      #   !f.match?(mise)
+      # end
+      # siblings = options[:containers] ? options[:containers] : default_containers
+      containers.each { |s| s.split('/').last }.each do |container|
+        create_file("#{mise}/containers/#{container}/scripts/.keep")
+        create_file("#{mise}/containers/#{container}/env/.keep")
+      end
+    end
+  end
+end

data/lib/roro/cli/generate/generate_environments.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Roro
+  class CLI < Thor
+    desc 'generate:environments', 'Generate environment files and keys'
+    map 'generate:environments'  => 'generate_environments'
+
+    def generate_environments(*args)
+      if args.last.is_a?(Hash)
+        hash = args.pop
+      end
+      default_environments = Roro::CLI.roro_environments
+      mise = Roro::CLI.mise
+      environments = args.empty? ? default_environments : args
+      containers = Dir.glob("./#{mise}/containers/*").select { |f| File.directory?(f) }
+      environments.each do |env|
+        content = hash&.dig(env.to_sym)&.each&.map {|k,v| "#{k}=#{v[:value]}"}&.join("\n") || 'SOME_KEY=some_value'
+        create_file "./#{mise}/env/#{env}.env", content
+        containers.each do |container|
+          create_file "#{container}/env/#{env}.env", content
+        end
+      end
+    end
+  end
+end

data/lib/roro/cli/generate/generate_exposed.rb

@@ -0,0 +1,11 @@
+module Roro
+  class CLI < Thor
+    desc "generate:exposed", "Decrypts .smart.env.enc files for all environments or those specified."
+    map "generate:exposed"  => "generate_exposed"
+
+    def generate_exposed(*environments)
+      exposer = Roro::Crypto::Exposer.new
+      exposer.expose(environments, Roro::CLI.mise, '.env.enc')
+    end
+  end
+end

data/lib/roro/cli/generate/generate_keys.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Roro
+  class CLI < Thor
+    desc 'generate:keys', 'Generates a key for each <environment>.smart.env file.'
+
+    map 'generate:keys'  => 'generate_keys'
+    map 'generate:key'   => 'generate_keys'
+
+    def generate_keys(*environments)
+      key_writer = Roro::Crypto::KeyWriter.new
+      key_writer.write_keyfiles(environments.uniq)
+    end
+  end
+end

data/lib/roro/cli/generate/generate_mise.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Roro
+  class CLI < Thor
+
+    desc 'generate:mise MISE', 'Generate mise en place.'
+    map 'generate:mise'  => 'generate_mise'
+
+    def generate_mise(mise_name = 'mise')
+      create_file "#{mise_name}/#{mise_name}.roro"
+    end
+  end
+end

data/lib/roro/cli/generate/generate_obfuscated.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Roro
+  class CLI < Thor
+
+    desc 'generate:obfuscated', 'Encrypts .smart.env files for safe storage.'
+    map 'generate:obfuscated'  => 'generate_obfuscated'
+
+    def generate_obfuscated(*environments)
+      obfuscator = Roro::Crypto::Obfuscator.new
+      obfuscator.obfuscate(environments, Roro::CLI.mise, '.env')
+    end
+  end
+end

data/lib/roro/cli/roll_your_own.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Roro
+  class CLI < Thor
+    desc 'roll_your_own', 'Generate mise en place'
+    map 'roll_your_own'  => 'roll_your_own'
+
+    def roll_your_own(stack_path = nil)
+
+    end
+  end
+end