roro 0.3.22 → 0.3.23

data/lib/roro/cli/rollon/rails/database/with_mysql.rb

@@ -1,22 +0,0 @@
-module Roro
-
-  class CLI < Thor
-
-    no_commands do
-      
-      def configure_for_mysql 
-        insert_db_gem('mysql2')
-        copy_file 'rails/config/database.mysql.yml', 'config/database.yml', force: true
-        config = @config.env.clone
-
-        %w(development production test staging ci).each do |environment| 
-          config[:rails_env] = environment
-          
-          source = 'rails/dotenv/database.mysql.env.tt'
-          target = "roro/containers/database/#{environment}.env" 
-          template( source, target, config )
-        end
-      end
-    end
-  end
-end

data/lib/roro/cli/rollon/rails/database/with_postgresql.rb

@@ -1,20 +0,0 @@
-module Roro
-
-  class CLI < Thor
-
-    no_commands do
-      
-      def configure_for_pg 
-        copy_file 'rails/config/database.pg.yml', 'config/database.yml', force: true
-        config = @config.env.clone
-        %w(development production test staging ci).each do |environment| 
-          config[:rails_env] = environment
-          
-          source = 'rails/dotenv/database.pg.env.tt'
-          target = "roro/containers/database/#{environment}.env"
-          template( source, target, config )
-        end
-      end
-    end
-  end
-end

data/lib/roro/cli/rollon/rails/database.rb

@@ -1,26 +0,0 @@
-module Roro
-
-  class CLI < Thor
-
-    no_commands do
-
-      def configure_database 
-        database = @config.intentions[:configure_database]
-        case database
-        when 'p'
-          @config.env[:database_vendor] = 'postgresql'
-          configure_for_pg
-        when 'm'
-          @config.env[:database_vendor] = 'mysql'
-          configure_for_mysql
-        end
-        %w(development production test staging ci).each do |environment| 
-          src = 'rails/dotenv/web.env.tt'
-          dest = "roro/containers/app/#{environment}.env"
-          template src, dest, @config.env
-        end
-      end
-    end 
-  end 
-end
-      

data/lib/roro/cli/rollon/ruby_gem/with_ci_cd.rb

@@ -1,45 +0,0 @@
-module Roro 
-  class CLI < Thor 
-       
-    desc "rollon::ruby_gem::with_ci_cd", "Generate files for containerized gem testing, CircleCI, and releasing to RubyGems."
-    map "rollon::ruby_gem::with_ci_cd" => "rollon_ruby_gem_with_ci_cd"
-
-    def rollon_ruby_gem_with_ci_cd(*args) 
-      ruby_gem_with_ci_cd(*args)
-      configure_for_rollon
-    end
-    
-    no_commands do 
-      def ruby_gem_with_ci_cd(*args)
-        answer = ask("\nYou can add your rubygems api key in\n\t 
-          './roro/containers/ruby_gem/ci.env' \n\nlater, or we'll try to add it here:", 
-        default: '')
-        rubygems_api_key = (answer.eql?("") ? 'some-key' : answer)
-        @config.env[:rubygems_api_key] = rubygems_api_key
-        @config.env[:rubies] = [] 
-        3.times do |index| 
-          newruby = @config.env[:ruby_version].gsub('.', '').to_i - index
-          @config.env[:rubies] << newruby.to_s.split('').join('.')
-        end
-        directory 'ruby_gem/roro', './roro', @config.env
-        directory 'ruby_gem/.circleci', './.circleci', @config.env
-        copy_file 'ruby_gem/docker-compose.yml', './docker-compose.yml'
-        
-        @config.env[:rubies].each do |ruby| 
-          file = '.circleci/config.yml'
-          spacer = "\n      - run: "
-          rv = "RUBY_VERSION=#{ruby} docker-compose "
-          build = "build ruby_gem"
-          up = "up -d --force-recreate ruby_gem"
-          run_tests = "run ruby_gem bundle exec rake test"
-          append_to_file file, spacer + rv + run_tests, after: "- placeholder"
-          append_to_file file, spacer + rv + up, after: "- placeholder"
-          append_to_file file, spacer + rv + build, after: "- placeholder"
-        end
-        gsub_file '.circleci/config.yml', "- placeholder", "- checkout"
-        append_to_file ".gitignore", "\nGemfile.lock"
-        gitignore_sensitive_files
-      end
-    end
-  end
-end

