roro 0.3.12 → 0.3.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: c6bf9813b07f7c2c2f34a0e0e4578130062af0752865da885f4da75c4def51c2
-  data.tar.gz: 2ff26062242671ba49fdffd5b6e87d0477ffb906fb5af967b758440fb4dade1d
+SHA1:
+  metadata.gz: 28419719167db581fa026244d2628fa4c86c9d3b
+  data.tar.gz: b46403289b09d42a550ac9dff3a4edcc717f2c63
 SHA512:
-  metadata.gz: d272d16756b148c197ec2b0dcaf25463f0669e88ad4c79ff2f9fc19a2508be72d7ebd13b33ef595df1d146bd22346a8f9413f99ce4d61139167ee0923e103dc7
-  data.tar.gz: 1ce050d03045da0c39d93f8f6ecbf9e4a92782ee7a7594aa976dbdea7350b53964612cd6b970f852749d016b071ccc8c56afca4ce71ed8ab632360150f086fd8
+  metadata.gz: 3b2075ccae46a264f2d64bf2d2c09fb678bf95a44d534b0263dcb2a9e5cbf6345663d683bea3219ec728512e65eca391e1715a7334d304d4e46411a3e75f6ec1
+  data.tar.gz: 5ef3392e89e8e72af5e190a79f45ff7e107db744c0fe2a886b6e0e11bf6829c0fc723c6e298c0ad51d20a7b4882dbd84035b3b966a2eabdf5484e4c32827ae28

data/.circleci/config.yml

@@ -0,0 +1,93 @@
+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
+
+major_only: &major_only
+  filters:
+    branches:
+      only: master, release
+ 
+version: 2.1
+
+executors:
+  machine-executor: 
+    machine: true
+  ruby-executor: 
+    docker:
+      - image: cimg/ruby:2.7
+      
+jobs:
+
+  build:
+    <<: *defaults
+    steps:
+      - checkout
+  
+  test-rollon-rails: 
+    executor: ruby-executor
+    steps: 
+      - checkout 
+      - setup_remote_docker:
+          version: 19.03.12
+      - run: |
+          rake install 
+          mkdir greenfield
+          cd greenfield
+          (yes || true) | roro greenfield
+      - 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
+  
+workflows:
+  version: 2
+    
+  build-cli: 
+    jobs: 
+      - build 
+      - test-rollon-rails: 
+          <<: *major_only
+      - test:
+          <<: *major_only
+      
+      - release:
+          requires: 
+            - build
+          filters:
+            branches:
+              only: release      

data/{lib/roro/cli/templates/ruby_gem → .circleci}/setup-gem-credentials.sh

@@ -1,3 +1,3 @@
 mkdir ~/.gem
 echo -e "---\r\n:rubygems_api_key: $RUBYGEMS_API_KEY" > ~/.gem/credentials
-chmod 0600 /home/circleci/.gem/credentials
+chmod 0600 /home/circleci/.gem/credentials

data/.gitignore

@@ -13,12 +13,13 @@ roro/**/*.key
 
 *.key
 *.env
-
-tmp/*
+!/.gitignore
+*.gem
 tmp/*
-!tmp/.gitkeep 
+!tmp/.keep 
 sandbox/*
 !sandbox/.keep 
 !sandbox/greenfield
 sandbox/greenfield/*
-!sandbox/greenfield/.keep
+!sandbox/greenfield/.keep
+TUTORIAL.md

data/Guardfile

@@ -1,17 +1,15 @@
-# A sample Guardfile
-# More info at https://github.com/guard/guard#readme
-
 options = {
-  cli: '-f',
-  all_on_start: true,
-  all_after_pass: true
+  all_on_start: false,
+  all_after_pass: false, 
 }
 
 guard :minitest, options do
 
-  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
   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{^test/fixtures/files/(.*/)?([^/]+)\.yml$})     { 'test' }
+  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" }
 end

data/README.md

@@ -217,4 +217,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/{lib/roro/cli/templates/ruby_gem/docker-compose.yml → docker-compose.yml}

@@ -7,5 +7,9 @@ services:
       context: .
       dockerfile: roro/containers/ruby_image/Dockerfile
     environment:
-      - RUBY_IMAGE=${RUBY_IMAGE}
-    command: bundle exec rake test
+      - RUBY_VERSION=${RUBY_VERSION}
+    volumes:
+      - gem_cache:/gems
+
+volumes:
+  gem_cache:

data/lib/roro.rb

@@ -1,6 +1,7 @@
-require "roro/version"
 require "thor"
+require "roro/version"
 require "roro/cli"
+require "roro/configurator"
 
 module Roro
   class Error < StandardError; end

