greenhat 0.4.0 → 0.6.1

data/lib/greenhat/shell/reports.rb

@@ -0,0 +1,41 @@
+# Reporting
+require 'greenhat/reports/shared' # Methods for Shell and Builder
+require 'greenhat/reports/internal_methods' # Class / Execution Only
+require 'greenhat/reports/runner' # Class execution
+require 'greenhat/reports/builder' # CLI Reports
+require 'greenhat/reports/shell_helper'
+
+module GreenHat
+  # CLI Helper
+  module Shell
+    # Logs
+    module Reports
+      # Easy Show All
+      def self.ls(raw = [])
+        filter, _flags, _args = Args.parse(raw)
+
+        list = GreenHat::ShellHelper::Reports.list
+        list.select! { |x| x.include? filter.first } unless filter.blank?
+
+        list.each do |x|
+          puts "- #{File.basename(x, '.rb').pastel(:yellow)}"
+        end
+      end
+
+      def self.default(raw = [])
+        list, flags, args = Args.parse(raw)
+
+        # Collect Reporst to Run
+        run_list = GreenHat::ShellHelper::Reports.list.select do |entry|
+          list.include? File.basename(entry, '.rb')
+        end
+
+        run_list.uniq!
+
+        run_list.each do |file|
+          GreenHat::ShellHelper::Reports.run(file: file, args: args, flags: flags)
+        end
+      end
+    end
+  end
+end

data/lib/greenhat/shell/shell_helper.rb

@@ -48,23 +48,50 @@ module GreenHat
 
       # Check if content needs to paged, or if auto_height is off
       if Page.skip?(flags, data)
-        puts data.map { |entry| entry_show(flags, entry) }.compact.join("\n")
+        create_ledger(data, flags).each { |entry| puts entry.render }
         return true
       end
 
-      # Default Pager
-      TTY::Pager.page do |pager|
-        data.each do |entry|
-          output = "\n#{entry_show(flags, entry)}"
+      # Create Jobs
+      # Generate List of Formatted Output
+      ledger = create_ledger(data, flags)
 
-          # output += "\n" if flags[:table_style] == 'basic'
+      # Start Thread
+      # TODO: Confirm / Test or Remove
+      unless flags.no_paper_thread
+        thread = Thread.new do
+          pending = ledger.clone
+          loop do
+            pending = pending.reject(&:done)
+            break if pending.empty?
 
-          # Breaks any intentional spaces
-          # next if output.blank?
+            pending.first.async
+          end
+        end
+      end
 
-          pager.write(output) # write line to the pager
+      TTY::Pager.page do |pager|
+        ledger.each do |paper|
+          # New Line is only needed on pager.write
+          pager.write "#{paper.render}\n"
         end
       end
+
+      # Terminate
+      thread.kill unless flags.no_paper_thread
+
+      # -----------------
+    end
+
+    # Collect Class Objects for output
+    def self.create_ledger(data, flags)
+      data.map do |x|
+        Paper.new(data: x, flags: flags)
+      end
+    end
+
+    def self.puts(text = '')
+      $stdout.puts text
     end
 
     # Entry Shower / Top Level
@@ -72,11 +99,13 @@ module GreenHat
       LogBot.debug('Entry Show', entry.class) if ENV['DEBUG']
       case entry
       when Hash then render_table(entry, flags)
-      when Float, Integer, Array
+      when Float, Integer
         format_table_entry(flags, entry, key)
-      # Ignore Special Formatting for Strings / Usually already formatted
+        # Ignore Special Formatting for Strings / Usually already formatted
       when String
         entry
+      when Array
+        render_array_table(entry, flags)
       else
         LogBot.warn('Shell Show', "Unknown #{entry.class}")
         nil
@@ -90,13 +119,12 @@ module GreenHat
                         when Float, Integer || entry.numeric?
                           flags.key?(:round) ? entry.to_f.round(flags.round).ai : entry.ai
 
-                          # General Inspecting
+                        # General Inspecting
                         when Hash then entry.ai(ruby19_syntax: true)
 
                         # Arrays often contain Hashes. Dangerous Recursive?
                         when Array
                           entry.map { |x| format_table_entry(flags, x) }.join("\n")
-
                         when Time
                           entry.to_s.pastel(:bright_white)
 
@@ -118,9 +146,25 @@ module GreenHat
       end
     end
 