data/lib/roro/cli/rollon/ruby_gem.rb

@@ -1 +0,0 @@
-require 'roro/cli/rollon/ruby_gem/with_ci_cd.rb'

data/lib/roro/cli/rollon/stories.rb

@@ -1,2 +0,0 @@
-require 'roro/cli/rollon/ruby_gem'
-require 'roro/cli/rollon/rails'

data/lib/roro/configurator/eligibility.rb

@@ -1,137 +0,0 @@
-require 'open3'
-
-module Roro
-  module Configurator
-    module Eligibility  
-      
-      def screen_target_directory
-        @structure[:greenfield] ? confirm_directory_empty : confirm_directory_app
-        handle_roro_artifacts
-      end
-      
-      def confirm_directory_app 
-        confirm_dependency({
-          system_query: "ls -A",
-          warning: "This is an empty directory. You can generate a new and fully 
-            dockerized Rails app using the 'greenfield' command here here but if 
-            you want to containerize an existing app -- which is what the 'rollon'
-            command is for -- you'll need to navigate to a directory with an app we
-            can roll onto.",
-          suggestion: "$ roro greenfield",
-          conditional: "!Dir.glob('*').empty?"})
-      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?" # || (Dir.glob('*').size.eql?(1) && Dir.glob('roro_configurator.yml'))" 
-          }) 
-        confirm || true
-      end
-
-      def artifacts?
-        @appname = @env[:main_app_name]
-        @artifacts = {}
-        hash = {
-          containers: {
-            list: "docker ps --filter name=#{@appname}\ -a",
-            remove: " -q | xargs docker stop | xargs docker rm -f"
-          }, 
-          volumes: {
-            list: "docker volume ls --filter name=#{@appname}*",
-            remove: " -q | xargs docker volume rm -f"
-          },
-          networks: {
-            list: "docker network ls --filter name=#{@appname}",
-            remove: " -q | xargs docker network rm"
-          },
-          images: {
-            list: "docker image ls #{@appname}*",
-            remove: " -q | xargs docker rmi -f"
-          }
-        }
-        hash.each do |k, v|
-          check = IO.popen(v[:list] + ' -q').count > 0
-          @artifacts[k] = v if check
-        end
-        true if @artifacts.empty?
-      end
-      
-      def handle_roro_artifacts
-        return if artifacts?
-        question = [
-          "\n\nThis machine has some docker artifacts which may clash with ",
-          "RoRo moving forward. You can verify their existence with:\n"
-        ]
-        @artifacts.each { |k,v| question << "\t$ #{v[:list]}" } 
-        question << "\nYou can remove these artifacts with something like:\n" 
-        @artifacts.each { |k,v| question << "\t$ #{v[:list]} #{v[:remove]}" }
-        question << "\nWould you like RoRo to attempt to remove them for you?"
-        choices = {'y' => 'Yes', 'n' => 'No'}
-        
-        choices.each { |k,v| question << "(#{k}) #{v.to_s}" }
-        
-        prompt = question.join
-        answer = ask(prompt, default: 'y', limited_to: choices.keys)
-        
-        if answer.eql?('y')
-          
-          @artifacts.each do |k,v| 
-            puts "Attempting to remove #{k}"  
-            system( v[:list] + v[:remove] )
-          end 
-        end
-      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 << "Try this:"
-        msg << ("\t" + options[:suggestion])
-        msg << delineator
-        conditional = options[:conditional] ? eval(options[:conditional]) : system(options[:system_query])
-        query = options[:system_query]
-        if conditional == false
-          
-          raise(Roro::Error.new(msg.join("\n\n")))
-        else 
-          true 
-        end    
-      end
-      
-      def confirm_dependencies
-        dependencies.each do |dependency|
-          confirm_dependency(dependency)
-        end
-      end
-      
-      private 
-      
-      def delineator
-        ("-" * 80)
-      end
-      
-      def dependencies
-        [ 
-          { 
-            system_query: "which docker",
-            warning: "Docker isn't installed",
-            suggestion: "https://docs.docker.com/install/"
-          }, {
-            system_query: "which docker-compose",
-            warning: "Docker Compose isn't installed",
-            suggestion: "https://docs.docker.com/compose/install/"
-          }, {
-            system_query: "docker info",
-            warning: "the Docker daemon isn't running",
-            suggestion: "https://docs.docker.com/config/daemon/#start-the-daemon-manually"
-        } ]
-      end 
-    end
-  end 
-end

