roro 0.3.17 → 0.3.18

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

@@ -15,17 +15,17 @@ module Roro
           './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.app['rubygems_api_key'] = rubygems_api_key
-        @config.app['rubies'] = [] 
+        @config.env[:rubygems_api_key] = rubygems_api_key
+        @config.env[:rubies] = [] 
         3.times do |index| 
-          newruby = @config.app['ruby_version'].gsub('.', '').to_i - index
-          @config.app['rubies'] << newruby.to_s.split('').join('.')
+          newruby = @config.env[:ruby_version].gsub('.', '').to_i - index
+          @config.env[:rubies] << newruby.to_s.split('').join('.')
         end
-        directory 'ruby_gem/roro', './roro', @config.app
-        directory 'ruby_gem/.circleci', './.circleci', @config.app
+        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.app['rubies'].each do |ruby| 
+        @config.env[:rubies].each do |ruby| 
           file = '.circleci/config.yml'
           spacer = "\n      - run: "
           rv = "RUBY_VERSION=#{ruby} docker-compose "

data/lib/roro/configurator.rb

@@ -0,0 +1,15 @@
+require 'roro/configurator/eligibility'
+require 'roro/configurator/okonomi'
+require 'roro/configurator/omakase'
+
+module Roro 
+  module Configurator 
+    include Eligibility
+    include Okonomi
+    include Omakase
+  end
+  
+  class Configuration < Thor
+    include Roro::Configurator
+  end
+end

data/lib/roro/configurator/eligibility.rb

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

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

@@ -0,0 +1,170 @@
+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/stories/greenfield.yml

@@ -0,0 +1 @@
+stories: rails

data/lib/roro/stories/greenfield/rails.yml

@@ -0,0 +1,9 @@
+greenfield_actions:
+  - "@config.env['force'] = true"
+  - |
+    src = 'rails/Dockerfile.greenfield.tt'
+    dest = 'roro/containers/app/Dockerfile'
+    template src, dest, @config.env
+  
+greenfield_commands: 
+  - system "DOCKER_BUILDKIT=1 docker build --file roro/containers/app/Dockerfile --output . ."

data/lib/roro/stories/rollon.yml

@@ -0,0 +1,42 @@
+stories: rails
+
+intentions: 
+
+env_vars: 
+  main_app_name: 
+  developer: 
+    name: your-name
+    email: your.email@example.com
+  docker_email: your-docker-registry-email
+  docker_org: your-docker-registry-org-name
+  docker_password: your-docker-registry-password
+  docker_token: your-docker-registry-token
+  docker_username: your-docker-registry-user-name
+    
+choices:
+  
+  generate_config_story:
+    question: |
+      Would you like to create a Roro Config file to help with debugging, 
+      sharing your desired story, or both?
+    choices: 
+      y: 'Yes'
+      n: 'No'
+    default: y 
+      
+  backup_existing_files: 
+    question: |
+      RoRo will be generating a number of files, some of which will 
+      replace existing ones. Would you like to back them up?
+    choices: 
+      y: 'Yes'
+      n: 'No' 
+    default: n
+
+  copy_dockerignore:
+    question: |
+      Would you like to create a .dockerignore file?
+    choices: 
+      y: 'Yes'
+      n: 'No'
+    default: y

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

@@ -0,0 +1,76 @@
+stories: 
+  - database  
+  - ci_cd
+  - kubernetes
+
+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
+  - chmod "roro/docker-entrypoint.sh", 0755
+
+
+startup: 
+  success: "Your app should be available at http://localhost:3000"
+  commands: 
+    - docker-compose build --no-cache
+    - docker-compose up -d
+    - docker-compose run app bin/rails db:create
+    - docker-compose run app bin/rails db:migrate
+    - 'docker-compose run app echo #{success_msg}'
+
+env_vars: 
+  ruby_version: '2.7'
+  database_host: database
+  frontend_service: frontend
+  database_service: database
+
+choices:
+  config_std_out_true: 
+    question: |
+      The team at Heroku, among others, recommend logging to STDOUT 
+      and treating your logs as streams. We'll set this to 
+      true as an environment variable but it may also be helpful
+      to configure './config/boot.rb' with '$stdout.sync = true' 
+      just in case that doesn't work. 
+      Would you like to configure this? 
+    choices: 
+      y: 'Yes'
+      n: 'No'
+    default: y
+
+  insert_roro_gem_into_gemfile: 
+    question: |
+      Many developers believe it's good idea to secure sensitive 
+      environment files and variables. You can use RoRo to 
+      generate secret keys known only to you for use in any
+      environment, and then use them to encrypt and decrypt 
+      these files. Would you like to add RoRo to your Gemfile?
+    choices: 
+      y: 'Yes'
+      n: 'No'
+    default: n
+        
+  gitignore_sensitive_files:
+    question: | 
+      If you plan to use the environment files RoRo generates for 
+      your own environment variables, it's a good idea to keep 
+      these files out of source control. Would you like RoRo to 
+      modify your .gitignore file to accomplish this for you ?
+    choices: 
+      y: 'Yes'
+      n: 'No'
+    default: y
+      
+  insert_hfci_gem_into_gemfile: 
+    question: | 
+      Jim Weirich passed too soon and remains missed. In addition 
+      to Rake, Jim wrote a beautiful gem called 'Given' that makes 
+      Rspec and Minitest less ugly and thus your tests more easy to 
+      write. Would you like to install a gem called 
+      handsome_fencer-test that allows you to try it out?
+    choices: 
+      y: 'Yes'
+      n: 'No' 
+    default: n