greenhat 0.2.0 → 0.3.0

data/lib/greenhat/color.rb

@@ -0,0 +1,27 @@
+# Top level namespace
+module GreenHat
+  # Replace Colorize with Pastel Monkey Patch String Shim
+  # https://github.com/piotrmurach/pastel#features
+
+  # Looping in GreenHat to allow disabling of Color
+  module Color
+    def self.pastel
+      @pastel ||= Pastel.new
+    end
+
+    def self.decorate(args)
+      Settings.color? ? pastel.decorate(*args) : args.first
+    end
+  end
+end
+
+# Monkey Patch
+class String
+  def pastel(*args)
+    GreenHat::Color.decorate(args.unshift(self))
+  end
+
+  def unpastel
+    GreenHat::Color.pastel.strip self
+  end
+end

data/lib/greenhat/logbot.rb

@@ -6,11 +6,11 @@ module LogBot
   end
 
   def self.output(name, message, level, duration = nil)
-    time = Time.now.to_s.colorize(:light_black)
+    time = Time.now.to_s.pastel(:bright_black)
     output = time
     output += "  #{color_level(level)}"
-    output += " - #{name.to_s.colorize(:light_blue)} "
-    output += "(#{duration.round(2)}) ".colorize(:magenta) if duration
+    output += " - #{name.to_s.pastel(:bright_blue)} "
+    output += "(#{duration.round(2)}) ".pastel(:magenta) if duration
 
     output += ' '
     if message
@@ -21,21 +21,21 @@ module LogBot
                 end
     end
 
-    puts output unless ENV['TESTING']
+    puts output unless ENV['TESTING'] || GreenHat::Cli.quiet
   end
 
   def self.color_level(level)
     case level
     when :debug
-      level.to_s.upcase.colorize(:light_cyan)
+      level.to_s.upcase.pastel(:bright_cyan)
     when :info
-      level.to_s.upcase.colorize(:cyan)
+      level.to_s.upcase.pastel(:cyan)
     when :warn
-      level.to_s.upcase.colorize(:yellow)
+      level.to_s.upcase.pastel(:yellow)
     when :error
-      level.to_s.upcase.colorize(:light_red)
+      level.to_s.upcase.pastel(:bright_red)
     when :fatal
-      level.to_s.upcase.colorize(:red)
+      level.to_s.upcase.pastel(:red)
     end
   end
 

data/lib/greenhat/settings.rb

@@ -5,14 +5,25 @@ module GreenHat
     def self.settings
       @settings ||= {
         history: [],
+        assume_json: true,
+        fuzzy_file_match: true,
 
         # round: [2],
         # page: [:true] Automatic,
-        truncate: [TTY::Screen.width * 4]
-
+        truncate: TTY::Screen.width * 4,
+        color: true
       }
     end
 
+    def self.assume_json?
+      settings.assume_json
+    end
+
+    # Allow for future disabling of color output
+    def self.color?
+      settings.color
+    end
+
     # Load User Settings and drop them into settings
     def self.settings_load
       return true unless File.exist?(settings_file)
@@ -26,12 +37,21 @@ module GreenHat
       "#{dir}/settings.json"
     end
 
-    # Set any Log Arguments that weren't set otherwise
-    def self.default_log_args(args, skip_args)
-      args[:round] ||= settings.round unless skip_args.include?(:round)
-      args[:page] ||= settings.page unless skip_args.include?(:page)
-      args[:truncate] ||= settings.truncate unless skip_args.include?(:truncate)
+    # Set any Log Arguments that weren't set otherwise | Conditional assign applied on bool
+    # rubocop:disable Style/GuardClause
+    def self.default_log_flags(flags, skip_flags)
+      flags[:round] = settings.round if !(skip_flags.include?(:round) || flags.key?(:round)) && settings.round
+
+      flags[:page] = settings.page if !(skip_flags.include?(:page) || flags.key?(:page)) && settings.page
+
+      flags[:truncate] = settings.truncate unless skip_flags.include?(:truncate) || flags.key?(:truncate)
+
+      # Fuzzy File Match
+      unless skip_flags.include?(:fuzzy_file_match) || flags.key?(:fuzzy_file_match)
+        flags[:fuzzy_file_match] = settings.fuzzy_file_match
+      end
     end
+    # rubocop:enable Style/GuardClause
 
     def self.start
       Dir.mkdir dir unless Dir.exist? dir

data/lib/greenhat/shell/args.rb

