roro 0.3.30 → 0.3.33

data/README.md

@@ -1,40 +1,23 @@
 # RoRo
 
-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:
+RoRo is a CLI that runs best in a container and which you can use to:
 
-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.
+1. Roll your own greenfield app into a container. 
+2. Roll it off your container and onto your dev box. 
+3. Roll it off your dev box and onto source control.
+4. Roll it off source control and onto ci/cd.
+5. Roll it off ci/cd and onto your image repository.
+6. Roll it off your image repository and onto your production servers.
 
-## Getting started
-
-### Install
+You can also use it to safely manage and expose your environment variables in the containers and environmens that need them.
 
-RoRo can be installed
-```bash
-$ gem install roro
-```
+## Demo
 
-Once installed, RoRo provides a CLI:
-
-```bash
-$ roro --help
-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 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 omakase a new backend wi...
-  roro ruby_gem        # Generate files for containerized gem testing, Circle...
-```
-
-However to use RoRo
+[Here you go](https://www.youtube.com/watch?v=-BxJuUQk1XI)
 
+## Getting started
 
-### Docker and Docker Compose 
+### Check your Docker and Docker Compose Dependencies: 
 
 You'll need [Docker](https://docs.docker.com/install/) and [Docker Compose](https://docs.docker.com/compose/install/). To confirm Docker is installed:
 
@@ -50,170 +33,36 @@ $ docker-compose -v
 docker-compose version 1.21.0, build 5920eb0
 ```
 
-### Greenfielding a dockerized app
-
-```bash
-$ mkdir -p handsome_app
-$ cd handsome_app
-$ 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/). 
-
-### Rolling onto an existing app
+### Greenfield a new app:
 
-Whether using your own app or one greenfielded using instructions above, first shut down any running docker containers: 
+1. Most RoRo adventures will copy files from their container and onto your host machine. To avoid making a mess, make a new directory and navigate into it:
 
 ```bash
-$ docker-compose down
+$ mkdir -p greenfield
+$ cd greenfield
 ```
 
-Then, roll RoRo on:
+2. Use the RoRo CLI to generate a greenfield app inside the RoRo container and then copy it onto your development machine: 
 
