greenhat 0.2.0 → 0.3.0

data/lib/greenhat/shell/page.rb

@@ -3,14 +3,18 @@ module GreenHat
     # Helper to organize page check / methods
     module Page
       # Check if paging should be skipped
-      def self.skip?(args, data)
-        return count_rows(data) unless args[:page]
+      # True / False / Not Set
+      def self.skip?(flags, data)
+        # Pass if Explicitly Set / Inverse for skip
+        return !flags[:page] if flags.key? :page
 
-        args[:page].first == :false
+        LogBot.debug('Page', count_rows(data, flags)) if ENV['DEBUG']
+
+        count_rows(data, flags)
       end
 
       # Array/Hash and String pagination check. Don't unncessarily loop through everything
-      def self.count_rows(data)
+      def self.count_rows(data, flags)
         height = TTY::Screen.height
         size = 0
 
@@ -19,7 +23,9 @@ module GreenHat
                   when Hash then entry.keys.count
                   when Array then entry.count
                   else
-                    1
+                    # Each Boxed Entry is 3 Lines
+                    flags.key?(:row_size) ? flags[:row_size] : 1
+
                   end
 
           break if size > height

data/lib/greenhat/shell/process.rb

@@ -11,16 +11,22 @@ module GreenHat
       end
 
       def self.help
-        puts "\u2500".colorize(:cyan) * 20
-        puts "#{'Process'.colorize(:yellow)} -  ps helper"
-        puts "\u2500".colorize(:cyan) * 20
+        puts "\u2500".pastel(:cyan) * 22
+        puts "#{'Process'.pastel(:yellow)} -  ps helper"
+        puts "\u2500".pastel(:cyan) * 22
 
-        puts 'Command Summary'.colorize(:blue)
-        puts '  ps'.colorize(:green)
+        ShellHelper.common_opts
+
+        puts 'Command Summary'.pastel(:blue)
+        puts '  ps'.pastel(:green)
         puts '    Raw `ps`'
-        puts '  filter'.colorize(:green)
-        puts '    Key/Field Filtering'
-        puts '    - See `filter_help`'
+        puts
+        puts '  filter'.pastel(:green)
+        puts "    Key/Field Filtering.  See #{'filter_help'.pastel(:blue)}"
+        puts '    Examples'
+        puts '      filter --sort=mem --reverse'.pastel(:green)
+        puts '      filter --user=gitlab'.pastel(:green)
+
         puts
       end
 
@@ -29,25 +35,31 @@ module GreenHat
       end
 
       def self.ps(raw = {})
-        _log_list, _1opts, args = ShellHelper.param_parse(raw)
-        ShellHelper.file_output GreenHat::Ps.ps(args)
+        # Extract Args
+        files_list, flags, _args = Args.parse(raw)
+
+        # Collect Files
+        files = ShellHelper.files(files_list, GreenHat::Ps.things, flags)
+
+        # Output
+        ShellHelper.file_output(files, flags)
       end
 
       def self.filter(raw = {})
-        _log_list, opts, args = ShellHelper.param_parse(raw)
+        # Argument Parsing
+        files, flags, args = Args.parse(raw)
 
-        # AND / OR Filtering
-        filter_type = args.or ? :any? : :all?
+        # Prepare Log List
+        file_list = ShellHelper.prepare_list(files, GreenHat::Ps.things)
 
-        # ShellHelper.file_output
-        results = ShellHelper.filter_start(GreenHat::Ps.ps(args).map(&:name), filter_type, args, opts)
+        results = ShellHelper.filter_start(file_list, flags, args)
 
         # Check Search Results
         if results.instance_of?(Hash) && results.values.flatten.empty?
-          puts 'No results'.colorize(:red)
+          puts 'No results'.pastel(:red)
         else
           # This causes the key 'colorized' output to also be included
-          ShellHelper.show(results.to_a.compact.flatten, args)
+          ShellHelper.show(results.to_a.compact.flatten, flags)
         end
       end
     end