data/lib/roro/cli.rb

@@ -1,89 +1,31 @@
-require 'roro/cli/base/base'
-require 'roro/cli/greenfield'
-require 'roro/cli/obfuscate'
-require 'roro/cli/expose'
-require 'roro/cli/generate/config/rails'
-require 'roro/cli/generate/config'
-require 'roro/cli/generate/generate_keys'
-require 'roro/cli/configuration'
 
+require 'roro/cli/generate/exposed'
+require 'roro/cli/generate/keys'
+require 'roro/cli/generate/obfuscated'
+require 'roro/cli/generate/story'
+require 'roro/cli/greenfield/rails'
 require 'roro/cli/rollon'
+require 'roro/cli/rollon/rails/base/base'
+require 'roro/cli/rollon/rails/database/with_mysql'
+require 'roro/cli/rollon/rails/database/with_postgresql'
+
+require 'roro/cli/rollon/ruby_gem'
+
 module Roro
-  
   class CLI < Thor
 
     include Thor::Actions
     
     def self.source_root
-      File.dirname(__FILE__) + '/cli/templates'
-    end
-    
-   
-    desc "rollon::rails", "Generates files for and makes changes to your app 
-      so it can run using Docker containers."
-    method_option :interactive, desc: "Set up your environment variables as 
-      you go."
-    map "rollon::rails" => "rollon_rails"
-    
-    def rollon_rails 
-      rollon
-    end
-
-    
-    desc "greenfield::rails", "Greenfield a new, dockerized rails app with
-      either MySQL or PostgreSQL in a separate container."
-    
-    method_option :env_vars, type: :hash, default: {}, desc: "Pass a list of environment variables like so: env:var", banner: "key1:value1 key2:value2"
-    method_option :interactive, desc: "Set up your environment variables as you go."
-    method_option :force, desc: "force over-write of existing files"
-
-    map "greenfield::rails" => "greenfield_rails"
-    
-    def greenfield_rails(*args) 
-      greenfield(*args)
+      File.dirname(__FILE__) + '/templates'
     end
-    desc "generate::exposed", "Generate private .env files from 
-      encrypted .env.enc files inside the roro directory."
-    map "generate::exposed" => "generate_exposed"
     
-    def generate_exposed(*args) 
-      expose(*args)
+    def self.story_root
+      File.dirname(__FILE__) + '/stories'
     end
     
-    desc "generate::key", "Generate a key inside roro/keys. Takes the name of 
-      an environment as an argument to private .env files from 
-    encrypted .env.enc files inside the roro directory.
-    Expose encrypted files"
-    
-    map "generate::key" => "generate_key"
-    method_option :environment, type: :hash, default: {}, desc: "Pass a list of environment variables like so: env:var", banner: "development, staging"
-    
-    def generate_key(*args)
-      generate_key_or_keys(*args)
-    end
-
-    desc "generate::keys", "Generate keys for each environment inside roro/keys.
-      If you have .env files like 'roro/containers/app/[staging_env].env' and 
-      'roro/[circle_ci_env].env' it will generate '/roro/keys/[staging_env].key'
-      and '/roro/keys/[circle_ci_env].key'."
-    map "generate::keys" => "generate_keys"
-
-    def generate_keys(*args)
-      generate_key(*args)
-    end
-    
-    desc "generate::config", "Generate a config file at .roro_config.yml" 
-    map "generate::config" => "generate_config"
-    
-    def generate_config
-      create_file ".roro_config.yml", @config.app.to_yaml 
-    end
-    
-    desc "generate::obfuscated", "obfuscates any files matching the pattern ./roro/**/*.env"
-    map "generate::obfuscated" => "generate_obfuscated"
-    
-    def generate_obfuscated(*args) 
-      obfuscate(*args)
+    def self.roro_environments 
+      %w(development production test staging ci)
     end
   end
 end

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

@@ -0,0 +1,14 @@
+module Roro
+  class CLI < Thor
+    
+    desc "generate::exposed", "Generate private .env files from encrypted .env.enc files inside the roro directory."
+    map "generate::exposed" => "generate_exposed"
+    
+    def generate_exposed(*args) 
+      environments = args.first ? [args.first] : gather_environments
+      environments.each do |environment|
+        HandsomeFencer::Crypto.expose(environment, 'roro')
+      end
+    end
+  end
+end

data/lib/roro/cli/generate/{generate_keys.rb → keys.rb}

@@ -2,6 +2,28 @@ module Roro
 
   class CLI < Thor
     
