greenhat 0.1.5 → 0.3.2

data/lib/greenhat/settings.rb

@@ -4,13 +4,61 @@ module GreenHat
   module Settings
     def self.settings
       @settings ||= {
-        history: []
+        history: [],
+        assume_json: true,
+        fuzzy_file_match: true,
+
+        # round: [2],
+        # page: [:true] Automatic,
+        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)
+
+      Oj.load(File.read(settings_file)).each do |key, value|
+        settings[key] = value
+      end
+    end
+
+    def self.settings_file
+      "#{dir}/settings.json"
+    end
+
+    # 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
 
+      # Load User Settings
+      settings_load
+
       # CMD History Loading / Tracking
       File.write(cmd_file, "\n") unless File.exist? cmd_file
     end
@@ -33,8 +81,8 @@ module GreenHat
       File.read(cmd_file).split("\n")
     end
 
-    def self.cmd_write
-      File.write(cmd_file, cmd_history_clean.join("\n"))
+    def self.cmd_history_clear
+      File.write(cmd_file, "\n")
     end
 
     def self.cmd_add(line)

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 time_zone table_style
+      ]
+    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

@@ -0,0 +1,43 @@
+module GreenHat
+  module ShellHelper
+    # Helper to colorize and make outtput easier to read
+    module StringColor
+      def self.do(key, entry)
+        LogBot.debug('Unknown Format', entry.class) if ENV['DEBUG'] && !entry.instance_of?(String)
+
+        # Other Helpful colorizers
+        if pastel?(key)
+          pastel(key, entry)
+        else
+          entry.to_s
+        end
+      end
+
+      # Add Color?
+      def self.pastel?(key)
+        [:severity].any? key
+      end
+
+      # General Key/Value Coloring
+      def self.pastel(key, value)
+        case key
+        when :severity then severity(value)
+        else
+          value.to_s
+        end
+      end
+      # ----
+
+      def self.severity(value)
+        case value.to_s.downcase.to_sym
+        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
+      end
+    end
+  end
+end

data/lib/greenhat/shell/disk.rb

@@ -8,60 +8,48 @@ module GreenHat
         Cli.help
       end
 
-      # Easy Show All
-      def self.df
-        ShellHelper.file_output GreenHat::Disk.df
+      def self.help
+        puts "\u2500".pastel(:cyan) * 22
+        puts "#{'Disk'.pastel(:yellow)} -  Storage Helper"
+        puts "\u2500".pastel(:cyan) * 22
+
+        ShellHelper.common_opts
+
+        puts 'Command Summary'.pastel(:blue)
+        puts '  df'.pastel(:green)
+        puts "    Raw #{'df'.pastel(:cyan)} output"
+        puts
+        puts '  free'.pastel(:green)
+        puts '    Formatted / Bar Output'
+        puts
       end
 
-      # rubocop:disable Metrics/MethodLength,Metrics/BlockLength
-      def self.free
-        GreenHat::Disk.df.each do |file|
-          # Reject TMPFS
-          puts file.friendly_name
-          disks = file.data.sort_by { |x| x.use.to_i }.reverse.reject { |x| x.filesystem.include? 'tmpfs' }
+      # Easy Show All
+      def self.df(raw = {})
+        # Extract Args
+        files_list, flags, _args = Args.parse(raw)
 
-          # pad_mount = GreenHat::Disk.max_padding(disks, :mounted_on)
-          # pad_size = GreenHat::Disk.max_padding(disks, :size)
-          # pad_used = GreenHat::Disk.max_padding(disks, :used)
-          # pad_avail = GreenHat::Disk.max_padding(disks, :avail)
+        # Collect Files
+        files = ShellHelper.files(files_list, GreenHat::Disk.df, flags)
 
-          pad_mount, pad_size, pad_used, pad_avail = GreenHat::Disk.padding(disks)
+        # Output
+        ShellHelper.file_output(files, flags)
+      end
 
-          # Headers
-          puts [
-            'Mount'.ljust(pad_mount).colorize(:blue),
-            'Size'.ljust(pad_size).colorize(:magenta),
-            'Used'.ljust(pad_used).colorize(:cyan),
-            'Avail'.ljust(pad_avail).colorize(:white),
-            '% Use'.ljust(pad_avail).colorize(:green)
-          ].join
+      def self.free(raw = {})
+        # Extract Args
+        files_list, flags, _args = Args.parse(raw)
 
-          # Table Summary
-          disks.map do |disk|
-            # Pretty Disk Use
-            use = [
-              disk.use.rjust(5).ljust(5).colorize(:green),
-              '  ['.colorize(:blue),
-              ('=' * (disk.use.to_i / 2)).colorize(:green),
-              ' ' * (50 - disk.use.to_i / 2),
-              ']'.colorize(:blue)
-            ].join
+        # Collect Files
+        files = ShellHelper.files(files_list, GreenHat::Disk.df, flags)
 
-            # Whole Thing
-            puts [
-              disk.mounted_on.ljust(pad_mount).colorize(:blue),
-              disk[:size].to_s.ljust(pad_size).colorize(:magenta),
-              disk.used.to_s.ljust(pad_used).colorize(:cyan),
-              disk.avail.to_s.ljust(pad_avail).colorize(:white),
-              use
-            ].join
-          end
+        files.each do |file|
+          puts GreenHat::Disk.format_output(file, true)
 
           # File End Loop / Break
           puts
         end
       end
-      # rubocop:enable Metrics/MethodLength,Metrics/BlockLength
       # ------------------------------------------------------------------------
     end
   end