orats 0.7.3 → 0.8.0

data/lib/orats/commands/nuke.rb

@@ -1,47 +1,55 @@
-require 'orats/commands/common'
+require 'orats/common'
 
 module Orats
   module Commands
+    # delete a path and its data
     class Nuke < Common
       def initialize(target_path = '', options = {})
         super
       end
 
       def init
-        log_nuke_info
-        log_nuke_details unless @options[:skip_data]
+        exit_if_invalid_system
 
-        confirmed_to_delete = yes?('Are you sure? (y/N)', :cyan); puts
-
-        if confirmed_to_delete
-          nuke_data unless @options[:skip_data]
-          nuke_directory
-        end
+        nuke_report
+        nuke_details
+        nuke_data unless @options[:skip_data]
+        nuke_path
       end
 
       private
 
-      def log_nuke_info
-        log_error 'nuke', 'You are about to permanently delete this directory',
-                  'path', File.expand_path(@target_path)
+      def exit_if_path_missing
+        task 'Check if path is missing'
+
+        return if Dir.exist?(@target_path) || File.exist?(@target_path)
+
+        error 'Path was not found', @target_path
+        exit 1
       end
 
-      def log_nuke_details
-        rails_projects = []
+      def nuke_report
+        puts
+        log 'warning', 'You are about to permanently delete this path',
+            :yellow, true
+        log 'nuke path', File.expand_path(@target_path), :white
+        puts
+      end
 
-        valid_rails_directories.each { |rails_dir| rails_projects << File.basename(rails_dir) }
-        project_names = rails_projects.join(', ')
+      def nuke_details
+        rails_apps = []
 
-        log_error 'nuke', 'You are about to permanently delete all postgres databases for',
-                  'databases', project_names, true
+        valid_rails_apps.each do
+          |rails_dir| rails_apps << File.basename(rails_dir)
+        end
 
-        log_error 'nuke', 'You are about to permanently delete all redis namespaces for',
-                  'namespaces', project_names
+        nuke_items(rails_apps) unless @options[:skip_data]
       end
 
-      def valid_rails_directories
+      def valid_rails_apps
         rails_gemfiles =