data/lib/greenhat/shell/report.rb

@@ -45,11 +45,11 @@ module GreenHat
 
     def show
       output = [
-        archive.friendly_name.colorize(:blue)
+        archive.friendly_name.pastel(:blue)
       ]
 
       # OS
-      output << 'OS'.colorize(:light_yellow)
+      output << 'OS'.pastel(:bright_yellow)
       output << hostname if host
       output << distro if os_release
       output << selinux if selinux_status
@@ -62,7 +62,7 @@ module GreenHat
 
       # Memory
       if meminfo || free_m
-        output << 'Memory'.colorize(:light_yellow)
+        output << 'Memory'.pastel(:bright_yellow)
         output << memory_perc if meminfo
         output << memory_free if free_m
         output << ''
@@ -75,7 +75,7 @@ module GreenHat
       end
 
       # Gitlab
-      output << 'GitLab'.colorize(:light_yellow) if gitlab_manifest
+      output << 'GitLab'.pastel(:bright_yellow) if gitlab_manifest
       output << gitlab_version if gitlab_manifest
       output << gitlab_services if gitlab_status
       output << title('Errors') if production_log || api_log || application_log || sidekiq_log
@@ -95,8 +95,8 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  Production', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  Production', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
@@ -105,8 +105,8 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  API', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  API', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
@@ -115,8 +115,8 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  Application', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  Application', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
@@ -125,32 +125,16 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  Sidekiq', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  Sidekiq', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
     def gitlab_services
-      list = gitlab_status.data.keys.sort.map do |service|
-        color = gitlab_status.data.dig(service, 0, :status) == 'run' ? :green : :red
-        service.colorize(color)
-      end
-
-      # Keep Alphabetical Sort
-      groups = list.each_slice((list.size / 3.to_f).round).to_a
-
-      table = TTY::Table.new do |t|
-        loop do
-          break if groups.all?(&:empty?)
-
-          t << groups.map(&:shift)
-        end
-      end
-
       [
         title('Services'),
         "\n   ",
-        table.render(:unicode, padding: [0, 1, 0, 1], indent: 3)
+        GitLab.services(archive, 3)
       ].join
     rescue StandardError => e
       LogBot.fatal('GitLab Services', message: e.message, backtrace: e.backtrace.first)
@@ -173,7 +157,7 @@ module GreenHat
     def distro
       [
         title('Distro'),
-        "[#{os_release.data.ID}] ".colorize(:light_black),
+        "[#{os_release.data.ID}] ".pastel(:bright_black),
         os_release.data.PRETTY_NAME
       ].join
     end
