roro 0.3.21 → 0.3.25

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

@@ -1,69 +0,0 @@
-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)
-        environments = args.first ? [args.first] : gather_environments
-        environments.each do |environment|
-          
-          confirm_files_decrypted?(environment)
-          create_file "roro/keys/#{environment}.key", encoded_key
-        end
-      end
-
-      def encoded_key
-        @cipher = OpenSSL::Cipher.new 'AES-128-CBC'
-        @salt = '8 octets'
-        @new_key = @cipher.random_key
-        Base64.encode64(@new_key)
-      end
-
-      def gather_environments
-        environments = []
-        ['.env', '.env.enc'].each do |extension|
-          Roro::Crypto.source_files('roro', extension).each do |env_file|
-            environments << env_file.split('/').last.split(extension).last
-          end
-        end
-        environments.uniq
-      end
-
-      def confirm_files_decrypted?(environment)
-        orphan_encrypted = []
-        Roro::Crypto.source_files('.', '.env.enc').each do |file|
-          unless File.exist? file.split('.enc').first
-            orphan_encrypted << file 
-          end
-        end
-        if !orphan_encrypted.empty?
-          raise Roro::Error.new("You have an encrypted files (.env.enc) #{orphan_encrypted} that do not have corresponding decrypted files (.env). Please decrypt or remove these encrypted files before generating a new key for #{environment}.")
-        end
-        true
-      end
-    end
-  end
-end

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

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

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

@@ -1,14 +0,0 @@
-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/rails/base/base.rb

@@ -1,4 +0,0 @@
-
-require_relative 'insertions.rb'
-require_relative 'insert_gems.rb'
-

data/lib/roro/cli/rollon/rails/base/insert_gems.rb

@@ -1,23 +0,0 @@
-
-module Roro
-
-  class CLI < Thor
-    
-    no_commands do 
-          
-      def insert_roro_gem_into_gemfile
-        insert_into_file 'Gemfile', "gem 'roro'\n\n", before: "group :development, :test do"
-      end
-      
-      def insert_db_gem(gem)
-        gems = %w(sqlite pg mysql2)
-        gems.each { |g| gsub_file('Gemfile', /.*#{g}.*/, '')}
-        insert_into_file 'Gemfile', "gem '#{gem}'\n\n", before: "group :development, :test"
-      end
-
-      def insert_hfci_gem_into_gemfile
-        insert_into_file 'Gemfile', "gem 'handsome_fencer-test'\n\n", after: "group :development, :test do"
-      end  
-    end
-  end 
-end

data/lib/roro/cli/rollon/rails/base/insertions.rb

@@ -1,27 +0,0 @@
-
-module Roro
-
-  class CLI < Thor
-    
-    no_commands do 
-          
-      def config_std_out_true
-        file = 'config/boot.rb'
-        line = "$stdout.sync = true\n\n"
-        prepend_to_file(file, line, force: true)
-      end 
-      
-      def copy_dockerignore 
-        copy_file 'base/.dockerignore', '.dockerignore'
-      end 
-      
-      def gitignore_sensitive_files
-        append_to_file ".gitignore", "\nroro/**/*.env\nroro/**/*.key"
-        append_to_file ".gitignore", "\nroro/**/*.env\nroro/**/*.key"
-        append_to_file ".gitignore", "\n*kubeconfig.yaml"
-        append_to_file ".gitignore", "\n*kubeconfig.yml"
-        append_to_file ".gitignore", "\n*.roro_configurator.yml"
-      end
-    end
-  end 
-end

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