data/lib/roro/configurator/okonomi.rb

@@ -1,28 +0,0 @@
-require 'yaml'
-require 'json'
-
-module Roro
-  module Configurator
-    module Okonomi  
-  
-      def take_order
-        ask_questions
-      end
-
-      def ask_questions
-        choices = @structure[:choices] 
-        choices.each do |key, value|
-          @structure[:intentions][key] = ask_question(value)
-        end
-      end
-
-      def ask_question(question)
-        prompt = question[:question]
-        default = question[:default]
-        choices = question[:choices].keys
-        answer = ask(prompt, default: default, limited_to: choices)
-        answer
-      end
-    end
-  end
-end

data/lib/roro/configurator/omakase.rb

@@ -1,170 +0,0 @@
-module Roro
-  module Configurator
-    module Omakase 
-      attr_reader :structure, :intentions, :env, :options, :story
-
-      def initialize(args={}, options={})
-
-        @options = sanitize(args)
-        @structure = {
-          intentions: {},
-          choices:    {}, 
-          env_vars:   {}
-        }
-        @story = @options[:story] ? { rollon: @options[:story] } : default_story 
-        build_story 
-        @intentions = @structure[:intentions]
-        @env = @structure[:env_vars]
-        @env[:main_app_name] = Dir.pwd.split('/').last 
-        @env[:ruby_version] = RUBY_VERSION
-        @env[:force] = true
-        @env[:verbose] = false
-        @env[:roro_version] = VERSION
-        screen_target_directory 
-      end
-      
-      def build_story 
-        layer_greenfield
-        layer_rollon
-        layer_story
-        layer_okonomi 
-      end
-     
-      def layer_okonomi
-        return unless @options.keys.include?(:okonomi) 
-        @structure[:okonomi] = true
-        take_order 
-      end
-      
-      def layer_greenfield
-        return unless @options.keys.include?(:greenfield) 
-        @structure[:greenfield] = true
-        build_layers( { greenfield: :rails } )
-      end
-      
-      def layer_rollon 
-        build_layers(@story)  
-      end
-      
-      def layer_story 
-        file = '.roro_story'
-        return unless File.exist?("#{file}.yml")
-        overlay(get_layer(file)) 
-      end
-      
-      def build_layers(story, location=nil)
-        story = story.is_a?(Hash) ? story : { story => {}} 
-        story.each do |key, value|
-          location = location ? "#{location}/#{key}" : key
-          case value 
-          when Array
-            value.each {|value| build_layers(value, location) }
-          when true
-          when 
-            build_layers(value, location)
-          end
-        end 
-        overlay(get_layer("#{Roro::CLI.story_root}/#{location}")) 
-      end
-      
-      def overlay(layer)
-        layer.each do |key, value| 
-          @structure[key] ||= value  
-        end
-        overlay_choices(layer) if layer[:choices]
-        overlay_env_vars(layer) if layer[:env_vars]
-        overlay_actions(layer) if layer[:actions]
-      end
-      
-      def overlay_actions(layer)
-        @structure[:actions].concat(layer[:actions]) 
-      end
-      
-      def overlay_env_vars(layer)
-        layer[:env_vars].each do |key, value| 
-          @structure[:env_vars][key] = value
-        end    
-      end
-  
-      def overlay_choices(layer)
-        @structure[:intentions] ||= {}
-        layer[:choices].each do |key, value|
-          @structure[:choices][key] = value
-          @structure[:intentions][key] = value[:default]  
-        end
-      end
-      
-      def overlay_intentions(layer) 
-        layer[:intentions].each do |key, value| 
-          @structure[:intentions][key] = value
-        end
-      end
-  
-      def sanitize(options)
-        options ||= {}
-        options.transform_keys!{|k| k.to_sym}
-        options.each do |key, value| 
-          case value
-          when Array
-            value.each { |vs| sanitize(vs) }
-          when Hash 
-            sanitize(value)
-          when true 
-            options[key] = true
-          when String || Symbol
-            options[key] = value.to_sym 
-          end
-        end
-      end
-   
-      def get_layer(filedir)
-        filepath = filedir + '.yml' 
-        if !File.exist?(filepath)
-          key = filedir.split('/').last
-          error_msg = "Cannot find that story #{key} at #{filepath}. Has it been written?" 
-          raise (Roro::Error.new(error_msg)) 
-        end   
-        json = JSON.parse(YAML.load_file(filepath).to_json, symbolize_names: true)
-        json ? json : ( raise (Roro::Error.new(error_msg))) 
-      end
-
-      def story_map(story='stories')
-        array ||= []
-        loc = Roro::CLI.story_root + "/#{story}"
-        validate_story(loc)
-        stories = Dir.glob(loc + "/*.yml") 
-        stories.each do |ss| 
-          name = ss.split('/').last.split('.yml').first
-          array << { name.to_sym => story_map([story, name].join('/'))}
-        end   
-        array
-      end
-            
-      def default_story(story='rollon', loc=nil)
-        hash = {}
-        loc = [(loc ||= Roro::CLI.story_root), story].join('/') 
-        substory = get_layer(loc)[:stories]
-        if substory.is_a?(Array)
-          array = []
-          substory.each do |s| 
-            ss = get_layer([loc, s].join('/'))[:stories]
-            array << (ss.is_a?(String) ? { s.to_sym => ss.to_sym } : default_story( s, loc ) ) 
-          end
-          hash[story.to_sym] = array
-        else 
-          hash[story.to_sym] = default_story(substory, loc)
-        end
-        hash
-      end
-      
-      def validate_story(story)
-        substories = get_layer(story)[:stories]
-        if substories.is_a? String
-          File.exist?(story + substories + '.yml')
-        elsif substories.is_a? Array 
-          substories.each { |substory| validate_story(story + '/' + substory) }
-        end 
-      end 
-    end 
-  end 
-end

