roro 0.3.13 → 0.3.21

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

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

data/lib/roro/cli/{base → rollon/rails/base}/insert_gems.rb

@@ -10,16 +10,8 @@ module Roro
       end
       
       def insert_db_gem(gem)
-        gem_lines = [
-          /gem\s['"]sqlite3['"]/,
-          /gem\s['"]mysql2['"]/,
-          /gem\s['"]pg['"]/,
-          
-        ]
-        gem_lines.each do |line| 
-          comment_lines 'Gemfile', line 
-          gsub_file 'Gemfile', line, 'gem copied over by roro'
-        end
+        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
 

data/lib/roro/cli/{base → rollon/rails/base}/insertions.rb

@@ -11,8 +11,16 @@ module Roro
         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 

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

@@ -0,0 +1,26 @@
+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/{stories/rails → rails}/database/with_mysql.rb

@@ -6,13 +6,13 @@ module Roro
       
       def configure_for_mysql 
         insert_db_gem('mysql2')
-        copy_file 'base/config/database.mysql.yml', 'config/database.yml', force: true
-        config = @config.app.clone
+        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
+          config[:rails_env] = environment
           
-          source = 'base/.env/database.mysql.env.tt'
+          source = 'rails/dotenv/database.mysql.env.tt'
           target = "roro/containers/database/#{environment}.env" 
           template( source, target, config )
         end

data/lib/roro/cli/rollon/{stories/rails → rails}/database/with_postgresql.rb

@@ -5,14 +5,13 @@ module Roro
     no_commands do
       
       def configure_for_pg 
-        insert_db_gem('pg')
-        copy_file 'base/config/database.pg.yml', 'config/database.yml', force: true
-        config = @config.app.clone
+        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
+          config[:rails_env] = environment
           
-          source = 'base/.env/database.pg.env.tt'
-          target = "roro/containers/database/#{environment}.env" 
+          source = 'rails/dotenv/database.pg.env.tt'
+          target = "roro/containers/database/#{environment}.env"
           template( source, target, config )
         end
       end

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

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

data/lib/roro/cli/rollon/{stories/ruby_gem → ruby_gem}/with_ci_cd.rb

@@ -6,26 +6,26 @@ module Roro
 
     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)
-        configure_for_rollon
         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.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/cli/rollon/stories.rb

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

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