+    desc "generate::key", "Generate a key inside roro/keys. Takes the name of 
+      an environment as an argument to private .env files from 
+    encrypted .env.enc files inside the roro directory.
+    Expose encrypted files"
+    
+    map "generate::key" => "generate_key"
+    method_option :environment, type: :hash, default: {}, desc: "Pass a list of environment variables like so: env:var", banner: "development, staging"
+    
+    def generate_key(*args)
+      generate_key_or_keys(*args)
+    end
+
+    desc "generate::keys", "Generate keys for each environment inside roro/keys.
+      If you have .env files like 'roro/containers/app/[staging_env].env' and 
+      'roro/[circle_ci_env].env' it will generate '/roro/keys/[staging_env].key'
+      and '/roro/keys/[circle_ci_env].key'."
+    map "generate::keys" => "generate_keys"
+
+    def generate_keys(*args)
+      generate_key(*args)
+    end
+    
     no_commands do
 
       def generate_key_or_keys(*args)

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

@@ -0,0 +1,17 @@
+require 'handsome_fencer/crypto'
+
+module Roro
+
+  class CLI < Thor
+
+    desc "generate::obfuscated", "obfuscates any files matching the pattern ./roro/**/*.env"
+    map "generate::obfuscated" => "generate_obfuscated"
+    
+    def generate_obfuscated(*args) 
+      environments = args.first ? [args.first] : gather_environments
+      environments.each do |environment|
+        HandsomeFencer::Crypto.obfuscate(environment, 'roro')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Roro
+  class CLI < Thor
+    
+    desc "generate::story", "Generate a config file at .roro_config.yml to use later" 
+    map "generate::story" => "generate_story"
+    
+    def generate_story
+      
+      @config ||= Roro::Configuration.new(options)
+      # configuration = {
+      #   env_vars: @config.env.keys,
+      #   intentions: @config.intentions,
+      #   story: @config.structure['story']
+      # }
+      # create_file ".roro_configurator.yml", @config.env.to_yaml 
+    end
+  end 
+end

data/lib/roro/cli/greenfield/rails.rb

@@ -0,0 +1,14 @@
+module Roro
+
+  class CLI < Thor
+    
+    desc "greenfield::rails", "Greenfield a new, dockerized rails app with
+    either MySQL or PostgreSQL in a separate container."
+  
+    map "greenfield::rails" => "greenfield_rails"
+    
+    def greenfield_rails
+      greenfield( { story: :rails } )
+    end
+  end
+end

data/lib/roro/cli/rollon.rb

@@ -1,84 +1,147 @@
-require 'roro/cli/rollon/stories'
-
 module Roro
-
   class CLI < Thor
 
-    desc "rollon", "Generates files for and makes changes to your app 
-      so it can run using Docker containers."
-    method_option :interactive, desc: "Set up your environment variables as 
-      you go."
-
-    def rollon
-      confirm_directory_not_empty
-      confirm_dependencies
-      remove_roro_artifacts 
+    class << self
+      private
+      def shared_options!
+        method_option :omakase, default: :omakase, desc: "Use the Roro setup with some configuring. 'Omakase' translates as 'I'll leave it up to you.'", aliases: ['-d', '--default']
+        method_option :fatsutofodo, desc: 'Use the Roro setup without having to think.', aliases: ['-f', '--fast']
+        method_option :okonomi, desc: "Use Roro how you like. 'Okonomi' has the opposite meaning of omakase.", aliases: ['-i', '--interactive'] 
+      end
+  
+      alias_method :orig_desc, :desc
+  
+      def desc(*args)
+        orig_desc(*args)
+        shared_options!
+      end
+    end
+    rollonto = ' into Roro.'
+    desc "rollon", "Roll an existing app#{rollonto}"
+    def rollon(args={})
+      @config ||= Roro::Configuration.new(args, options) 
+      greenfield_actions 
+      greenfield_commands
+      manifest_actions
+      manifest_intentions
+      congratulations
+      startup_commands 
+    end
+    
+    desc "greenfield", "Greenfield a new app and roll it#{rollonto}"
+    def greenfield(args={})
+      args[:greenfield] = :greenfield
 
-      configure_for_rollon
-      
-      copy_roro_files
-      generate_config
-      startup_commands
+      rollon(args)
     end
     