data/lib/roro/crypto.rb

@@ -1,113 +0,0 @@
-require "openssl"
-require "base64"
-module Roro::Crypto
-
-  class << self
-
-    def generate_key
-      @cipher = OpenSSL::Cipher.new 'AES-128-CBC'
-      @salt = '8 octets'
-      @new_key = @cipher.random_key
-      Base64.encode64(@new_key)
-    end
-
-    def source_files(dir, pattern)
-      Dir.glob(dir + "/**/*#{pattern}")
-    end
-
-    def gather_environments(dir, ext)
-      environments = []
-      source_files(dir, ext).each do |source_file|
-        environments << source_file.split('/').last.split('.').first
-      end
-      if environments.empty? 
-        raise EnvironmentError, "No files in the #{dir} directory matching #{ext}"
-      else 
-        environments.uniq
-      end
-    end
-
-    def generate_keys(keys, dir, ext)
-      (keys.empty? ? gather_environments(dir, ext) : keys).each do |key|
-        write_to_file generate_key, "#{dir}/keys/#{key}.key"
-      end
-    end
-
-    def expose(environments, dir, ext)
-      if environments.empty? 
-        environments = gather_environments('./roro/keys', '.key')
-      end 
-      environments.each do |environment| 
-        pattern = "#{environment}*#{ext}" 
-
-        exposable = source_files(dir, pattern)
-        if exposable.empty?
-          puts "No #{environment} files in ./roro matching #{pattern}"
-        end
-        source_files(dir, pattern).each do |file|
-          decrypt(file, environment)
-        end
-      end
-    end
-
-    def obfuscate(envs, dir, ext)
-      environments = envs.empty? ? gather_environments(dir, ext) : envs
-      environments.each do |environment|
-        pattern = "#{environment}*#{ext}" 
-        get_key(environment)
-        encryptable_files = source_files(dir, pattern)
-        if encryptable_files.empty?
-          puts "No #{environment} files in ./roro matching #{pattern}"
-        end 
-        encryptable_files.each do |file|
-          encrypt(file, environment)
-        end
-      end 
-    end
-
-    def write_to_file(data, filename)
-      if File.exist?(filename)
-        raise DataDestructionError, "Existing file at #{filename}. Please remove it and try again."
-      else
-        File.open(filename, "w") { |io| io.write data }
-      end
-    end
-
-    
-    def encrypt(file, key)
-      build_cipher(key)
-      encrypted = @cipher.update(File.read file) + @cipher.final
-      write_to_file(Base64.encode64(encrypted), file + '.enc')
-    end
-    
-    def decrypt(file, key)
-      build_cipher(key)
-      encrypted = Base64.decode64 File.read(file)
-      @cipher.decrypt.pkcs5_keyivgen @pass_phrase, @salt
-      decrypted = @cipher.update(encrypted) + @cipher.final
-      decrypted_file = file.split('.enc').first
-      write_to_file decrypted, decrypted_file
-    end
-    
-    def get_key(environment, dir='roro')
-      env_key = environment.upcase + '_KEY'
-      key_file = Dir.glob("roro/keys/#{environment}.key").first
-      case
-      when ENV[env_key].nil? && key_file.nil?
-        raise KeyError, "No #{env_key} set. Please set one as a variable or in a file."
-      when ENV[env_key]
-        ENV[env_key]
-      when File.exist?(key_file)
-        File.read(key_file).strip
-      end
-    end
-    
-    private 
-    def build_cipher(environment)
-      @cipher = OpenSSL::Cipher.new 'AES-128-CBC'
-      @salt = '8 octets'
-      @pass_phrase = get_key(environment)
-      @cipher.encrypt.pkcs5_keyivgen @pass_phrase, @salt
-    end
-  end
-end

