roro 0.3.17 → 0.3.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4ff432672046f38d4adb0214e9c5125be36183f2
-  data.tar.gz: 5559ed50720181a77d4af026cd3b0b8bff90b674
+SHA256:
+  metadata.gz: c3367a0100cab60651928187b96db25f1a4ecaecca166afde2621e0fd09f4b17
+  data.tar.gz: 851e7f8fe51e02c206a506350d353a3f4663265d7568c61dc359c394ae5599f9
 SHA512:
-  metadata.gz: 44d46961f02e97b9d21ee5c7e76f2e4d1708824c3bb50dbb24291bdc3f3c9fa64c4c2ffeb70ff235c685898e4224bc6ba558f51a6158a68888f63d2be904bb77
-  data.tar.gz: 2b3d2e7129581279a7bca13f36a3a1287e06041b8ba1e2880251ca4aa65217cd47947c31d511509b724bf5d64119a31c47da1cb7afc82165922bc126322a31f9
+  metadata.gz: 4326d8ca1ec1a6bbd16a48403bf2f754799c46b29a83043d2b1d04c7165ba46073ebd0d8f4092ce0b8a8ea1476962ffeea4a260bd98b0808ce73820abe85017e
+  data.tar.gz: 5b7a70514ba7174f5a68dc07accf606374a20f441d7a76f46c728bc602e6b2f3a49bbc40c8e713b907d2f3fb7816e95d255a27abc12ac9f708da00a536765fff

data/.circleci/config.yml

@@ -1,92 +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
-
-defaults: &defaults
-  executor: machine-executor
-  working_directory: ~/project
- 
 version: 2.1
 
 executors:
-  machine-executor: 
-    machine: true
-  ruby-executor: 
+  ruby-executor:
     docker:
       - image: cimg/ruby:2.7
-      
-jobs:
+  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: ruby
 
+major_only: &major_only
+  filters:
+    branches:
+      only: master
+
+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: 
+  matrix-test-rollon:
+    jobs:
+      - test-rollon:
+          <<: *major_only
+          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
-      - test-rollon-rails: 
-          filters: 
-            branches: 
-              only: development
-      - test:
-          filters: 
-            branches: 
-              only: master
-      
       - release:
-          requires: 
+          requires:
             - build
-          filters: 
-            branches: 
-              only: release
+          <<: *release

data/.gitignore

@@ -10,15 +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
+!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,17 +1,27 @@
-options = {
-  all_on_start: true,
-  all_after_pass: true, 
-}
+# 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{^lib/roro/(.+)\.rb$}) { |m| "test/#{m[1]}_test.rb" }
-  watch(%r{^test/thor_helper\.rb$})      { 'test' }
-  watch(%r{^lib/roro/cli/(.+)\.rb$}) { |m| "test/cli/#{m[1]}_test.rb" }
-  watch(%r{^lib/roro/cli/templates/base(.+)\.yml$}) { |m| "test/cli" }
-  watch(%r{^lib/roro/cli/templates/rollon(.+)\.yml$}) { |m| "test/cli/rollon" }
-  watch(%r{^lib/roro/cli/templates/rollon(.+)\.tt$}) { |m| "test/cli/rollon" }
-  watch(%r{^lib/roro/cli/templates/greenfield(.+)\.yml$}) { |m| "test/cli/greenfield" }
-  watch(%r{^lib/roro/cli/templates/greenfield(.+)\.tt$}) { |m| "test/cli/greenfield" }
+  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):
@@ -217,4 +216,5 @@ $ docker system prune -af --volumes
 This gem and its associated practices are just one way of using these tools and not the canonical way. My purpose in publishing it is to get a conversation started about what conventions around these tools might look like. If you have ideas on how to make it better please put in an issue -- or fork the repo, make your changes, write your tests, and send me a pull request. It'll make me feel warm inside.    
 
 ## License
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

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

data/lib/roro/cli/rollon.rb

@@ -1,20 +1,20 @@
 module Roro
   class CLI < Thor
-        
-    no_commands do
-     
-      def configure_for_rollon
-        confirm_dependencies
-        @config ||= Roro::Configuration.new(options) 
-      end
-      
-      def yaml_from_template(file)
-        File.read(File.dirname(__FILE__) + "/templates/#{file}")
-      end
-      
-      def take_thor_actions 
-        @config.thor_actions.each {|k, v| eval(k) if v.eql?('y') }  
-      end
+
+    desc 'rollon', 'Roll a fresh development story into the current directory.'
+    map 'rollon' => 'rollon'
+
+    def rollon
+      configurator = Roro::Configurators::Configurator.new
+      configurator.rollon
+    end
+
+    desc 'log itineraries', 'logs all possible itineraries in specified location'
+    map 'log_itineraries' => 'log_itineraries'
+
+    def log_itineraries(location = 'test/fixtures/itineraries')
+      builder = Roro::Configurators::AdventureCaseBuilder.new
+      builder.log_itineraries('test/fixtures/itineraries')
     end
   end
-end
+end