-    no_commands do
-     
-      def configure_for_rollon
+    desc "greenfield::rails", "Greenfield a new Rails app and roll it#{rollonto}"
+  
+    map "greenfield::rails" => "greenfield_rails"
+    
+    def greenfield_rails
+      greenfield( { story: :rails } )
+    end
+    
+    desc "rollon::rails", "Roll an existing app#{rollonto}"
+    map "rollon::rails" => "rollon_rails"
+    
+    def rollon_rails(args={}) 
+      rollon( { story: :rails } )
+    end
+    
+    desc "rollon::rails::kubernetes", "Adds Kubernetes for production."
+    map "rollon::rails::kubernetes" => "rollon_rails_kubernetes"
+    
+    def rollon_rails_kubernetes(args={}) 
+      story = { 
+        rails: [
+          { database: :postgresql },
+          { kubernetes: :postgresql },
+          { ci_cd: :circleci}
+        ] 
+      }  
+      rollon( { story: story } )
+    end
+
+    desc "greenfield::rails::kubernetes", "Adds Kubernetes for production."
+    map "greenfield::rails::kubernetes" => "greenfield_rails_kubernetes"
+    
+    def greenfield_rails_kubernetes(args={}) 
+      story = { 
+        rails: [
+          { database: :postgresql },
+          { kubernetes: :postgresql },
+          { ci_cd: :circleci}
+        ] 
+      }  
+      rollon( { story: story } )
+    end
+
+    no_commands do 
+      
+      def configure_for_rollon(aroptions=nil)
         @config ||= Roro::Configuration.new(options) 
       end
-      
-      def yaml_from_template(file)
-        File.read(File.dirname(__FILE__) + "/templates/#{file}")
+
+      def manifest_actions
+        @config.structure[:actions].each {|a| eval a }
       end
       
-      def copy_roro_files 
-        configure_database  
-        directory 'roro', './', @config.app
-        template 'base/Dockerfile.tt', 'roro/containers/app/Dockerfile', @config.app
-        take_thor_actions
-      end
+      def manifest_intentions
+        @config.intentions.each {|k, v| eval(k.to_s) if v.eql?('y') }  
+      end 
       
-      def take_thor_actions 
-        @config.thor_actions.each {|k, v| eval(k) if v.eql?('y') }  
-      end
-              
-      def startup_commands
-        system 'docker-compose build'
-        system 'docker-compose run web bundle'
-        system 'docker-compose run web bin/rails webpacker:install'
-        system 'docker-compose run web bin/rails yarn:install'
-        system 'docker-compose run web bin/rails db:create'
-        system 'docker-compose run web bin/rails db:migrate'
-        system 'docker-compose up'
-      end
+      def greenfield_actions 
+        return unless @config.structure[:greenfield_actions] 
+        @config.structure[:greenfield_actions].each {|a| eval a }
+      end 
       
-      def confirm_directory_empty 
-        confirm = confirm_dependency({
-          system_query: "ls -A",
-          warning: "this is not an empty directory. Roro will not greenfield a new Rails app unless either a) the current directory is empty or b) you run greenfield with the --force flag",
-          suggestion: "$ roro greenfield --force",
-          conditional: "Dir.glob('*').empty?" }) 
-        confirm || true
+      def greenfield_commands 
+        return unless @config.structure[:greenfield_actions] 
+        @config.structure[:greenfield_commands].each {|a| eval a }
       end
 
-    
-      def confirm_dependency(options)
-        msg = []
-        msg << ""
-        msg << delineator
-        msg << "It looks like #{options[:warning]}. The following bash command returns false:"
-        msg << "\t$ #{options[:system_query]}"
-        msg << "Please try these instructions:"
-        msg << ("\t" + options[:suggestion])
-        msg << delineator
-        conditional = options[:conditional] ? eval(options[:conditional]) : system(options[:system_query])
-        if conditional == false
-          raise(Roro::Error.new(msg.join("\n\n")))
+      def congratulations(story=nil)
+        ( @config.story[:rollon]) 
+        if @config.structure[:greenfield]
+          usecase = 'greenfielded a new '
         else 
-          true 
+          usecase = 'rolled your existing ' 
+        end 
+        array = ["You've successfully "]
+        array << usecase
+        congrats = array.join("") 
+        puts congrats
+      end
+      
+      def startup_commands
+        congratulations( @config.story[:rollon])
+        cmd = @config.structure[:startup]
+        commands = cmd[:commands] 
+        question = []
+        question << "\n\n You can start your app up with some combination of these commands:\n"
+        commands.each { |c| question << "\t#{c}"}
+        question << "\nOr if you'd like Roro to try and do it for you:"
+        question = question.join("\n")
+        if ask(question, default: 'y', limited_to: ['y', 'n']).eql?("y")
+          commands.each {|a| system(a) }
+          puts "\n\n#{cmd[:success]}\n\n" 
         end
       end
       
+      def yaml_from_template(file)
+        File.read(find_in_source_paths(file))
+      end
+      
+      def generate_config_story
+        roro_story = {
+          story: @config.story,
+          env_vars: @config.env,
+          intentions: @config.intentions
+        }
+        create_file ".roro_story.yml", roro_story.to_yaml 
+      end
     end
   end
 end