data/lib/roro/stories/rollon/rails/kubernetes/postgresql.yml

@@ -1,10 +0,0 @@
-stories: 
-  - default 
-  - edge
-
-actions: 
-  - template 'rails/.circleci/config.yml.tt', './.circleci/config.yml' 
-  - template 'rails/docker-compose.yml.tt', './docker-compose.yml', @config.env
-  - template 'base/dotenv', './.env', @config.env
-  - directory 'rails/roro', './roro', @config.env
-  - template 'rails/kube.rake.tt', './lib/tasks/kube.rake', @config.env

data/lib/roro/templates/base/.circleci/_aliases.yml

@@ -1,8 +0,0 @@
-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

data/lib/roro/templates/base/.circleci/_commands.yml

@@ -1,31 +0,0 @@
-commands: 
-  setup-docker-builds: 
-    steps: 
-      - setup_remote_docker:
-          docker_layer_caching: false
-
-  source-ci-vars: 
-    steps: 
-      - run: |
-          echo 'source roro/containers/app/ci.env' >> ${BASH_ENV}
-          source ${BASH_ENV} 
-
-  attach-roro: 
-    steps: 
-      - attach_workspace: 
-          at: workspace
-      - run: cp -rf workspace/roro .
-      - source-ci-vars
-
-  tag-and-push:
-    parameters: 
-      deploy_tag: 
-        type: string 
-        default: latest
-    steps:
-      - run: | 
-          SOURCE=$(docker images | grep project_app | awk '{ print $3 }')
-          DOCKER_REPO=${DOCKER_ORG}/${APP_NAME}_app
-          TAGGED_IMAGE=${DOCKER_REPO}:<< parameters.deploy_tag >>
-          docker tag ${SOURCE} ${TAGGED_IMAGE}
-          docker push ${TAGGED_IMAGE}

data/lib/roro/templates/base/.circleci/_defaults.yml

@@ -1,5 +0,0 @@
-defaults: &defaults
-  executor: machine-layer-caching
-  working_directory: ~/project
-  environment:
-    RORO_ENV: ci

data/lib/roro/templates/base/.circleci/_executors.yml

@@ -1,11 +0,0 @@
-executors: 
-  machine-layer-caching:
-    machine: 
-      image: circleci/classic:latest
-      docker_layer_caching: true
-  machine-executor: 
-    machine: 
-      image: circleci/classic:latest
-  ruby-executor: 
-    docker:
-      - image: cimg/ruby:2.7

data/lib/roro/templates/base/.circleci/_major_only.yml

@@ -1,4 +0,0 @@
-major_only: &major_only
-  filters:
-    branches:
-      only: master

data/lib/roro/templates/base/.circleci/_version.yml

@@ -1 +0,0 @@
-version: 2.1

data/lib/roro/templates/base/.circleci/_workflow.yml

@@ -1,2 +0,0 @@
-workflows:
-  version: 2