-```bash
-$ roro rollon
+```shell
+docker run \
+  --name artifact \
+  -v $PWD:/artifact \
+  -v /var/run/docker.sock:/var/run/docker.sock \
+  -u 0 \
+  -it handsomefencer/roro:latest roro rollon
 ```
 
-If your host machine runs a flavor of linux, ensure its logged in user owns the generated files:
+### Note for Linux users
+Once you've rolled your greenfielded app out of the RoRo container and onto your development machine, you'll want to establish ownership of them 
 
 ```bash
 $ sudo chown <username><user group> -R .
 ```
 
-And spin it up:
-
-```bash
-$ docker-compose up --build
-``` 
-
-As with greenfielding above, wait a few minutes, and when it's finished, open [http://localhost:3000/](http://localhost:3000/). 
-
-
-### Guard and tests
-
-From another terminal: 
-
-```bash
-$ 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):
-
-
-## Deployment 
-
-### Securing environment files 
-
-Roro provides conventions for securing sensitive variables between docker containers and environments. To store a variable for use in development, create a file with that variable inside, name it "development.env," and store it in docker/env_files. Here's a one-liner:
-
-```bash 
-$ echo "export EXAMPLE_KEY=example_value" > docker/env_files/development.env
-```
-
-Next, generate a key for the development environment:
-
-```bash 
-$ roro generate_key development
-```
-
-Then encrypt the development.env file using the previously generated development key:
-
-```bash 
-$ roro obfuscate development
-```
-
-You should now have the environment file and its encrypted counterpart: 
-
-```bash 
-$ ls docker/env_files
-development.env  development.env.enc
-```
-
-To see how decryption works, first back up a copy of your development.env file:
-
-```bash 
-$ mv docker/env_files/development.env docker/env_files/backup.env
-```
-
-Then expose its encrypted counterpart:
-
-```bash 
-$ roro expose development
-```
-
-You should now have three files:
-
-```bash 
-$ ls docker/env_files
-backup.env  development.env  development.env.enc 
-```
-
-To verify the newly decrypted file's contents match those of its backup:
-
-```bash 
-$ diff docker/env_files/development.env docker/env_files/backup.env 
-```
-
-## Notes 
-
-### Linux
-
-If you're running linux you may need to change ownership of the newly created files, prepend commands with sudo, or both. To change ownership of newly generated files:
-
-```bash
-$ sudo chown <username><user group> -R .
-```
-
-If that doesn't work, Docker's [documentation](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) should get you pointed in the right direction.
-
-### Troubleshooting 
-
-#### Port in use 
-
-Sometimes you will ge a message saying the port specified in your docker-compose.yml file is already in use. This may be because you have a server running on your host from normal development, or because another Docker container is running a server and piping it to your host. If the former you can shut it down using ctrl^c, and if the latter:
-
-```
-$ docker-compose down 
-``` 
-
-Sometimes shutting down all servers isn't enough because a .pid file remains. You can usually remove it with: 
-
-```bash
-$ rm /tmp/pids/server.pid
-```
-
-If that doesn't work, restart your machine.
-
-#### Mismatched ruby versions 
-
-Sometimes your Gemfile will specify a ruby version which doesn't match the ruby version of the image your container is using. There are three ways to handle this. The first way is to specify an image with the same version of ruby as is in your Gemfile. Open your Dockerfile and change:
-
-```
-FROM ruby:2.5
-```
-to:
-```
-FROM ruby:2.5.x
-```
-...where 2.5.x is the ruby specified in your Gemfile. The second way is to specify the same version of ruby in your app container's image as at the top of your Gemfile:
-
-```ruby 
-ruby '2.5.x'
-``` 
-
-The third way is to remove the ruby specification from your Gemfile, relying on your Dockerfile for ruby version management.
-
-#### Get out of jail
-
-To remove all images, containers, and volumes from your system and start over:
-
-```bash
-$ docker system prune -af --volumes
-```
-
 ## Contributing
 
-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.    
+I can definitely use some help and if you have any thoughts about this, please open an issue. 
 
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,10 +1,42 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'json'
+require 'yaml'
+require 'roro'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+Rake.add_rakelib 'rakelib/ci'
+Rake.add_rakelib 'rakelib/ci/config'
+Rake.add_rakelib 'rakelib/ci/matrices/run'
+Rake.add_rakelib 'rakelib/ci/matrices/test_rollon'
+Rake.add_rakelib 'rakelib/ci/matrices/test_rubies'
+Rake.add_rakelib 'rakelib/ci/prepare/config'
+Rake.add_rakelib 'rakelib/ci/prepare/workflows'
+Rake.add_rakelib 'rakelib/ci/prepare'
+Rake.add_rakelib 'rakelib/ci/test'
+Rake.add_rakelib 'rakelib/ci/jobs'
+Rake.add_rakelib 'rakelib/test'
+Rake.add_rakelib 'rakelib/fixtures'
+Rake.add_rakelib 'rakelib/fixtures/matrixes'
+Rake.add_rakelib 'rakelib/docker/image'
+Rake.add_rakelib 'rakelib/club'
+Rake.add_rakelib 'rakelib/club/harvest'
+
+Rake::TestTask.new('test') do |t|
+  t.libs << 'test'
+  # t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+                 .exclude('test/fixtures/dummies/**/*')
 end
 
-task :default => :test
+# Rake::TestTask.new('test') do |t|
+#   t.libs << "test"
+#   t.libs << "lib"
+#   t.test_files = FileList["./**/*/_test.rb"]
+#                    .exclude('test/fixtures/dummies/test_annotate/**/*')
+# end
+
+# Rake::TestTask.new('test:stacks') do |t|
+#   t.libs << "test"
+#   t.libs << "lib"
+#   t.test_files = FileList["./lib/roro/stacks/**/*_test.rb"]
+# end