+    def self.render_array_table(entry, flags)
+      table_style = flags[:table_style]&.to_sym || :unicode
+      header, rows = entry
+      table = TTY::Table.new(header: header, rows: rows)
+
+      LogBot.debug('Rendering Entries') if ENV['DEBUG']
+      output = table.render(table_style, padding: [0, 1, 0, 1], multiline: true) do |renderer|
+        renderer.border.style = :cyan
+      end
+
+      # Line breaks for basic tables
+      output += "\n" if flags[:table_style] == 'basic'
+
+      output
+    end
+
     # Print the Table in a Nice way
     def self.render_table(entry, flags)
-      entry = entry.map { |k, v| [k, format_table_entry(flags, v, k)] }.to_h
+      entry = entry.to_h { |k, v| [k, format_table_entry(flags, v, k)] }
       # Pre-format Entry
 
       table_style = flags[:table_style]&.to_sym || :unicode
@@ -136,9 +180,6 @@ module GreenHat
       output += "\n" if flags[:table_style] == 'basic'
 
       output
-
-      # LogBot.debug('Finish Render Table') if ENV['DEBUG']
-      # Fall Back to Amazing Inspect
     rescue StandardError => e
       if ENV['DEBUG']
         LogBot.warn('Table', message: e.message)
@@ -168,201 +209,7 @@ module GreenHat
       # Default to everything
       files = Thing.all.map(&:name) if files.empty?
 
-      ShellHelper.filter_start(files, flags, args)
-    end
-
-    # Main Entry Point for Filtering
-    def self.filter_start(files, flags = {}, args = {})
-      # Convert to Things
-      logs = ShellHelper.find_things(files, flags).select(&:processed?)
-
-      # Ignore Archive/Host Dividers
-      if flags[:combine]
-        results = logs.reject(&:blank?).map(&:data).flatten.compact
-        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?
-
-          # Include Total Count in Name
-          results = ShellHelper.filter(log.data, flags, args)
-          duration = calculate_duration(results)
-
-          title = [
-            log.friendly_name,
-            " #{results.count}".pastel(:bright_black)
-
-          ]
-
-          # Append Duration
-          title.push(" #{duration.pastel(:cyan, :dim)}") unless duration.blank?
-
-          # Save unless empty
-          obj[title.join] = results unless results.count.zero?
-
-          obj
-        end
-      end
-    end
-
-    def self.calculate_duration(results)
-      # Skip for Pluck
-      only_with_time = results.select { |x| x.instance_of?(Hash) && x.key?(:time) }
-
-      # If slice is used ignore
-      return nil if only_with_time.empty?
-
-      sorted = only_with_time.map(&:time).sort
-      humanize_time(sorted.first, sorted.last)
-    end
-
-    # Replace TimeDifference with https://stackoverflow.com/a/4136485/1678507
-    def self.humanize_time(time_start, time_end, increments = 2)
-      miliseconds = (time_end - time_start) * 1000
-
-      list = [[1000, :ms], [60, :s], [60, :m], [24, :h]].map do |count, name|
-        next unless miliseconds.positive?
-
-        miliseconds, n = miliseconds.divmod(count)
-
-        "#{n.to_i}#{name}" unless n.to_i.zero?
-      end
-
-      list.compact.reverse[0..increments - 1].join(' ')
-    end
-
-    # Filter Logic
-    # TODO: Simplify
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    def self.filter(data, flags = {}, args = {})
-      # results = data.clone.flatten.compact
-
-      # Experimenting with deep clone
-      results = Marshal.load(Marshal.dump(data))
-      results.select! do |row|
-        args.send(flags.logic || :all?) 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 Zone
-      results = filter_modify_timezone(results, flags[:time_zone]) if flags.key?(:time_zone)
-
-      # Time Filtering
-      results = filter_time(results, flags) if flags.key?(:start) || flags.key?(:end)
-
-      # Strip Results if Slice is defined
-      results = filter_slice(results, flags[:slice]) if flags.key?(:slice)
-
-      # Strip Results if Except is defined
-      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(*flags[:sort]).values } if flags.key?(:sort)
-
-      # JSON Formatting
-      results = results.map { |x| Oj.dump(x) } if flags.key?(:json)
-
-      # Show Unique Only
-      results = filter_uniq(results, flags[:uniq]) if flags.key?(:uniq)
-
-      # Reverse
-      results.reverse! if flags[:reverse]
-
-      # Count occurrences / Skip Results
-      return filter_stats(results, flags) if flags.key?(:stats)
-
-      # Limit before Pluck / Flattening
-      results = filter_limit(results, flags[:limit]) if flags.key?(:limit)
-
-      # Pluck
-      results = filter_pluck(results, flags[:pluck]) if flags.key?(:pluck)
-
-      results
-    end
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    # Limit / Ensure Exists and Valid Number
-    def self.filter_limit(results, limit)
-      return results unless limit.integer? && limit.positive?
-
-      results.shift limit
-    end
-
-    def self.filter_modify_timezone(results, time_zone)
-      results.each do |x|
-        next unless x.key? :time
-
-        x[:time] = x[:time].in_time_zone time_zone
-      end
-
-      results
-    end
-
-    # Filter Start and End Times
-    # TODO: This is a bit icky, simplify/dry
-    def self.filter_time(results, flags)
-      if flags.key?(:start)
-        begin
-          time_start = Time.parse(flags[:start])
-
-          results.select! do |x|
-            if x.time
-              time_start < x.time
-            else
-              true
-            end
-          end
-        rescue StandardError
-          puts 'Unable to Process Start Time Filter'.pastel(:red)
-        end
-      end
-
-      if flags.key?(:end)
-        begin
-          time_start = Time.parse(flags[:end])
-
-          results.select! do |x|
-            if x.time
-              time_start > x.time
-            else
-              true
-            end
-          end
-        rescue StandardError
-          puts 'Unable to Process End Time Filter'.pastel(:red)
-        end
-      end
-
-      results
-    end
-
-    def self.filter_except(results, except)
-      # Avoid Empty Results
-      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? }
+      Query.start(files, flags, args)
     end
 
     def self.entry_truncate(entry, truncate)
