orats 0.5.1 → 0.6.0

data/lib/orats/commands/new/rails.rb

@@ -0,0 +1,107 @@
+module Orats
+  module Commands
+    module New
+      module Rails
+        def rails_template(command, flags = '')
+          exit_if_cannot_rails
+          exit_if_exists unless flags.index(/--skip/)
+
+          orats_template = "--template #{base_path}/templates/#{command}.rb"
+
+          run "rails new #{@active_path} #{flags} --skip-bundle #{orats_template unless command.empty?}"
+          yield if block_given?
+        end
+
+        def custom_rails_template
+          log_thor_task 'shell', 'Running custom rails template'
+
+          @options[:template].include?('://') ? url_to_string(@options[:template])
+                                               : file_to_string(@options[:template])
+
+          rails_template '', "--skip --template #{@options[:template]}"
+        end
+
+        def gsub_postgres_info
+          log_thor_task 'root', 'Changing the postgres information'
+          gsub_file "#{@active_path}/.env", 'DATABASE_HOST: localhost', "DATABASE_HOST: #{@options[:pg_location]}"
+          gsub_file "#{@active_path}/.env", ': postgres', ": #{@options[:pg_username]}"
+          gsub_file "#{@active_path}/.env", ': supersecrets', ": #{@options[:pg_password]}"
+
+          git_commit 'Change the postgres information'
+        end
+
+        def gsub_redis_info
+          log_thor_task 'root', 'Adding the redis password'
+          gsub_file "#{@active_path}/config/initializers/sidekiq.rb", '//', "//:#{ENV['CACHE_PASSWORD']}@"
+          gsub_file "#{@active_path}/.env", 'HE_PASSWORD: ', "HE_PASSWORD: #{@options[:redis_password]}"
+          gsub_file "#{@active_path}/.env", 'CACHE_HOST: localhost', "CACHE_HOST: #{@options[:redis_location]}"
+          gsub_file "#{@active_path}/config/application.rb", '# pass', 'pass'
+
+          git_commit 'Add the redis password'
+        end
+
+        def gsub_project_path
+          log_thor_task 'root', 'Changing the project path'
+          gsub_file "#{@active_path}/.env", ': /full/path/to/your/project', ": #{File.expand_path(@active_path)}"
+
+          git_commit 'Add the development project path'
+        end
+
+        def bundle_install
+          log_thor_task 'shell', 'Running bundle install, this may take a while'
+          run_from @active_path, 'bundle install'
+
+          git_commit 'Add gem lock file'
+        end
+
+        def bundle_binstubs
+          log_thor_task 'shell', 'Running bundle binstubs for a few gems'
+          run_from @active_path, 'bundle binstubs whenever puma sidekiq backup'
+
+          git_commit 'Add binstubs for the important gems'
+        end
+
+        def spring_binstub
+          log_thor_task 'shell', 'Running spring binstub'
+          run_from @active_path, 'bundle exec spring binstub --all'
+
+          git_commit 'Springify all of the bins'
+        end
+
+        def run_rake(command)
+          log_thor_task 'shell', 'Running rake commands'
+
+          run_from @active_path, "bundle exec rake #{command}"
+        end
+
+        def create_and_migrate_database
+          run_rake 'db:create:all db:migrate'
+          git_commit 'Add the database schema file'
+        end
+
+        private
+
+        def exit_if_cannot_rails
+          log_thor_task 'shell', 'Checking for rails'
+
+          has_rails = run('which rails', capture: true)
+
+          log_error 'error', 'Cannot access rails', 'question', 'Are you sure you have rails setup correctly?', true do
+            log_status_bottom 'tip', 'You can install it by running `gem install rails`', :white
+          end if has_rails.empty?
+
+          exit 1 if has_rails.empty?
+        end
+
+        def exit_if_exists
+          log_thor_task 'shell', 'Checking if a file or directory already exists'
+
+          if Dir.exist?(@active_path) || File.exist?(@active_path)
+            log_error 'error', 'A file or directory already exists at this location', 'path', @active_path
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/orats/commands/nuke.rb