-            run("find #{@active_path} -type f -name Gemfile | xargs grep -lE \"gem 'rails'|gem \\\"rails\\\"\"",
+            run("find #{@target_path} -type f -name Gemfile | " + \
+                "xargs grep -lE \"gem 'rails'|gem \\\"rails\\\"\"",
                 capture: true)
 
         gemfile_paths = rails_gemfiles.split("\n")
@@ -49,38 +57,52 @@ module Orats
         gemfile_paths.map { |gemfile| File.dirname(gemfile) }
       end
 
-      def nuke_data
-        valid_rails_directories.each do |directory|
-          log_task 'Remove postgres databases'
-          run_from directory, 'bundle exec rake db:drop:all'
-
-          nuke_redis File.basename(directory)
+      def nuke_items(apps)
+        if apps.empty?
+          results 'No apps were found in this path',
+                  'skipping', File.expand_path(@target_path)
+          nuke_path
+          exit
+        else
+          nuke_app_details(apps.join(', '))
         end
       end
 
-      def nuke_redis(namespace)
-        log_task 'Remove redis keys'
+      def nuke_app_details(app_names)
+        puts
+        log 'nuke', 'You are about to permanently delete all postgres' + \
+            ' databases for', :red, true
+        log 'databases', app_names, :yellow
+        puts
+        log 'nuke', 'You are about to permanently delete all redis' + \
+            ' namespaces for', :red, true
+        log 'namespaces', app_names, :yellow
+        puts
+
+        exit unless yes?('Are you sure? (y/N)', :cyan)
+      end
 
-        while not_able_to_nuke_redis?(@options[:redis_password], namespace)
-          log_status_top 'error', "The redis password you supplied was incorrect\n", :red
-          new_password = ask('Enter the correct password or CTRL+C to quit:', :cyan)
-          puts
+      def nuke_data
+        valid_rails_apps.each do |app|
+          task 'Delete postgres database'
+          drop_database app
 
-          break unless not_able_to_nuke_redis?(new_password, namespace)
+          task 'Delete redis keys'
+          drop_namespace File.basename(app)
         end
       end
 
-      def not_able_to_nuke_redis?(password, namespace)
-        password.empty? ? redis_password = '' : redis_password = "-a #{password}"
-        redis_out = run("redis-cli #{redis_password} KEYS '#{namespace}:*' | xargs --delim='\n' redis-cli #{redis_password} DEL", capture: true)
+      def nuke_path
+        exit_if_path_missing
 
-        redis_out.include?('NOAUTH Authentication required')
-      end
+        task 'Delete path'
+
+        return if @options[:skip_data]
 
-      def nuke_directory
-        log_task 'Delete directory'
-        run "rm -rf #{@active_path}"
+        puts
+        exit unless yes?('Are you sure? (y/N)', :cyan)
+        run "rm -rf #{@target_path}"
       end
     end
   end
-end
+end

data/lib/orats/common.rb

@@ -0,0 +1,76 @@
+require 'orats/postgres'
+require 'orats/process'
+require 'orats/redis'
+require 'orats/shell'
+require 'orats/ui'
+
+module Orats
+  # common class that other CLI driven classes subclass
+  class Common
+    include Thor::Base
+    include Thor::Shell
+    include Thor::Actions
+    include Shell
+    include UI
+    include Process
+    include Postgres
+    include Redis
+
+    def initialize(target_path = '', options = {})
+      @target_path = target_path
+      @options     = options
+
+      self.destination_root = Dir.pwd
+      @behavior             = :invoke
+    end
+
+    def base_path
+      File.join(File.expand_path(File.dirname(__FILE__)))
+    end
+
+    def url_to_string(url)
+      open(url).read
+      rescue *[OpenURI::HTTPError, SocketError] => ex
+        error 'Unable to access URL', ex
+        exit 1
+    end
+
+    def file_to_string(path)
+      if File.exist?(path) && File.file?(path)
+        IO.read path
+      else
+        error 'Path not found', path
+        exit 1
+      end
+    end
+
+    def exit_if_path_exists(extend_path = '')
+      task 'Check if path exists'
+
+      extended_path = @target_path.dup
+
+      unless extend_path.empty?
+        extended_path = File.join(extended_path, extend_path)
+      end
+
+      return unless Dir.exist?(extended_path) || File.exist?(extended_path)
+
+      error 'Path already exists', extended_path
+      exit 1
+    end
+
+    def exit_if_invalid_system
+      exit_if_process :not_found, 'rails', 'git', 'psql', 'redis-cli'
+      exit_if_process :not_running, 'postgres', 'redis'
+
+      exit_if_postgres_unreachable
+      exit_if_redis_unreachable
+    end
+
+    def run_rake(command)
+      task 'Run rake command'
+
+      run_from @target_path, "bundle exec rake #{command}"
+    end
+  end
+end

data/lib/orats/postgres.rb

@@ -0,0 +1,90 @@
+module Orats
+  # manage the postgres process
+  module Postgres
+    def postgres_bin(bin_name = 'psql')
+      exec = "#{bin_name} -h #{@options[:pg_location]} -U " + \
+                      "#{@options[:pg_username]}"
+
+      return exec if @options[:pg_password].empty?
+      exec.prepend("PGPASSWORD=#{@options[:pg_password]} ")
+    end
+
+    def create_database
+      if local_postgres?
+        run_rake 'db:create:all'
+      else
+        manually_create_postgres_db
+      end
+    end
+
+    def drop_database(name)
+      if local_postgres?
+        run_rake 'db:drop:all'
+      else
+        manually_delete_postgres_db File.basename(name)
+      end
+    end
+
+    def exit_if_postgres_unreachable
+      task 'Check if you can connect to postgres'
+
+      return if run("#{postgres_bin} -c 'select 1'")
+
+      error 'Cannot connect to postgres', 'attempt to SELECT 1'
+      exit 1
+    end
+
+    def exit_if_database_exists
+      task 'Check if the postgres database exists'
+
+      # detect if the database already exists
+      database = File.basename(@target_path)
+      return if run("#{postgres_bin} -d #{database} -l | " + \
+                    "grep #{database} | wc -l", capture: true).chomp == '0'
+
+      error "'#{database}' database already exists",
+            'attempt to check database existence'
+      puts
+
+      exit 1 unless yes?('Would you like to continue anyways? (y/N)',
+                         :cyan)
+    end
+
+    private
+
+    def local_postgres?
+      @options[:pg_location] == 'localhost' ||
+      @options[:pg_location] == '127.0.0.1'
+    end
+
+    def manually_create_postgres_db
+      database = File.basename(@target_path)
+      test_database = "#{database}_test"
+
+      createdb(database)
+      createdb(test_database)
+    end
+
+    def createdb(database)
+      return if run("#{postgres_bin('createdb')} #{database}")
+
+      log 'Skipped creating postgres database',
+          "#{database} already exists", :yellow
+    end
+
+    def manually_delete_postgres_db(name)
+      database = File.basename(name)
+      test_database = "#{database}_test"
+
+      dropdb(database)
+      dropdb(test_database)
+    end
+
+    def dropdb(database)
+      return if run("#{postgres_bin('dropdb')} #{database}")
+
+      log 'Skipped dropping postgres database',
+          "#{database} does not exists", :yellow
+    end
+  end
+end

data/lib/orats/process.rb

@@ -0,0 +1,35 @@
+module Orats
+  # manage detecting processes
+  module Process
+    def exit_if_process(detect_method, *processes)
+      result = process_detect(detect_method)
+
+      processes.each do |process|
+        task "Check if #{process} is available"
+
+        exit 1 if process_unusable?("#{result} #{process}", process)
+      end
+    end
+
+    private
+
+    def process_detect(method)
+      if method == :not_found
+        'which'
+      elsif method == :not_running
+        'ps cax | grep'
+      end
+    end
+
+    def process_unusable?(command, process)
+      out = run(command, capture: true)
+
+      if out.empty?
+        error "Cannot detect #{process}",
+              'trying to do `which` on it'
+      end
+
+      out.empty?
+    end
+  end
+end

data/lib/orats/redis.rb

@@ -0,0 +1,25 @@
+module Orats
+  # manage the redis process
+  module Redis
+    def redis_bin(bin_name = 'redis-cli')
+      exec = "#{bin_name} -h #{@options[:redis_location]}"
+
+      return exec if @options[:redis_password].empty?
+      exec << " -a #{@options[:redis_password]}"
+    end
+
+    def drop_namespace(namespace)
+      run "#{redis_bin} KEYS '#{namespace}:*'| " + \
+          "xargs --delim='\n' #{redis_bin} DEL"
+    end
+
+    def exit_if_redis_unreachable
+      task 'Check if you can ping redis'
+
+      return if run("#{redis_bin} ping")
+
+      error 'Cannot ping redis', 'attempt to PING'
+      exit 1
+    end
+  end
+end

data/lib/orats/shell.rb

@@ -0,0 +1,12 @@
+module Orats
+  # execute various shell commands
+  module Shell
+    def run_from(path, command)
+      run "cd #{path} && #{command} && cd -"
+    end
+
+    def commit(message)
+      run_from @target_path, "git add -A && git commit -m '#{message}'"
+    end
+  end
+end