@@ -376,184 +223,42 @@ module GreenHat
       "#{entry.to_s[0..truncate]} #{'...'.pastel(:bright_blue)}"
     end
 
-    def self.filter_slice(results, slice)
-      # Avoid Empty Results
-      if slice.empty?
-        filter_empty_arg('slice')
-        return results
-      end
-
-      results.map { |row| row.slice(*slice) }
-    end
-
-    def self.filter_pluck(results, pluck)
-      # Avoid Empty Results
-      if pluck.empty?
-        filter_empty_arg('pluck')
-        return results
-      end
-
-      results.map { |x| x.slice(*pluck).values }.flatten
-    end
-
-    def self.filter_uniq(results, unique)
-      # Avoid Empty Results
-      if unique.empty?
-        filter_empty_arg('uniq')
-        return results
-      end
-
-      unique.map do |field|
-        results.uniq { |x| x[field] }
-      end.inject(:&)
-    end
-
-    def self.filter_stats(results, flags)
-      stats = flags[:stats]
-
-      # Avoid Empty Results
-      if stats.empty?
-        filter_empty_arg('stats')
-        return results
-      end
-
-      # Loop through Stats, Separate Hash/Tables
-      stats.map do |field|
-        occurrences = filter_count_occurrences(results, field, flags)
-
-        # Use Truncate For Long Keys
-        occurrences.transform_keys! { |key| key.to_s[0..flags[:truncate]] } if flags[:truncate]
-
-        # 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, field, flags = {})
-      results.each_with_object(Hash.new(0)) do |entry, counts|
-        if entry.key? field
-          # Rounding in pagination breaks stats
-          key = if flags.key?(:round) && entry[field].numeric?
-                  entry[field].to_f.round(flags.round)
-                else
-                  entry[field]
-                end
-
-          counts[key] += 1
-        else
-          counts['None'.pastel(:bright_black)] += 1
-        end
-
-        counts
-      end
-    end
+    # Total Count Helper
+    def self.total_count(results, flags)
+      # Support Combine Helper
+      # TODO I Believe this should be removed now
+      # total_count_hash(results, flags) if results.instance_of? Hash
 
-    def self.filter_empty_arg(arg)
-      puts [
-        'Ignoring'.pastel(:bright_yellow),
-        "--#{arg}".pastel(:cyan),
-        'it requires an argument'.pastel(:red)
-      ].join(' ')
+      total_count_array(results, flags) if results.instance_of? Array
     end
 
-    # Break out filter row logic into separate method
-    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
-      search_data = arg[:field] == :text ? row : row[arg.field]
-      match = filter_row_entry(search_data.to_s, arg, flags)
-
-      # Pivot of off include vs exclude
-      if arg.bang
-        !match
-      else
-        match
+    # Hash Iteration
+    def self.total_count_hash(results, flags)
+      results.flat_map do |k, values|
+        [k, total_count_array(values, flags)]
       end
     end
 
-    # Field Partial / Case / Exact search
-    def self.filter_row_entry(entry, arg, flags)
-      # Exact Matching / Unless doing full text search
-      return entry == arg.value.to_s if flags.key?(:exact) && arg.field != :text
+    # List Calculation
+    def self.total_count_array(results, flags)
+      # Option to only return the count
+      return results.count if flags[:total] == 'simple'
 