@@ -0,0 +1,146 @@
+module GreenHat
+  # Module for Argument Parsing
+  # Possible Args
+  # --value=thing
+  # --value / Default => --value=thing
+  # --flag
+  # --slice=value,value2
+  # files
+
+  # Variable Breakdown
+  # Args:Array supplied or default values for entry looping action
+  # Flags:Hash Key/Value filter Actionables
+  # Files:Array/String are any non start `-` dash entries
+  module Args
+    def self.parse(raw, skip_flags = [])
+      # Don't affect original object / Better deep clone?
+      cmd = raw.clone
+      # cmd = Marshal.load(Marshal.dump(raw))
+
+      # Extract Files
+      files = cmd.grep_v(/^-+([^=]+)/)
+
+      # Collect and Naturalize Arguments
+      args = cmd.flat_map { |arg| arg_scan(arg) }
+
+      # Collect all Flags to Hash
+      flags = cmd.flat_map { |flag| flag_scan(flag) }.to_h
+
+      # Move Flags to Args
+      arg_to_flag(flags, args)
+
+      # Logic
+      # And / Or
+      flag_defaults(flags, skip_flags)
+
+      [files, flags, args]
+    end
+
+    def self.flag_defaults(flags, skip_flags)
+      # Update other user defaults
+      Settings.default_log_flags(flags, skip_flags)
+
+      # FastStats / Don't set default flags
+      return if skip_flags.include? :logic
+
+      # Default Logic
+      if flags.key?(:or)
+        flags.logic = :any?
+        flags.delete(:or)
+      else
+        flags.logic = :all?
+      end
+    end
+
+    # Move Valued Flags to arguments (--truncate=5)
+    def self.arg_to_flag(flags, args)
+      args.reject! do |arg|
+        # Entries specifically to move to Args
+        if arg_to_flag_list.include?(arg.field)
+          flags[arg.field] = arg.value
+
+          true
+        # Ignore Good Entries
+        else
+          false
+        end
+      end
+    end
+
+    # Flags Anything that isn't sent as a key/filter
+    def self.arg_to_flag_list
+      %i[
+        archive end except exists json limit pluck reverse round slice sort start stats
+        truncate uniq page
+      ]
+    end
+
+    # Arg Scan (Split -- values into keys)
+    def self.arg_scan(arg)
+      arg.scan(/^-+([^=]+)=(.*)/).map do |field, value|
+        bang = false
+        if field.include? '!'
+          field.delete!('!')
+          bang = true
+        end
+
+        # Symbolize
+        field = field.to_sym
+
+        {
+          field: field,
+          value: arg_normalize(field, value),
+          bang: bang
+        }
+      end
+    end
+
+    # Collect All Flags
+    def self.flag_scan(arg)
+      arg.scan(/^-+([^=]+)$/).map do |field, _val|
+        # Symbolize
+        field = field.to_sym
+
+        [field, flag_arg_defaults(field)]
+      end
+    end
+
+    # Naturlalize Values, Manipluate Special Values
+    def self.arg_normalize(field, value)
+      # Special Comma Params With Symbol
+      return value.split(',').map(&:to_sym) if arg_special_split.include?(field)
+
+      # Integer Arguments
+      return value.to_i if value.numeric?
+
+      # Other Field Manipulation
+      case field
+      when :page then value == 'true'
+      else
+
+        # Default Original
+        value
+      end
+    end
+
+    # Arguments that Accept multiple options / Comma Delimted
+    def self.arg_special_split
+      %i[
+        slice except uniq pluck sort archive stats exists
+      ]
+    end
+
+    # Arg Defaults
+    def self.flag_arg_defaults(field)
+      case field
+      when :round then 2
+      when :limit then (TTY::Screen.height / 3) - 3
+      when :truncate then TTY::Screen.width * 4
+      # when :page, :case, :exact then :true # Override Specials
+      when *arg_special_split then []
+      else
+        true
+      end
+    end
+  end
+end

data/lib/greenhat/shell/cat.rb

@@ -3,60 +3,38 @@ module GreenHat
   module Shell
     # Common File Reader File
     module Cat
-      # rubocop:disable Metrics/MethodLength
       def self.help
-        puts "\u2500".colorize(:cyan) * 20
-        puts "#{'Cat'.colorize(:yellow)} All the files"
-        puts "\u2500".colorize(:cyan) * 20
+        puts "\u2500".pastel(:cyan) * 20
+        puts "#{'Cat'.pastel(:yellow)} All the files"
+        puts "\u2500".pastel(:cyan) * 20
         puts 'Print raw file by just entering the file name'
         puts
 
-        puts 'Common Options'.colorize(:blue)
-        puts '  --raw'.colorize(:green)
-        puts '    Do not use less/paging'
-        puts
-        puts '  --archive'.colorize(:green)
-        puts '    Limit to specific archvie name (inclusive). Matching SOS tar.gz name'
-        puts '    Ex: --archive=dev-gitlab_20210622154626, --archive=202106,202107'
-        puts '    cat mount --archive=dev-gitlab_202106221546'
-        puts
+        ShellHelper.common_opts
 