@@ -0,0 +1,72 @@
+require 'orats/commands/common'
+
+module Orats
+  module Commands
+    class Nuke < Common
+      def initialize(target_path = '', options = {})
+        super
+      end
+
+      def init
+        log_nuke_info
+        log_nuke_details unless @options[:skip_data]
+
+        confirmed_to_delete = yes?('Are you sure? (y/N)', :cyan); puts
+
+        if confirmed_to_delete
+          nuke_data unless @options[:skip_data]
+          nuke_directory
+        end
+      end
+
+      private
+
+      def log_nuke_info
+        log_error 'nuke', 'You are about to permanently delete this directory',
+                  'path', File.expand_path(@target_path)
+      end
+
+      def log_nuke_details
+        rails_projects = []
+
+        valid_rails_directories.each { |rails_dir| rails_projects << File.basename(rails_dir) }
+        project_names = rails_projects.join(', ')
+
+        log_error 'nuke', 'You are about to permanently delete all postgres databases for',
+                  'databases', project_names, true
+
+        log_error 'nuke', 'You are about to permanently delete all redis namespaces for',
+                  'namespaces', project_names
+      end
+
+      def valid_rails_directories
+        rails_gemfiles =
+            run("find #{@active_path} -type f -name Gemfile | xargs grep -lE \"gem 'rails'|gem \\\"rails\\\"\"",
+                capture: true)
+
+        gemfile_paths = rails_gemfiles.split("\n")
+
+        gemfile_paths.map { |gemfile| File.dirname(gemfile) }
+      end
+
+      def nuke_data
+        valid_rails_directories.each do |directory|
+          log_thor_task 'root', 'Removing postgres databases'
+          run_from directory, 'bundle exec rake db:drop:all'
+
+          nuke_redis File.basename(directory)
+        end
+      end
+
+      def nuke_redis(namespace)
+        log_thor_task 'root', 'Removing redis keys'
+        run "redis-cli KEYS '#{namespace}:*' | xargs --delim='\n' redis-cli DEL"
+      end
+
+      def nuke_directory
+        log_thor_task 'root', 'Deleting directory'
+        run "rm -rf #{@active_path}"
+      end
+    end
+  end
+end

data/lib/orats/commands/outdated/compare.rb