data/cases

@@ -0,0 +1 @@
+--- 

data/docker-compose.yml

@@ -1,15 +1,35 @@
-version: '3.2'
+version: '3.5'
 
 services:
 
   ruby_gem:
+    image: handsomefencer/roro
     build:
       context: .
       dockerfile: mise/containers/ruby_gem/Dockerfile
-    volumes:
-      - gem_cache:/gems
     environment:
-      RUBY_VERSION: '2.5'
+      - RUBY_VERSION='2.5'
 
-volumes:
-  gem_cache:
+  dev:
+    build:
+      context: .
+      dockerfile: mise/containers/ruby_gem/Dockerfile
+    working_dir: /usr/src
+    volumes:
+      - .:/usr/src
+
+  roro:
+    build:
+      context: .
+      dockerfile: mise/containers/ruby_gem/Dockerfile
+    image: handsomefencer/roro
+  guard:
+    build:
+      context: .
+      dockerfile: mise/containers/ruby_gem/Dockerfile
+    working_dir: /usr/src
+    volumes:
+      - .:/usr/src
+    environment:
+      - RAILS_ENV=development
+    command: bundle exec guard --no-bundler-warning

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Roro
+  class CLI < Thor
+    desc 'generate:adventure', 'Generate adventure for adventure tests.'
+    map 'generate:adventure' => 'generate_adventure'
+
+    method_options adventure: :string
+
+    def generate_adventure(adventure)
+      @env = { adventure_name: adventure.split('/').last }
+      location = "lib/roro/stacks/#{adventure}"
+      directory 'adventure', location, @env
+      generate_adventure_tests
+    end
+
+    no_commands do
+      def adventure_name
+        @env[:adventure_name]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Roro
+  class CLI < Thor
+    desc 'generate:adventure_tests', 'Generate tests from stacks.'
+    map 'generate:adventure_tests' => 'generate_adventure_tests'
+
+    method_options adventure: :string
+
+    def generate_adventure_tests(kase = nil)
+      reflector = Roro::Configurators::Reflector.new
+      itineraries = reflector.itineraries
+
+      kases = kase ? [kase] : reflector.cases
+      kases.each_with_index do |choice, index|
+        @env = { adventure_title: itineraries[index].join(' & ') }
+        location = "test/roro/stacks/#{choice.join('/')}"
+        directory 'adventure_test', location, @env
+      end
+    end
+  end
+end

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

@@ -13,6 +13,7 @@ module Roro
       mise = Roro::CLI.mise
       environments = args.empty? ? default_environments : args
       containers = Dir.glob("./#{mise}/containers/*").select { |f| File.directory?(f) }
+      create_file "./#{mise}/env/.keep", ''
       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

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Roro
+  class CLI < Thor
+    desc 'generate:harvest', 'Generate harvest.'
+    map 'generate:harvest' => 'generate_harvest'
+
+    def generate_harvest
+      reflector = Roro::Reflector.new
+      content = {
+        cases: reflector.cases.map { |c| c.join(' ') },
+        structure_human: reflector.adventure_structure_human,
+        structure_choices: reflector.adventure_structure_choices
+        # itineraries: harvest_itineraries,
+        # metadata: @reflector.metadata
+      }
+      content.each do |key, value|
+        create_file ".harvest/#{key}.yml", value.to_yaml
+      end
+    end
+
+    no_commands do
+      def harvest_itineraries
+        itineraries = {}
+        @reflector.itineraries.each do |i|
+          itineraries[harvest_adventure_title(i)] = 'blah'
+        end
+        itineraries
+      end
+
+      def harvest_test_files
+        harvest = {}
+        harvest[:test_files] = gather_test_files
+        create_file '.harvest.yml', harvest.to_yaml
+      end
+
+      def gather_test_files
+        Dir.glob("#{Dir.pwd}/lib/roro/stacks/**/*_test.rb")
+      end
+    end
+  end
+end