-        puts 'Commands'.colorize(:blue)
-        puts 'ls'.colorize(:green)
-        puts '  List available files'
-        puts '  Options'
-        puts '    -a, --all, show all files including source'
-        puts
+        puts 'Commands'.pastel(:blue)
+        puts ShellHelper::List.help
 
-        puts '<file names+>'.colorize(:green)
-        puts '  Print any file names'
-        puts '  Ex: `free_m`'
-        puts '  Ex: `ps mount --raw`'
+        puts '  <file names+>'.pastel(:green)
+        puts '    Print any file names'
+        puts '    Ex: `free_m`'
+        puts '    Ex: `ps mount --raw`'
         puts
 
-        puts "#{'show'.colorize(:green)} <file names>"
-        puts '  Attempt to print formatted output'
-        puts '  Ex: show `free_m`'
-
-        puts '--archive'.colorize(:green)
-        puts '  Limit to specific archvie name (inclusive). Matching SOS tar.gz name'
-        puts '  Ex: --archive=dev-gitlab_20210622154626, --archive=202106,202107'
-        puts
+        puts "  #{'show'.pastel(:green)} <file names>"
+        puts '    Attempt to print formatted output'
+        puts '    Ex: show `free_m`'
       end
-      # rubocop:enable Metrics/MethodLength
 
       # ========================================================================
       # Default
       # ========================================================================
-      def self.default(file_list)
+      def self.default(raw)
         # Extract Args
-        file_list, _opts, args = ShellHelper.param_parse(file_list)
-
-        # Prepare Log List
-        file_list = ShellHelper.prepare_list(file_list, Thing.all)
+        files_list, flags, _args = Args.parse(raw)
 
-        # Convert to Things
-        files = ShellHelper.find_things(file_list, args)
+        # Collect Files
+        files = ShellHelper.files(files_list, Thing.all, flags)
 
         results = ShellHelper.file_process(files) do |file|
           [
@@ -66,58 +44,32 @@ module GreenHat
           ]
         end
 
-        ShellHelper.show(results.flatten, args)
+        ShellHelper.show(results.flatten, flags)
       end
 
       # ========================================================================
       # Show Attempted Formatting
       # ========================================================================
-      def self.show(file_list)
+      def self.show(raw)
         # Extract Args
-        file_list, _opts, args = ShellHelper.param_parse(file_list)
+        files_list, flags, _args = Args.parse(raw)
 
-        # Prepare Log List
-        file_list = ShellHelper.prepare_list(file_list, Thing.all)
-
-        # Convert to Things
-        files = ShellHelper.find_things(file_list, args)
+        # Collect Files
+        files = ShellHelper.files(files_list, Thing.all, flags)
 
         results = ShellHelper.file_process(files) do |file|
           [
             file.friendly_name,
-            file.output(false),
+            file.data,
             "\n"
           ]
         end
 
-        ShellHelper.show(results.flatten, args)
-      end
-
-      # List Files Helpers
-      def self.list(args = [])
-        all = false
-        all = true if args.include?('-a') || args.include?('--all')
-
-        files = Thing.all
-
-        # Sort
-        files.sort_by!(&:name)
-
-        # Short & Uniq
-        files.uniq!(&:name) unless all
-
-        # Print
-        files.each do |log|
-          if all
-            puts "- #{log.friendly_name}"
-          else
-            puts "- #{log.name.colorize(:yellow)}"
-          end
-        end
+        ShellHelper.show(results.flatten, flags)
       end
 
       def self.ls(args = [])
-        list(args)
+        ShellHelper::List.list(args, Thing.all)
       end
       # ------------------------------------------------------------------------
     end

data/lib/greenhat/shell/color_string.rb

@@ -6,20 +6,20 @@ module GreenHat
         LogBot.debug('Unknown Format', entry.class) if ENV['DEBUG'] && !entry.instance_of?(String)
 
         # Other Helpful colorizers
-        if colorize?(key)
-          colorize(key, entry)
+        if pastel?(key)
+          pastel(key, entry)
         else
           entry.to_s
         end
       end
 
       # Add Color?
-      def self.colorize?(key)
+      def self.pastel?(key)
         [:severity].any? key
       end
 
       # General Key/Value Coloring
-      def self.colorize(key, value)
+      def self.pastel(key, value)
         case key
         when :severity then severity(value)
         else
@@ -30,10 +30,10 @@ module GreenHat
 
       def self.severity(value)
         case value.to_s.downcase.to_sym
-        when :debug then value.colorize(:blue)
-        when :info then value.colorize(:cyan)
-        when :warn then value.colorize(:yellow)
-        when :fatal, :error then value.colorize(:light_red)
+        when :debug then value.pastel(:blue)
+        when :info then value.pastel(:cyan)
+        when :warn then value.pastel(:yellow)
+        when :fatal, :error then value.pastel(:bright_red)
         else
           value.to_s
         end