@@ -0,0 +1,100 @@
+module Orats
+  module Commands
+    module Outdated
+      module Compare
+        def remote_to_local_gem_versions
+          log_remote_info 'gem', 'Comparing this version of orats to the latest orats version',
+                          'version', "Latest: #{@remote_gem_version}, Yours: v#{VERSION}"
+        end
+
+        def remote_to_local_galaxyfiles
+          galaxyfile_diff = @remote_galaxyfile - @local_galaxyfile
+          local_galaxyfile_as_string = @local_galaxyfile.join
+          local_galaxyfile_roles = @local_galaxyfile.size
+          roles_diff_count = galaxyfile_diff.size
+
+          log_status_top 'roles', "Comparing this version of orats' roles to the latest version:", :green
+
+          if roles_diff_count == 0
+            log_status_bottom 'message', "All #{local_galaxyfile_roles} roles are up to date", :yellow
+          else
+            log_status_bottom 'message', "There are #{roles_diff_count} differences", :yellow
+
+            galaxyfile_diff.each do |line|
+              name = line.split(',').first
+              status = 'outdated'
+              color = :yellow
+
+              unless local_galaxyfile_as_string.include?(name)
+                status = 'missing'
+                color = :red
+              end
+
+              log_status_bottom status, name, color, true
+            end
+
+            log_results 'The latest version of orats may benefit you', 'Check github to see if the changes interest you'
+          end
+        end
+
+        def remote_to_local(label, keyword, remote, local)
+          item_diff = remote - local
+          item_diff_count = item_diff.size
+
+          log_remote_info label, "Comparing this version of orats' #{label} to the latest version",
+                          'file', label == 'playbook' ? 'site.yml' : 'all.yml'
+
+          item_diff.each do |line|
+            log_status_bottom 'missing', line, :red, true unless local.include?(line)
+          end
+
+          if item_diff_count > 0
+            log_results "#{item_diff_count} new #{keyword} are available",
+                        'You may benefit from upgrading to the latest orats'
+          else
+            log_results 'Everything appears to be in order', "No missing #{keyword} were found"
+          end
+        end
+
+        def local_to_user(label, keyword, flag_path, local)
+          user = yield
+
+          log_local_info label, "Comparing this version of orats' #{label} to #{File.basename(flag_path)}",
+                         'path', flag_path
+
+          missing_count = log_unmatched(local, user, 'missing', :red)
+          extra_count = log_unmatched(user, local, 'extra', :yellow)
+
+          if missing_count > 0
+            log_results "#{missing_count} #{keyword} are missing",
+                        "Your ansible run will likely fail with this #{label}"
+          else
+            log_results 'Everything appears to be in order', "No missing #{keyword} were found"
+          end
+
+          if extra_count > 0
+            log_results "#{extra_count} extra #{keyword} were detected:",
+                        "No problem but remember to add them to future #{keyword}"
+          else
+            log_results "No extra #{keyword} were found:", "Extra #{keyword} are fine but you have none"
+          end
+        end
+
+        private
+
+        def log_unmatched(compare, against, label, color)
+          count = 0
+
+          compare.each do |item|
+            unless against.include?(item)
+              log_status_bottom label, item, color, true
+              count += 1
+            end
+          end
+
+          count
+        end
+      end
+    end
+  end
+end

data/lib/orats/commands/outdated/exec.rb

@@ -0,0 +1,46 @@
+require 'orats/commands/common'
+require 'orats/version'
+require 'orats/commands/outdated/parse'
+require 'orats/commands/outdated/compare'
+
+module Orats
+  module Commands
+    module Outdated
+      class Exec < Commands::Common
+        include Parse
+        include Compare
+
+        def initialize(target_path = '', options = {})
+          super
+
+          @remote_galaxyfile = galaxyfile url_to_string(@remote_paths[:galaxyfile])
+          @remote_inventory = inventory url_to_string(@remote_paths[:inventory])
+          @remote_playbook = playbook url_to_string(@remote_paths[:playbook])
+
+          @local_galaxyfile = galaxyfile file_to_string(@local_paths[:galaxyfile])
+          @local_inventory = inventory file_to_string(@local_paths[:inventory])
+          @local_playbook = playbook file_to_string(@local_paths[:playbook])
+        end
+
+        def init
+          remote_to_local_gem_versions
+          remote_to_local_galaxyfiles
+          remote_to_local 'inventory', 'variables', @remote_inventory, @local_inventory
+          remote_to_local 'playbook', 'roles', @remote_playbook, @local_playbook
+
+          unless @options[:playbook].empty?
+            local_to_user('playbook', 'roles', @options[:playbook], @local_playbook) do
+              playbook file_to_string(@options[:playbook])
+            end
+          end
+
+          unless @options[:inventory].empty?
+            local_to_user('inventory', 'variables', @options[:inventory], @local_inventory) do
+              inventory file_to_string(@options[:inventory])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/orats/commands/outdated/parse.rb