data/lib/roro/cli/rollon.rb

@@ -9,12 +9,5 @@ module Roro
       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

data/lib/roro/cli.rb

@@ -4,6 +4,18 @@ module Roro
   class CLI < Thor
     include Thor::Actions
 
+    def self.supported_rubies
+      %w[3.0 2.7 2.6 2.5]
+    end
+
+    def self.test_root
+      "#{ENV['PWD']}/test"
+    end
+
+    def self.stacks
+      "#{File.dirname(__FILE__)}/stacks"
+    end
+
     def self.source_root
       "#{@template_root || File.dirname(__FILE__)}/templates"
     end
@@ -13,7 +25,7 @@ module Roro
     end
 
     def self.dependency_root
-      "#{self.roro_root}/dependencies"
+      "#{roro_root}/dependencies"
     end
 
     def self.catalog_root
@@ -22,11 +34,11 @@ module Roro
 
     def self.mise_location
       lookup = Dir.glob("#{Dir.pwd}/**/*.roro")&.first&.split("#{Dir.pwd}/")
-      if lookup
-        mise = lookup.last.split('/').first
-      else
-        mise = 'roro'
-      end
+      mise = if lookup
+               lookup.last.split('/').first
+             else
+               'roro'
+             end
       "#{Dir.pwd}/#{mise}"
     end
 

data/lib/roro/common/utilities.rb

@@ -1,27 +1,28 @@
 # frozen_string_literal: true
+
 require 'json'
 require 'yaml'
 
 module Roro
   module Utilities
-
     def stack_type(stack)
-      case
-      when stack_not_present?(stack)
+      if stack_not_present?(stack)
         :nonexistent
-      when stack_is_ignored?(stack)
+      elsif stack_is_ignored?(stack)
         :ignored
-      when stack_is_dotfile?(stack)
+      elsif stack_is_dotfile?(stack)
         :dotfile
-      when stack_is_storyfile?(stack)
+      elsif stack_is_storyfile?(stack)
         :storyfile
-      when stack_is_templates?(stack)
+      elsif stack_is_templates?(stack)
         :templates
-      when stack_is_inflection?(stack)
+      elsif stack_is_inflection_stub?(stack)
+        :inflection_stub
+      elsif stack_is_inflection?(stack)
         :inflection
-      when stack_is_stack?(stack)
+      elsif stack_is_stack?(stack)
         :stack
-      when stack_is_story?(stack)
+      elsif stack_is_story?(stack)
         :story
       end
     end
@@ -56,6 +57,21 @@ module Roro
         !stack_is_dotfile?(stack)
     end
 
+    def stack_is_inflection_stub?(stack)
+      return unless stack_is_inflection?(stack)
+
+      choices = children(stack).select do |c|
+        stack_is_inflection?(stack) &&
+          !stack_is_stack?(stack) &&
+          !stack_is_story?(stack) &&
+          !stack_is_templates?(stack) &&
+          !stack_is_ignored?(stack) &&
+          !stack_is_storyfile?(stack) &&
+          stack_is_stack?(c) || stack_is_story?(c)
+      end
+      choices.size < 2
+    end
+
     def stack_is_inflection?(stack)
       stack_stories(stack).empty? &&
         !File.file?(stack) &&
@@ -127,7 +143,13 @@ module Roro
     end
 
     def stack_parent_path(stack)
-      stack.split("/#{name(stack)}").first
+      stack.split("/#{stack_name(stack)}").first
+    end
+
+    def stack_is_adventure?(stack)
+      !stack_type(stack).eql?(:templates) &&
+        stack_type(stack_parent_path(stack)).eql?(:inflection) &&
+        %i[stack story].include?(stack_type(stack))
     end
 
     def stack_is_empty?(stack)
@@ -142,6 +164,12 @@ module Roro
       story_paths
     end
 