-      # Cast to String/Integer Helper
-      entry, value = filter_entry_cast(entry, arg, flags)
+      output = {}
+      output[:total] = results.count
+      output[:duration] = Query.calculate_duration(results)
 
-      entry.send(arg.logic, value)
-    end
-
-    # Handle casting to strings or integers
-    def self.filter_entry_cast(entry, arg, flags)
-      # Cast to String
-      value = arg.value.to_s
-
-      case arg.logic
-      when :include?
-
-        # Exact Case argument
-        unless flags.key?(:case)
-          entry.downcase!
-          value.downcase!
-        end
-      when :>=, :<=
-        entry = entry.to_i if entry.numeric?
-        value = value.to_i if value&.numeric?
+      # Sort / Get first and Last
+      list = results.select(&:time).map(&:time)
+      unless list.blank?
+        output[:start] = list.first
+        output[:end] = list.last
       end
 
-      [entry, value]
-    end
+      # Hide empty results
+      output.reject! { |_k, v| v.blank? }
 
-    def self.filter_entry_logic(entry, arg)
-      entry.send(arg.logic, arg.value)
-    end
-
-    # Total Count Helper
-    def self.total_count(results, flags)
-      results.map do |k, v|
-        puts k
-        # puts "Total: #{v.count.to_s.pastel(:blue)}"
-        # puts "Time Covered: #{calculate_duration(v).pastel(:cyan)}"
-
-        output = {}
-        output[:total] = v.count
-        output[:duration] = calculate_duration(v)
-
-        # Sort / Get first and Last
-        list = v.select(&:time).map(&:time)
-        unless list.blank?
-          output[:start] = list.first
-          output[:end] = list.last
-        end
-
-        puts render_table(output, flags)
-
-        puts
-      end
+      render_table(output, flags)
     end
 
     # Table Printer Helper
@@ -590,12 +295,12 @@ module GreenHat
       file_list = prepare_list(file_list, base_list)
 
       # Convert to Things
-      find_things(file_list, flags)
+      find_things(file_list, flags, base_list)
     end
 
     # Total Log List Manipulator
-    def self.prepare_list(log_list, base_list = nil, _flags = {})
-      base_list ||= GreenHat::ShellHelper::Log.list
+    def self.prepare_list(log_list, base_list = nil)
+      base_list ||= Thing.list
 
       # Assume all
       log_list.push '*' if log_list.empty?
@@ -606,21 +311,23 @@ module GreenHat
       log_list
     end
 
-    # Fuzzy match for things
+    # Fuzzy match for things / List used for processable (Hash Entries)
     def self.thing_list
-      @thing_list ||= Thing.all.map(&:name)
+      @thing_list ||= Thing.list.map(&:name)
 
       @thing_list
     end
 
     # Shortcut find things
-    def self.find_things(files, flags = {})
-      things = files.uniq.flat_map do |file|
+    def self.find_things(file_list, flags = {}, base_list = nil)
+      base_list ||= Thing.all
+
+      things = file_list.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) || x.type.include?(file) }
+          base_list.select { |x| x.name.include?(file) || x.type.include?(file) }
         else
           Thing.where name: file
         end
@@ -666,5 +373,6 @@ module GreenHat
       puts
     end
   end
+
   # rubocop:enable Metrics/ModuleLength
 end

data/lib/greenhat/shell.rb

@@ -7,6 +7,10 @@ module GreenHat
       # rubocop:enable Lint/Debugger
     end
 
+    def self.settings
+      Settings.configure_settings
+    end
+
     def self.web
       # Load Required Files
       require 'greenhat/web'
@@ -14,10 +18,20 @@ module GreenHat
       GreenHat::Web.toggle
     end
 
+    # Append Log Location so follow up commands are executed there
+    def self.default(raw_list = [])
+      Cli.move_shell Shell::Log
+      Log.default(raw_list)
+    end
+
     def self.df
       Disk.df
     end
 
+    def self.quit(_raw = {})
+      exit 0
+    end
+
     def self.ps(raw = {})
       Process.ps raw
     end
@@ -60,7 +74,7 @@ module GreenHat
     end
 
     def self.quiet
-      Cli.quiet!
+      Cli.quiet_toggle
 
       if Cli.quiet
         puts "GreenHat Quiet Logging #{'Off'.pastel(:red)}"
@@ -93,8 +107,13 @@ module GreenHat
       end
     end
 
-    def self.ls
-      GreenHat::Cli.help(false)
+    def self.ls(raw = [])
+      if raw.empty?
+        GreenHat::Cli.help(false)
+      else
+        Cli.move_shell Shell::Log
+        Log.ls(raw)
+      end
     end
 
     def self.ll