roro 0.3.22 → 0.3.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d21bacda1161bc7f1cb8b57ebbca68cbe4f9647c2d02b33464c6a162f3661d31
-  data.tar.gz: d40e7d418705dd50e38e8d5a6f337d313f8cae3fadb1a37a7114c504cd8bbb46
+  metadata.gz: c3367a0100cab60651928187b96db25f1a4ecaecca166afde2621e0fd09f4b17
+  data.tar.gz: 851e7f8fe51e02c206a506350d353a3f4663265d7568c61dc359c394ae5599f9
 SHA512:
-  metadata.gz: af1f1072843ad1d6919afd41398c31ae7357a9d492bb8e811a3d9da825bef9eb1def20a5577f059655b22eceac1bc387b0760f710a257412202a61f6497d8818
-  data.tar.gz: ed48d94a0902e9123e4790b44d77249ddee40e4d122524fcfe5afe92a661ebc3903ff96cc75210e85e200eb66388033d824934b6675b976ca543aa39981ac2f5
+  metadata.gz: 4326d8ca1ec1a6bbd16a48403bf2f754799c46b29a83043d2b1d04c7165ba46073ebd0d8f4092ce0b8a8ea1476962ffeea4a260bd98b0808ce73820abe85017e
+  data.tar.gz: 5b7a70514ba7174f5a68dc07accf606374a20f441d7a76f46c728bc602e6b2f3a49bbc40c8e713b907d2f3fb7816e95d255a27abc12ac9f708da00a536765fff

data/.circleci/config.yml

@@ -1,15 +1,26 @@
-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:
@@ -20,80 +31,100 @@ release: &release
   filters:
     branches:
       only: release
-      
-      
-version: 2.1
 
-executors:
-  machine-executor: 
-    machine: true
-  ruby-executor: 
-    docker:
-      - image: cimg/ruby:2.7
-      
-jobs:
+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: 
-          <<: *major_only
-          <<: *release
-      - 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
-          <<: *release
+          <<: *release

data/.gitignore

@@ -10,18 +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
 
-.idea
+# 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,17 +1,27 @@
-options = {
-  all_on_start: true,
-  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/(.+)\.rb$})              { "test/crypto_test.rb" }
-  # watch(%r{^lib/(.+)\.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

@@ -1,18 +1,11 @@
 module Roro
   class CLI < Thor
-    
-    desc "generate::exposed", "Decrypts .env.enc files for all environments or those specified."
-    map "generate::exposed" => "generate_exposed"
+    desc "generate:exposed", "Decrypts .smart.env.enc files for all environments or those specified."
+    map "generate:exposed"  => "generate_exposed"
 
-    
     def generate_exposed(*environments)
-      Roro::Crypto.expose(environments, './roro', '.env.enc')
+      exposer = Roro::Crypto::Exposer.new
+      exposer.expose(environments, Roro::CLI.mise, '.env.enc')
     end
-    # def generate_exposed(*args) 
-    #   environments = args.first ? [args.first] : gather_environments
-    #   environments.each do |environment|
-    #     Roro::Crypto.expose(environment, 'roro')
-    #   end
-    # end
   end
 end

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

@@ -1,14 +1,15 @@
-module Roro
+# frozen_string_literal: true
 
+module Roro
   class CLI < Thor
-    map "generate::key" => "generate_keys"
-    method_option :environment, type: :hash, default: {}, desc: "Generates a key for each argument.", banner: "development, staging"
+    desc 'generate:keys', 'Generates a key for each <environment>.smart.env file.'
 
-    desc "generate::keys", "Generates a key for each <environment>.env file."
-    map "generate::keys" => "generate_keys"
+    map 'generate:keys'  => 'generate_keys'
+    map 'generate:key'   => 'generate_keys'
 
     def generate_keys(*environments)
-      Roro::Crypto.generate_keys(environments, './roro', '.env')
+      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

@@ -1,34 +1,14 @@
-require 'roro/crypto'
+# frozen_string_literal: true
 
 module Roro
-
   class CLI < Thor
 
-    desc "generate::obfuscated", "Encrypts .env files for safe storage."
-    map "generate::obfuscated" => "generate_obfuscated"
+    desc 'generate:obfuscated', 'Encrypts .smart.env files for safe storage.'
+    map 'generate:obfuscated'  => 'generate_obfuscated'
 
     def generate_obfuscated(*environments)
-      Roro::Crypto.obfuscate(environments, './roro', '.env')
-    end
-
-    no_commands do
-
-      def check_for_obfuscatable(environments)
-        if environments.empty?
-          msg = "No .env files matching the
-          pattern roro/**/*.env'. Please create one."
-          raise Roro::Error.new(msg)
-        end
-      end
-
-      def check_for_keys(environments)
-        environments.each do |e|
-          unless File.exist?("roro/keys/#{e}.key")
-            msg = "No #{e} key file at roro/keys/{e}.key. Please generate one."
-            raise Roro::Error.new(msg)
-          end
-        end
-      end
+      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