+    def sort_hash_deeply(unsorted)
+      sorted ||= {}
+      unsorted.sort.to_h.map { |k, v| sorted[k] = sort_hash_deeply(v) }
+      sorted
+    end
+
     def sanitize(hash)
       (hash ||= {}).transform_keys!(&:to_sym).each do |key, value|
         case value
@@ -157,7 +185,7 @@ module Roro
       end
     end
 
-    def name(stack)
+    def stack_name(stack)
       stack.split('/').last
     end
 
@@ -173,7 +201,6 @@ module Roro
       stack.split('/').last
     end
 
-
     def sentence_from(array)
       array[1] ? "#{array[0..-2].join(', ')} and #{array[-1]}" : array[0]
     end
@@ -181,5 +208,9 @@ module Roro
     def read_yaml(yaml_file)
       JSON.parse(YAML.load_file(yaml_file).to_json, symbolize_names: true)
     end
+
+    def adventure_name(location)
+      "Adventure #{stack_parent(location)} #{location.split(Roro::CLI.stacks).last}" # .split('/')
+    end
   end
 end

data/lib/roro/configurators/adventure_chooser.rb

@@ -11,7 +11,7 @@ module Roro
       def initialize
         @asker     = AdventurePicker.new
         @itinerary = []
-        @stack     = Roro::CLI.catalog_root
+        @stack     = Roro::CLI.stacks
       end
 
       def build_itinerary(stack=nil)
@@ -21,13 +21,15 @@ module Roro
         when :storyfile
           @manifest << stack
         when :story
+          @itinerary << stack.split("#{Roro::CLI.stacks}/").last
           @manifest += stack_stories(stack)
         when :stack
           @manifest += stack_stories(stack)
           children(stack).each { |c| build_itinerary(c) }
+        when :inflection_stub
+          children(stack).each { |c| build_itinerary(c) }
         when :inflection
           child = choose_adventure(stack)
-          @itinerary << child if stack_type(child).eql?(:story)
           build_itinerary(child)
         end
         @manifest.uniq!

data/lib/roro/configurators/adventure_picker.rb

@@ -12,7 +12,7 @@ module Roro
         def choose_adventure(stack)
           build_inflection(stack)
           say("Rolling story on from stack: #{@stack}\n\n")
-          say(@getsome)
+          say(@prompt)
           choice = ask(@inflection)
           story_name = story_from(choice.to_s)
           "#{stack}/#{story_name}"
@@ -23,13 +23,13 @@ module Roro
           prompt = inflection_prompt
           options = inflection_options
           prompt_options = humanize(options)
-          @getsome = "#{prompt}\n"
+          @prompt = "#{prompt}\n"
           @inflection = ["#{prompt_options}\n\n", "Choices: [#{set_color(options.keys.map { |k| k.to_i }.join(' '), :blue)}]"]
         end
 
         def inflection_prompt
           prompt = 'Please choose from these'
-          collection = name(@stack).gsub('_', ' ') + ":\n"
+          collection = stack_name(@stack).gsub('_', ' ') + ":\n"
           [prompt, stack_parent(@stack), collection].join(' ')
         end
 
@@ -37,10 +37,10 @@ module Roro
           stack ||= @stack
           Hash.new.tap do |h|
             children(stack)
-              .map { |f| name(f) }
+              .map { |f| stack_name(f) }
               .sort
               .each_with_index do |c, i|
-              h[(i + 1).to_s] = name(c)
+              h[(i + 1).to_s] = stack_name(c)
             end
           end
         end
@@ -55,9 +55,9 @@ module Roro
         end
 
         def get_story_preface(story)
-          storyfile = "#{story}/#{name(story)}.yml"
+          storyfile = "#{story}/#{stack_name(story)}.yml"
           if stack_is_storyfile?(storyfile)
-            read_yaml("#{story}/#{name(story)}.yml")[:preface]
+            read_yaml("#{story}/#{stack_name(story)}.yml")[:preface]
           else
             nil
           end