@@ -184,7 +168,7 @@ module GreenHat
 
       [
         title('SeLinux'),
-        status.colorize(status_color),
+        status.pastel(status_color),
         ' (',
         selinux_status.data['Current mode'],
         ')'
@@ -204,7 +188,7 @@ module GreenHat
       [
         title('Kernel'),
         value,
-        " (#{build})".colorize(:light_black)
+        " (#{build})".pastel(:bright_black)
       ].join
     end
 
@@ -231,9 +215,9 @@ module GreenHat
       [
         title('Sys Time'),
         timedatectl.data['Local time'],
-        ' (ntp: '.colorize(:light_black),
-        ntp_status.colorize(ntp_color),
-        ')'.colorize(:light_black)
+        ' (ntp: '.pastel(:bright_black),
+        ntp_status.pastel(ntp_color),
+        ')'.pastel(:bright_black)
       ].join
     end
 
@@ -258,14 +242,14 @@ module GreenHat
         [
           interval,
           ' (',
-          "#{value}%".colorize(color),
+          "#{value}%".pastel(color),
           ')'
         ].join
       end
 
       [
         title('LoadAvg'),
-        "[CPU #{cpu_count}] ".colorize(:light_white),
+        "[CPU #{cpu_count}] ".pastel(:bright_white),
         intervals_text.join(', ')
       ].join
     end
@@ -277,11 +261,11 @@ module GreenHat
 
       [
         title('Usage'),
-        '  ['.colorize(:light_black),
-        '='.colorize(:green) * (used / 2),
+        '  ['.pastel(:bright_black),
+        '='.pastel(:green) * (used / 2),
         ' ' * (50 - used / 2),
-        ']'.colorize(:light_black),
-        " #{100 - percent(free, total)}%".colorize(:green) # Inverse
+        ']'.pastel(:bright_black),
+        " #{100 - percent(free, total)}%".pastel(:green) # Inverse
       ].join
     end
 
@@ -317,7 +301,7 @@ module GreenHat
 
       # Preapre / Indent List
       [
-        'Disks(Top % Usage)'.colorize(:light_yellow),
+        'Disks'.pastel(:bright_yellow) + ' (Top % Usage)'.pastel(:bright_black),
         "\n",
         disk_list.each { |x| x.prepend(' ' * 4) }.join("\n")
       ].join
@@ -332,7 +316,7 @@ module GreenHat
 
     # Helper to Make Cyan Titles
     def title(name, color = :cyan, ljust = 12)
-      "  #{name}:".ljust(ljust).colorize(color)
+      "  #{name}:".ljust(ljust).pastel(color)
     end
   end
   # rubocop:enable Metrics/ClassLength

data/lib/greenhat/shell/{helper.rb → shell_helper.rb}

@@ -2,94 +2,8 @@ module GreenHat
   # Common Helpers
   # rubocop:disable Metrics/ModuleLength
   module ShellHelper
-    # Generic Parameter Parsing
-    def self.param_parse(params, skip_args = [])
-      # Turn Params into Hash
-      opts = params.flat_map { |param| param_opt_scan(param) }
-
-      # Collect and Remove Args
-      args = params.each_with_object({}) { |param, obj| param_arg_scan(param, obj) }
-
-      # Move Special Arguments
-      opts.reject! do |opt|
-        if param_special_opts.include? opt.field
-          args[opt.field] = opt.value.split(',').map(&:to_sym)
-          true
-        end
-      end
-
-      # Remove Opts and Args
-      params.reject! do |param|
-        opt_field_remove?(opts, param) || arg_field_remove?(args, param)
-      end
-
-      # Update other user defaults
-      Settings.default_log_args(args, skip_args)
-
-      [params, opts, args]
-    end
-
-    def self.opt_field_remove?(opts, param)
-      opts.any? do |opt|
-        param.include? "--#{opt.field}#{opt.bang ? '!' : nil}=#{opt.value}"
-      end
-    end
-
-    def self.arg_field_remove?(args, param)
-      args.keys.any? { |field| param.include? "--#{field}" }
-    end
-
-    # Def Param Scan (Split -- values into keys)
-    def self.param_opt_scan(param)
-      param.scan(/--([^=]+)=(.*)/).map do |field, value|
-        bang = false
-        if field.include? '!'
-          field.delete!('!')
-          bang = true
-        end
-
-        { field: field.to_sym, value: value, bang: bang }
-      end
-    end
-
-    # Params that should be set as Args
-    # Comma Delimited
-    # --slice=thing,thing2
-    # --except=time,params
-    # --round=2
-
-    def self.param_special_opts
-      %i[
-        slice except stats uniq pluck round archive start end sort limit truncate page case
-      ]
-    end
-
-    # Parameter Extraction
-    # Special Opts: --slice, --except
-    def self.param_arg_scan(param, obj)
-      # TODO: Why is capture group doing two arrays
-      param.scan(/--([^=]+)$/).flatten.each do |field|
-        obj[field.to_sym] = param_arg_defaults(field.to_sym)
-      end
-
-      obj
-    end
-
-    # Arg Defaults
-    def self.param_arg_defaults(field)
-      case field
-      when :round then [2]
-      when :limit then [TTY::Screen.height / 2]
-      when :truncate then [TTY::Screen.width * 4]
-      when :page, :case then [:true]
-      when *param_special_opts then []
-      else
-        true
-      end
-    end
-
     # Use File Process for Output
-    def self.file_output(files)
+    def self.file_output(files, flags = {})
       results = file_process(files) do |file|
         [
           file.friendly_name,
@@ -98,7 +12,7 @@ module GreenHat
         ]
       end
 
-      ShellHelper.show(results.flatten)
+      ShellHelper.show(results.flatten, flags)
     end
 
     def self.file_process(files, &block)
@@ -119,7 +33,7 @@ module GreenHat
     end
 
     # Show Data / Auto Paginate Helper
-    def self.show(data, args = {})
+    def self.show(data, flags = {})
       # If Block of String
       if data.instance_of?(String)
         TTY::Pager.page data
@@ -127,23 +41,24 @@ module GreenHat
       end
 
       # If raw just print out
-      if args.raw
+      if flags[:raw]
         puts data.join("\n")
         return true
       end
 
       # Check if content needs to paged, or if auto_height is off
-      if Page.skip?(args, data)
-        puts data.map { |entry| entry_show(args, entry) }.compact.join("\n")
+      if Page.skip?(flags, data)
+        puts data.map { |entry| entry_show(flags, entry) }.compact.join("\n")
         return true
       end
 
       # Default Pager
       TTY::Pager.page do |pager|
         data.each do |entry|
-          output = entry_show(args, entry)
+          output = entry_show(flags, entry)
 
-          next if output.blank?
+          # Breaks any intentional spaces
+          # next if output.blank?
 
           pager.write("\n#{output}") # write line to the pager
         end
@@ -151,12 +66,12 @@ module GreenHat
     end
 
     # Entry Shower / Top Level
-    def self.entry_show(args, entry, key = nil)
+    def self.entry_show(flags, entry, key = nil)
       LogBot.debug('Entry Show', entry.class) if ENV['DEBUG']
       case entry
-      when Hash then render_table(entry, args)
+      when Hash then render_table(entry, flags)
       when Float, Integer, Array
-        format_table_entry(args, entry, key)
+        format_table_entry(flags, entry, key)
       # Ignore Special Formatting for Strings / Usually already formatted
       when String
         entry
@@ -167,39 +82,42 @@ module GreenHat
     end
 
     # Format Table Entries
-    def self.format_table_entry(args, entry, key = nil)
+    def self.format_table_entry(flags, entry, key = nil)
       formatted_entry = case entry
                         # Rounding
                         when Float, Integer || entry.numeric?
-                          args.round ? entry.to_f.round(args.round.first.to_s.to_i).ai : entry.ai
+                          flags.key?(:round) ? entry.to_f.round(flags.round).ai : entry.ai
 
                           # General Inspecting
                         when Hash then entry.ai(ruby19_syntax: true)
 
                         # Arrays often contain Hashes. Dangerous Recursive?
                         when Array
-                          entry.map { |x| format_table_entry(args, x) }.join("\n")
+                          entry.map { |x| format_table_entry(flags, x) }.join("\n")
 
                         when Time
-                          entry.to_s.colorize(:light_white)
+                          entry.to_s.pastel(:bright_white)
 
                         # Default String Formatting
                         else
                           StringColor.do(key, entry)
                         end
 
-      if args[:truncate]
-        entry_truncate(formatted_entry, args[:truncate].join.to_i)
+      if flags[:truncate]
+        entry_truncate(formatted_entry, flags[:truncate])
       else
         formatted_entry
       end
     rescue StandardError => e
-      binding.pry
+      if ENV['DEBUG']
+        LogBot.warn('Table Format Entry', message: e.message)
+        ap e.backtrace
+      end
     end
 
     # Print the Table in a Nice way
-    def self.render_table(entry, args)
-      entry = entry.map { |k, v| [k, format_table_entry(args, v, k)] }.to_h
+    def self.render_table(entry, flags)
+      entry = entry.map { |k, v| [k, format_table_entry(flags, v, k)] }.to_h
       # Pre-format Entry
 
       table = TTY::Table.new(header: entry.keys, rows: [entry], orientation: :vertical)
@@ -207,10 +125,6 @@ module GreenHat
       LogBot.debug('Rendering Entries') if ENV['DEBUG']
       table.render(:unicode, padding: [0, 1, 0, 1], multiline: true) do |renderer|
         renderer.border.style = :cyan
-
-        # renderer.filter = lambda do |val, _row_index, col_index|
-        #   render_table_entry(val, col_index, args)
-        # end
       end
 
       # LogBot.debug('Finish Render Table') if ENV['DEBUG']
@@ -223,33 +137,41 @@ module GreenHat
 
       [
         entry.ai,
-        ('_' * (TTY::Screen.width / 3)).colorize(:cyan),
+        ('_' * (TTY::Screen.width / 3)).pastel(:cyan),
         "\n"
       ].join("\n")
     end
 
-    def self.render_table_entry(val, col_index, args)
+    def self.render_table_entry(val, col_index, flags)
       return val.to_s unless col_index == 1
 
-      format_table_entry(args, val)
+      format_table_entry(flags, val)
     end
 
     # Main Entry Point for Filtering
-    def self.filter_start(log_list, filter_type, args, opts)
+    def self.filter_start(files, flags, args)
       # Convert to Things
-      logs = ShellHelper.find_things(log_list, args).select(&:processed?)
+      logs = ShellHelper.find_things(files, flags).select(&:processed?)
 
       # Ignore Archive/Host Dividers
-      if args[:combine]
+      if flags[:combine]
         results = logs.reject(&:blank?).map(&:data).flatten.compact
-        ShellHelper.filter(results, filter_type, args, opts)
+        ShellHelper.filter(results, flags, args)
       else
         # Iterate and Preserve Archive/Host Index
         logs.each_with_object({}) do |log, obj|
           # Ignore Empty Results / No Thing
           next if log&.blank?
 
-          obj[log.friendly_name] = ShellHelper.filter(log.data, filter_type, args, opts)
+          # Include Total Count in Name
+          results = ShellHelper.filter(log.data, flags, args)
+          title = [
+            log.friendly_name,
+            " #{results.count}".pastel(:bright_black)
+          ]
+
+          # Save unless empty
+          obj[title.join] = results unless results.count.zero?
 
           obj
         end
@@ -259,50 +181,55 @@ module GreenHat
     # Filter Logic
     # TODO: Simplify
     # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    def self.filter(data, type = :all?, args = {}, opts = {})
+    def self.filter(data, flags = {}, args = {})
       results = data.clone.flatten.compact
       results.select! do |row|
-        opts.send(type) do |opt|
-          filter_row_key(row, opt, args)
+        args.send(flags.logic) do |arg|
+          filter_row_key(row, arg, flags)
         end
       end
 
+      # Ensure presecense of a specific field
+      results = filter_exists(results, flags[:exists]) if flags.key?(:exists)
+
       # Time Filtering
-      results = filter_time(results, args) if args[:start] || args[:end]
+      results = filter_time(results, flags) if flags.key?(:start) || flags.key?(:end)
 
       # Strip Results if Slice is defined
-      results = filter_slice(results, args[:slice]) if args[:slice]
+      results = filter_slice(results, flags[:slice]) if flags.key?(:slice)
 
       # Strip Results if Except is defined
-      results = filter_except(results, args[:except]) if args[:except]
+      results = filter_except(results, flags[:except]) if flags.key?(:except)
 
       # Remove Blank from either slice or except
       results.reject!(&:empty?)
 
       # Sort
-      results.sort_by! { |x| x.slice(*args[:sort]).values } if args[:sort]
+      results.sort_by! { |x| x.slice(*flags[:sort]).values } if flags.key?(:sort)
 
       # JSON Formatting
-      results = results.map { |x| Oj.dump(x) } if args[:json]
+      results = results.map { |x| Oj.dump(x) } if flags.key?(:json)
 
       # Show Unique Only
-      results = filter_uniq(results, args[:uniq]) if args.key?(:uniq)
+      results = filter_uniq(results, flags[:uniq]) if flags.key?(:uniq)
 
       # Reverse
-      results.reverse! if args[:reverse]
+      results.reverse! if flags[:reverse]
 
       # Count occurrences / Skip Results
-      return filter_stats(results, args[:stats]) if args[:stats]
+      return filter_stats(results, flags[:stats]) if flags.key?(:stats)
 
       # Pluck
-      results = filter_pluck(results, args[:pluck]) if args.key?(:pluck)
+      results = filter_pluck(results, flags[:pluck]) if flags.key?(:pluck)
 
-      # Truncate
-      # filter_truncate(results, args[:truncate].join.to_i) if args.key?(:truncate)
+      # Limit / Ensure Exists and Valid Number
+      if flags.key?(:limit) && flags[:limit]
+        # Old
+        # results[0..flags[:limit].map(&:to_s).join.to_i - 1]
+
+        # New
+        results.shift flags[:limit]
 
-      # Limit
-      if args[:limit]
-        results[0..args[:limit].map(&:to_s).join.to_i - 1]
       else
         results
       end
@@ -312,10 +239,10 @@ module GreenHat
     # Filter Start and End Times
     # rubocop:disable Metrics/MethodLength
     # TODO: This is a bit icky, simplify/dry
-    def self.filter_time(results, args)
-      if args.start
+    def self.filter_time(results, flags)
+      if flags.key?(:start)
         begin
-          time_start = Time.parse(args.start.first.to_s)
+          time_start = Time.parse(flags[:start])
 
           results.select! do |x|
             if x.time
@@ -325,13 +252,13 @@ module GreenHat
             end
           end
         rescue StandardError
-          puts 'Unable to Process Start Time Filter'.colorize(:red)
+          puts 'Unable to Process Start Time Filter'.pastel(:red)
         end
       end
 
-      if args.end
+      if flags.key?(:end)
         begin
-          time_start = Time.parse(args.end.first.to_s)
+          time_start = Time.parse(flags[:end])
 
           results.select! do |x|
             if x.time
@@ -341,7 +268,7 @@ module GreenHat
             end
           end
         rescue StandardError
-          puts 'Unable to Process End Time Filter'.colorize(:red)
+          puts 'Unable to Process End Time Filter'.pastel(:red)
         end
       end
 
@@ -351,14 +278,24 @@ module GreenHat
 
     def self.filter_except(results, except)
       # Avoid Empty Results
-      if slice.empty?
-        filter_empty_arg('slice')
+      if except.empty?
+        filter_empty_arg('except')
         return results
       end
 
       results.map { |row| row.except(*except) }
     end
 
+    def self.filter_exists(results, exists)
+      # Avoid Empty Results
+      if exists.empty?
+        filter_empty_arg('exists')
+        return results
+      end
+
+      results.select { |row| (exists - row.keys).empty? }
+    end
+
     def self.entry_truncate(entry, truncate)
       # Ignore if Truncation Off
       return entry if truncate.zero?
@@ -367,7 +304,7 @@ module GreenHat
       return entry unless entry.instance_of?(String) && entry.size > truncate
 
       # Include  '...' to indicate truncation
-      "#{entry.to_s[0..truncate]} #{'...'.colorize(:light_blue)}"
+      "#{entry.to_s[0..truncate]} #{'...'.pastel(:bright_blue)}"
     end
 
     def self.filter_slice(results, slice)
@@ -399,7 +336,7 @@ module GreenHat
 
       unique.map do |field|
         results.uniq { |x| x[field] }
-      end.flatten
+      end.inject(:&)
     end
 
     def self.filter_stats(results, stats)
@@ -409,18 +346,45 @@ module GreenHat
         return results
       end
 
-      stats.map do |stat|
-        occurrences = filter_count_occurrences(results, stat)
-        occurrences.sort_by(&:last).to_h
+      # Loop through Stats, Separate Hash/Tables
+      stats.map do |field|
+        occurrences = filter_count_occurrences(results, field)
+
+        # Total Occurences
+        total = occurrences.values.sum
+
+        # Percs
+        occurrences.transform_values! do |count|
+          [
+            count,
+            " #{percent(count, total)}%".pastel(:bright_black)
+          ]
+        end
+
+        # Sort by total occurances / New Variable for Total
+        output = occurrences.sort_by(&:last).to_h.transform_values!(&:join).to_a
+
+        # Append Header / Total with field name
+        output.unshift([field.to_s.pastel(:bright_black), total])
+
+        # Format
+        output.to_h
       end
     end
 
+    # Percent Helper
+    def self.percent(value, total)
+      ((value / total.to_f) * 100).round
+    end
+
     # Helper to Count occurrences
-    def self.filter_count_occurrences(results, stat)
+    def self.filter_count_occurrences(results, field)
       results.each_with_object(Hash.new(0)) do |entry, counts|
-        next unless entry.key? stat
-
-        counts[entry[stat]] += 1
+        if entry.key? field
+          counts[entry[field]] += 1
+        else
+          counts['None'.pastel(:bright_black)] += 1
+        end
 
         counts
       end
@@ -428,43 +392,67 @@ module GreenHat
 
     def self.filter_empty_arg(arg)
       puts [
-        'Ignoring'.colorize(:light_yellow),
-        "--#{arg}".colorize(:cyan),
-        'it requires an argument'.colorize(:red)
+        'Ignoring'.pastel(:bright_yellow),
+        "--#{arg}".pastel(:cyan),
+        'it requires an argument'.pastel(:red)
       ].join(' ')
     end
 
     # Break out filter row logic into separate method
-    def self.filter_row_key(row, param, args)
-      # Ignore Other Logic if Field isn't even included
-      return false unless row.key? param.field
 
-      # Sensitivity Check / Check for Match
-      included = if args.key?(:case)
-                   row[param.field].to_s.include? param.value.to_s
+    def self.filter_row_key(row, arg, flags)
+      # Ignore Other Logic if Field isn't even included / Full Text Searching
+      return false unless row.key?(arg[:field]) || arg[:field] == :text
+
+      # Sensitivity Check / Check for Match / Full Text Searching
+      included = if arg[:field] == :text
+                   filter_row_entry(row.to_s, arg, flags)
                  else
-                   row[param.field].to_s.downcase.include? param.value.to_s.downcase
+                   filter_row_entry(row[arg.field].to_s, arg, flags)
                  end
 
       # Pivot of off include vs exclude
-      if param.bang
+      if arg.bang
         !included
       else
         included
       end
     end
 
+    # Field Partial / Case / Exact search
+    def self.filter_row_entry(entry, arg, flags)
+      # Exact Matching / Unless doing full text search
+      return entry.to_s == arg.value.to_s if flags.key?(:exact) && arg.field != :text
+
+      if flags.key?(:case)
+        entry.include? arg.value.to_s
+      else
+        entry.downcase.include? arg.value.to_s.downcase
+      end
+    end
+
     # Total Count Helper
     def self.total_count(results)
       results.each do |k, v|
         puts k
-        puts "Total: #{v.count.to_s.colorize(:blue)}"
+        puts "Total: #{v.count.to_s.pastel(:blue)}"
         puts
       end
     end
 
+    # Unified Files Interface
+    def self.files(file_list, base_list = nil, flags = {})
+      base_list ||= Thing.all
+
+      # Prepare Log List
+      file_list = prepare_list(file_list, base_list)
+
+      # Convert to Things
+      find_things(file_list, flags)
+    end
+
     # Total Log List Manipulator
-    def self.prepare_list(log_list, base_list = nil)
+    def self.prepare_list(log_list, base_list = nil, _flags = {})
       base_list ||= GreenHat::ShellHelper::Log.list
 
       # Assume all
@@ -476,48 +464,62 @@ module GreenHat
       log_list
     end
 
+    # Fuzzy match for things
+    def self.thing_list
+      @thing_list ||= Thing.all.map(&:name)
+
+      @thing_list
+    end
+
     # Shortcut find things
-    def self.find_things(log_list, args = {})
-      things = log_list.uniq.flat_map do |log|
-        Thing.where name: log
-      end
+    def self.find_things(files, flags = {})
+      things = files.uniq.flat_map do |file|
+        # If Thing, Return Thing
+        return file if file.instance_of?(Thing)
+
+        if flags.fuzzy_file_match
+          Thing.all.select { |x| x.name.include? file }
+        else
+          Thing.where name: file
+        end
+      end.uniq
 
       # Host / Archive
-      things.select! { |x| x.archive? args.archive } if args.archive
+      things.select! { |x| x.archive? flags.archive } if flags.key?(:archive)
 
       things
     end
 
     # Main Entry Point for Searching
-    def self.search_start(log_list, filter_type, args, opts)
+    # def self.search_start(log_list, filter_type, args, opts)
+    def self.search_start(files, flags, args)
       # Convert to Things
-      logs = ShellHelper.find_things(log_list, args)
+      logs = ShellHelper.find_things(files, flags)
 
       logs.each_with_object({}) do |log, obj|
         # Ignore Empty Results / No Thing
         next if log&.data.blank?
 
-        obj[log.friendly_name] = ShellHelper.search(log.data, filter_type, args, opts)
+        obj[log.friendly_name] = ShellHelper.search(log.data, flags, args)
 
         obj
       end
     end
 
     # Generic Search Helper / String/Regex
-    def self.search(data, type = :all?, args = {}, opts = {})
+    def self.search(data, flags = {}, args = {})
       results = data.clone.flatten.compact
-
       results.select! do |row|
-        opts.send(type) do |opt|
-          search_row(row, opt)
+        args.send(flags.logic) do |arg|
+          search_row(row, arg, flags)
         end
       end
 
       # Strip Results if Slice is defined
-      results.map! { |row| row.slice(*args[:slice]) } if args[:slice]
+      results.map! { |row| row.slice(*flags[:slice]) } if flags[:slice]
 
       # Strip Results if Except is defined
-      results.map! { |row| row.except(*args[:except]) } if args[:except]
+      results.map! { |row| row.except(*flags[:except]) } if flags[:except]
 
       # Remove Blank from either slice or except
       results.reject!(&:empty?)
@@ -526,21 +528,23 @@ module GreenHat
     end
 
     # Break out filter row logic into separate method
-    def self.search_row(row, param)
-      # Not Included Param
-      included = row.to_s.include? param.value
+    def self.search_row(row, arg, flags)
+      # Sensitivity Check / Check for Match
+      included = filter_row_entry(row.to_s, arg, flags)
 
-      if param.bang
+      # Pivot of off include vs exclude
+      if arg.bang
         !included
       else
         included
       end
     end
 
+    # TODO: Remove?
     # Color Reader Helper
-    def self.pastel
-      @pastel ||= Pastel.new
-    end
+    # def self.pastel
+    #   @pastel ||= Pastel.new
+    # end
 
     # Number Helper
     # https://gitlab.com/zedtux/human_size_to_number/-/blob/master/lib/human_size_to_number/helper.rb
@@ -579,6 +583,19 @@ module GreenHat
 
       result
     end
+
+    # General Helper for `show`
+    def self.common_opts
+      puts 'Common Options'.pastel(:blue)
+      puts '  --raw'.pastel(:green)
+      puts '    Do not use less/paging'
+      puts
+
+      puts '  --archive'.pastel(:green)
+      puts '    Limit to specific archive name (inclusive). Matching SOS tar.gz name'
+      puts '    Ex: --archive=dev-gitlab_20210622154626, --archive=202106,202107'
+      puts
+    end
   end
   # rubocop:enable Metrics/ModuleLength
 end