roro 0.3.13 → 0.3.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6b8dac88c95d43a7e4531d2b44849f30e1e37c9e
-  data.tar.gz: 20af42166d1cc70f7b20d327d8cbc8027255cc6c
+SHA256:
+  metadata.gz: 43e30bd9aa551984852307e9c258049546a167e89aaab22e3f8b7256cec22a23
+  data.tar.gz: 790ad729852cf34c8bbdfa6499ab325f399334d1df2c385d20e7ae5757dcd707
 SHA512:
-  metadata.gz: c05e7ff871bcfb14a52602ef71b3a331113ff87da423cca594fb07b41fb5463a432809e0526b8ca77987fb6838829c5ccacfc6e85e1823bf92d6d66a5c1bc3f9
-  data.tar.gz: db4039537980f16d922c0f08add246f66d1229b3055e0cfc0880f5bbdd968eca374d142639fb09d1b4d3d6246efac5dbe381239f516170e065ef3e72ab400366
+  metadata.gz: 4de76d1807c627790a721e968e458bcff335d9a972b8b496d5a1dfc494c8b750332eae75411dc689482bb3e60fab44319fa46cc95c63547cedfa5c849e527ce5
+  data.tar.gz: b7f2647884d116fc849431070829e2806f244771580a532f57e65cabbf17d856bf209d76e425eee28e370eee90ef6d10f0ab8de10998503bc058da846387bb78

data/.circleci/config.yml

@@ -1,14 +1,58 @@
+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: &release
+  filters:
+    branches:
+      only: release
+      
+      
 version: 2.1
 
+executors:
+  machine-executor: 
+    machine: true
+  ruby-executor: 
+    docker:
+      - image: cimg/ruby:2.7
+      
 jobs:
 
   build:
-    machine: true
+    <<: *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:
-    machine: true
+    <<: *defaults
     steps:
       - checkout
       - run: RUBY_VERSION=2.5 docker-compose build ruby_gem
@@ -22,7 +66,7 @@ jobs:
       - run: RUBY_VERSION=2.7 docker-compose run ruby_gem bundle exec rake test    
       
   release:
-    machine: true
+    <<: *defaults
     steps:
       - checkout
       - run: gem install roro
@@ -39,17 +83,17 @@ jobs:
 workflows:
   version: 2
     
-  build-release: 
+  build-cli: 
     jobs: 
-      - build
+      - build: 
+          <<: *major_only
+          <<: *release
+      - test-rollon-rails: 
+          <<: *major_only
       - test:
-          filters: 
-            branches: 
-              only: master
+          <<: *major_only
       
       - release:
           requires: 
             - build
-          filters: 
-            branches: 
-              only: release
+          <<: *release

data/.gitignore

@@ -14,11 +14,12 @@ roro/**/*.key
 *.key
 *.env
 !/.gitignore
-
+*.gem
 tmp/*
 !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.rb

@@ -1,6 +1,8 @@
-require "roro/version"
 require "thor"
+require "roro/version"
 require "roro/cli"
+require "roro/configurator"
+require "roro/crypto"
 
 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|
+        Roro::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)
@@ -23,7 +45,7 @@ module Roro
       def gather_environments
         environments = []
         ['.env', '.env.enc'].each do |extension|
-          HandsomeFencer::Crypto.source_files('roro', extension).each do |env_file|
+          Roro::Crypto.source_files('roro', extension).each do |env_file|
             environments << env_file.split('/').last.split(extension).last
           end
         end
@@ -32,7 +54,7 @@ module Roro
 
       def confirm_files_decrypted?(environment)
         orphan_encrypted = []
-        HandsomeFencer::Crypto.source_files('.', '.env.enc').each do |file|
+        Roro::Crypto.source_files('.', '.env.enc').each do |file|
           unless File.exist? file.split('.enc').first
             orphan_encrypted << file 
           end

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

@@ -0,0 +1,17 @@
+require 'roro/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|
+        Roro::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, 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