@@ -0,0 +1,62 @@
+module Orats
+  module Commands
+    module Outdated
+      module Parse
+        def gem_version
+          "v#{url_to_string(@remote_paths[:version]).match(/'(.*)'/)[1..-1].first}"
+        end
+
+        def galaxyfile(contents)
+          contents.split
+        end
+
+        def inventory(contents)
+          # pluck out all of the values contained with {{ }}
+          ansible_variables = contents.scan(/\{\{([^{{}}]*)\}\}/)
+
+          # remove the leading space
+          ansible_variables.map! { |line| line.first[0] = '' }
+
+          # match every line that is not a comment and contains a colon
+          inventory_variables = contents.scan(/^[^#].*:/)
+
+          inventory_variables.map! do |line|
+            # only strip lines that need it
+            line.strip! if line.include?(' ') || line.include?("\n")
+
+            # get rid of the trailing colon
+            line.chomp(':')
+
+            # if a value of a certain variable has a colon then the regex
+            # picks this up as a match. only take the variable name
+            # if this happens to occur
+            line.split(':').first if line.include?(':')
+          end
+
+          (ansible_variables + inventory_variables).uniq.delete_if(&:empty?)
+        end
+
+        def playbook(contents)
+          roles = contents.scan(/^.*role:.*/)
+
+          roles.map! do |line|
+            line.strip! if line.include?(' ') || line.include?("\n")
+
+            role_parts = line.split('role:')
+
+            # start at the actual role name
+            line = role_parts[1]
+
+            if line.include?(',')
+              line = line.split(',').first
+            end
+
+            line.strip! if line.include?(' ')
+          end
+
+          roles.uniq
+        end
+      end
+    end
+  end
+end

data/lib/orats/commands/play.rb

@@ -0,0 +1,34 @@
+require 'orats/commands/common'
+require 'orats/commands/new/rails'
+
+module Orats
+  module Commands
+    class Play < Common
+      include New::Rails
+
+      def initialize(target_path = '', options = {})
+        super
+      end
+
+      def init
+        return unless can_play?
+        rails_template 'play'
+        custom_rails_template unless @options[:template].empty?
+      end
+
+      private
+
+      def can_play?
+        log_thor_task 'shell', 'Checking for the ansible binary'
+
+        has_ansible = run('which ansible', capture: true)
+
+        log_error 'error', 'Cannot access ansible', 'question', 'Are you sure you have ansible setup correctly?', true do
+          log_status_bottom 'tip', 'http://docs.ansible.com/intro_installation.html', :white
+        end if has_ansible.empty?
+
+        !has_ansible.empty?
+      end
+    end
+  end
+end

data/lib/orats/commands/ui.rb

@@ -0,0 +1,52 @@
+module Orats
+  module Commands
+    module UI
+      include Thor::Shell
+
+      def log_thor_task(type, message)
+        puts
+        say_status  type, "#{message}...", :yellow
+        puts        '-'*80, ''; sleep 0.25
+      end
+
+      def log_status_top(type, message, color)
+        puts
+        say_status type, set_color(message, :bold), color
+      end
+
+      def log_status_bottom(type, message, color, strip_newline = false)
+        say_status type, message, color
+        puts unless strip_newline
+      end
+
+      def log_results(results, message)
+        log_status_top 'results', "#{results}:", :magenta
+        log_status_bottom 'message', message, :white
+      end
+
+      def log_error(top_label, top_message, bottom_label, bottom_message, strip_newline = false)
+        log_status_top top_label, "#{top_message}:", :red
+        log_status_bottom bottom_label, bottom_message , :yellow, strip_newline
+        yield if block_given?
+      end
+
+      def log_remote_info(top_label, top_message, bottom_label, bottom_message)
+        log_status_top top_label, "#{top_message}:", :green
+        log_status_bottom bottom_label, bottom_message, :yellow
+      end
+
+      def log_local_info(top_label, top_message, bottom_label, bottom_message)
+        log_status_top top_label, "#{top_message}:", :blue
+        log_status_bottom bottom_label, bottom_message, :cyan
+      end
+
+      def run_from(path, command)
+        run "cd #{path} && #{command} && cd -"
+      end
+
+      def git_commit(message)
+        run_from @active_path, "git add -A && git commit -m '#{message}'"
+      end
+    end
+  end
+end