chaos_detector 0.4.9

data/lib/chaos_detector/utils/core_util.rb

@@ -0,0 +1,117 @@
+# naught?("")
+# naught?(0)
+# naught?([])
+# naught?("foobar")
+# naught?(0)
+# naught?([])
+# module ChaosDetector
+
+# = ChaosDetector::Utils::CoreUtil::with
+module ChaosDetector
+  module Utils
+    module CoreUtil
+      class AssertError < StandardError; end
+
+      class << self
+        def enum(*values)
+          Module.new do |mod|
+            values.each_with_index do |v, _i|
+              mod.const_set(v.to_s.upcase, v.to_s.downcase.to_sym)
+              # mod.const_set(v.to_s.upcase, 2**i)
+            end
+
+            def mod.values
+              constants
+            end
+          end
+        end
+
+        def naught?(obj)
+          if obj.nil?
+            true
+          elsif obj.is_a?(FalseClass)
+            true
+          elsif obj.is_a?(TrueClass)
+            false
+          elsif obj.is_a?(String)
+            obj.strip.empty?
+          elsif obj.is_a?(Enumerable)
+            obj.none? { |o| aught?(o) }
+          elsif obj.is_a?(Numeric)
+            obj == 0
+          end
+        end
+
+        def aught?(obj)
+          !naught?(obj)
+        end
+
+        def with(obj, aught:false)
+          raise ArgumentError('with requires block') unless block_given?
+
+          yield obj if (aught ? aught?(obj) : !!obj)
+        end
+
+        def assert(expected_result=true, msg=nil, &block)
+          if block.nil? && !expected_result
+            raise AssertError, "Assertion failed. #{msg}"
+          elsif !block.nil? && block.call != expected_result
+            raise AssertError, "Assertion failed. #{msg}\n\t#{block.source_location}"
+          end
+        end
+
+        # @return subset of given properties not contained within given object
+        def properties_complement(props, obj:)
+          return props if obj.nil?
+          raise ArgumentError, 'props is required.' unless props
+
+          puts "(#{obj.class} )props: #{props}"
+
+          props - case obj
+                  when Hash
+                    puts 'KKKKK'
+                    puts "obj.keys: #{obj.keys}"
+                    obj.keys
+
+                  else
+                    puts "PPPPP #{obj.class}"
+                    puts "obj.public_methods: #{obj.public_methods}"
+                    obj.public_methods
+
+                  end
+        end
+
+        # Built-in self-testing:
+        # ChaosDetector::Utils::CoreUtil.test
+        def test
+          puts('Testing ChaosDetector::Utils::CoreUtil')
+          assert(true, 'Naught detects blank string') {naught?('')}
+          assert(true, 'Naught detects blank string with space') {naught?(' ')}
+          assert(true, 'Naught detects int 0') {naught?(0)}
+          assert(true, 'Naught detects float 0.0') {naught?(0.0)}
+          assert(true, 'Naught detects empty array') {naught?([])}
+          assert(true, 'Naught detects empty hash') {naught?({})}
+          assert(false, 'Naught real string') {naught?('foobar')}
+          assert(false, 'Naught non-zero int') {naught?(1)}
+          assert(false, 'Naught non-zero float') {naught?(33.33)}
+          assert(false, 'Naught non-empty array') {naught?(['stuff'])}
+          assert(false, 'Naught non-empty hash') {naught?({ foo: 'bar' })}
+        end
+      end
+
+      module ChaosAttr
+        def chaos_attr(attribute_name, default_val=nil, &block)
+          # raise 'Default value or block required' unless !default_val.nil? || block
+          sym = attribute_name&.to_sym
+          raise ArgumentError, 'attribute_name is required and convertible to symbol.' if sym.nil?
+
+          define_method(sym) do
+            instance_variable_get("@#{sym}") || (block.nil? ? default_val : block.call)
+          end
+
+          define_method("#{sym}=") { |val| instance_variable_set("@#{sym}", val) }
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/utils/fs_util.rb

@@ -0,0 +1,49 @@
+require 'fileutils'
+require 'pathname'
+require_relative 'core_util'
+
+module ChaosDetector
+  module Utils
+    module FSUtil
+      class << self
+
+        # Relative path:
+        def rel_path(dir_path, from_path:)
+          pathname = Pathname.new(dir_path)
+          base_path = Pathname.new(from_path).cleanpath
+          pathname.relative_path_from(base_path).to_s
+        end
+
+        # Ensure directory and all its parents exist, like (mkdir -p):
+        def ensure_dirpath(dirpath)
+          raise ArgumentError, '#ensure_paths_to_file requires dirpath' if nay? dirpath
+
+          FileUtils.mkdir_p(dirpath)
+        end
+
+        # Ensure file's directory and all its parents exist, then write given string to it:
+        def safe_file_write(filepath, content: nil)
+          raise ArgumentError, '#write_to_file requires filepath' if nay? filepath
+
+          ensure_paths_to_file(filepath)
+          File.write(filepath, content)
+          filepath
+        end
+
+        # Ensure file's directory and all its parents exist, like (mkdir -p):
+        def ensure_paths_to_file(filepath)
+          raise ArgumentError, '#ensure_paths_to_file requires filepath' if nay? filepath
+
+          dirpath = File.split(filepath).first
+          raise "dirpath couldn't be obtained from #{filepath}" if nay? dirpath
+
+          ensure_dirpath(dirpath)
+        end
+
+        def nay?(obj)
+          ChaosDetector::Utils::CoreUtil.naught?(obj)
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/utils/lerp_util.rb

@@ -0,0 +1,20 @@
+module ChaosDetector
+  module Utils
+    module LerpUtil
+      class << self
+
+        def delerp(val, min:, max:)
+          return 0.0 if min==max
+          (val - min).to_f / (max - min)
+        end
+
+        # Linear interpolation between min and max:
+        # @arg pct is percentage where 1.0 represents 100%
+        def lerp(pct, min:, max:)
+          return 0.0 if min==max
+          (max-min) * pct.to_f + min
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/utils/log_util.rb

@@ -0,0 +1,45 @@
+require_relative 'core_util'
+require_relative 'str_util'
+
+module ChaosDetector
+  module Utils
+    module LogUtil
+      class << self
+        # Simple logging, more later
+        def log(msg, object: nil, subject: nil)
+          # raise ArgumentError, "no message to log" if nay?(msg)
+          return if nay?(msg)
+
+          subj = d(subject, clamp: :brace)
+          obj = d(object, clamp: :bracket, prefix: ': ')
+          message = d(msg, prefix: subj, suffix: obj)
+
+          if block_given?
+            print_line(d(message, prefix: 'Starting: '))
+            result = yield
+            print_line(d(message, prefix: 'Complete: ', suffix: d(result)))
+          else
+            print_line(message)
+          end
+          message
+        end
+
+        def print_line(msg, *opts)
+          # print("#{msg}\n", opts)
+          # nil
+          Kernel.puts(msg, opts)
+        end
+
+        alias pp print_line
+
+        def nay?(obj)
+          ChaosDetector::Utils::CoreUtil.naught?(obj)
+        end
+
+        def d(text, *args)
+          ChaosDetector::Utils::StrUtil.decorate(text, *args)
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/utils/str_util.rb

@@ -0,0 +1,90 @@
+require_relative 'core_util'
+module ChaosDetector
+  module Utils
+    module StrUtil
+      STR_INDENT = '  '.freeze
+      STR_BLANK = ''.freeze
+      STR_NS_SEP = '::'.freeze
+      SPACE = ' '.freeze
+      SCORE = '_'.freeze
+
+      class << self
+
+        def decorate_pair(source, dest, indent_length: 0, clamp: :angle, join_str: ' ')
+          decorate("#{decorate(source)}#{decorate(dest, prefix: join_str)}", clamp: clamp, indent_length: indent_length)
+        end
+
+        def decorate_tuple(tuple, indent_length: 0, clamp: :angle, join_str: ' ')
+          body = tuple.map { |t| decorate(t, indent_length: indent_length)}.join(join_str)
+          decorate(body, clamp: clamp, indent_length: indent_length)
+        end
+
+        def decorate(text, clamp: :nil, prefix: nil, suffix: nil, sep: nil, indent_length: 0)
+          return '' if nay? text
+
+          clamp_pre, clamp_post = clamp_chars(clamp: clamp)
+          indent("#{prefix}#{sep}#{clamp_pre}#{text}#{clamp_post}#{sep}#{suffix}", indent_length)
+        end
+
+        def humanize_module(mod_name, max_segments: 2, sep_token: STR_NS_SEP)
+          return '' if nay? mod_name
+          raise ArgumentError, 'Must have at least 1 segment.' if max_segments < 1
+
+          mod_name.split(sep_token).last(max_segments).join(sep_token)
+        end
+
+        def snakeize(obj)
+          obj.to_s.gsub(/[^a-zA-Z\d\s:]/, SCORE)
+        end
+
+        def blank?(obj)
+          obj.nil? || obj.to_s.empty?
+        end
+
+        def squish(str)
+          str.to_s.strip.split.map(&:strip).join(SPACE)
+        end
+
+        def titleize(obj)
+          obj.to_s.split(SCORE).map(&:capitalize).join(SPACE)
+        end
+
+        alias d decorate
+
+        def clamp_chars(clamp: :none)
+          case clamp
+          when :angle, :arrow
+            ['<', '>']
+          when :brace
+            ['{', '}']
+          when :bracket
+            ['[', ']']
+          when :italic, :emphasize
+            %w[_ _]
+          when :strong, :bold, :stars
+            ['**', '**']
+          when :quotes, :double_quotes
+            ['"', '"']
+          when :ticks, :single_quotes
+            ["'", "'"]
+          when :none
+            [STR_BLANK, STR_BLANK]
+          else # :parens, :parentheses
+            ['(', ')']
+          end
+        end
+
+        def indent(text, indent_length=1)
+          return '' if nay? text
+          return text unless indent_length
+
+          "#{STR_INDENT * indent_length}#{text}"
+        end
+
+        def nay?(obj)
+          ChaosDetector::Utils::CoreUtil.naught?(obj)
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/utils/tensor_util.rb

@@ -0,0 +1,21 @@
+require 'matrix'
+require_relative 'lerp_util'
+module ChaosDetector
+  module Utils
+    module TensorUtil
+      class << self
+        # Return new matrix that is normalized from 0.0(min) to 1.0(max)
+        def normalize_matrix(matrix)
+          mag = matrix.row_size
+          raise ArgumentError if matrix.column_size != mag
+                    
+          lo, hi = matrix.minmax
+          
+          Matrix.build(mag) do |row, col|
+            ChaosDetector::Utils::LerpUtil.delerp(matrix[row, col], min: lo, max: hi)            
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chaos_detector/walkman.rb

@@ -0,0 +1,214 @@
+require 'csv'
+require 'digest'
+
+require 'chaos_detector/utils/fs_util'
+require 'chaos_detector/chaos_utils'
+
+require_relative 'options'
+require_relative 'stacker/frame'
+
+# TODO: add traversal types to find depth, coupling in various ways (directory/package/namespace):
+module ChaosDetector
+  class Walkman
+    PLAYBACK_MSG = "Playback error on line number %d of pre-recorded CSV %s:\n  %s\n  %s".freeze
+    CSV_HEADER = %w[ROWNUM EVENT MOD_NAME MOD_TYPE FN_PATH FN_LINE FN_NAME CALLER_TYPE CALLER_PATH CALLER_INFO CALLER_NAME].freeze
+    COL_COUNT = CSV_HEADER.length
+    COL_INDEXES = CSV_HEADER.map.with_index { |col, i| [col.downcase.to_sym, i]}.to_h
+
+    DEFALT_BUFFER_LENGTH = 1000
+
+    def initialize(options:)
+      @buffer_length = options.walkman_buffer_length || DEFALT_BUFFER_LENGTH
+      @options = options
+      flush_csv
+      @csv_path = nil
+      @log_buffer = []
+      @rownum = 0
+    end
+
+    def record_start
+      flush_csv
+      @csv_path = nil
+      @log_buffer = []
+      @rownum = 0
+      autosave_csv
+      init_file_with_header(csv_path)
+    end
+
+    # Return frame at given index or nil if nothing:
+    def frame_at(row_index:)
+      frames_within(row_range: row_index..row_index).first
+    end
+
+    # Return any frames within specified row range; empty array if not found:
+    def frames_within(row_range: nil)
+      to_enum(:playback, row_range: row_range).map { |_r, frame| frame }
+    end
+
+    # Play back CSV from path configured in Walkman options
+    # @param row_range optionally specify range of rows.  Leave nil for all.
+    # yields each row as
+    #   frame A Frame object with its attributes contained in the CSV row
+    def playback(row_range: nil)
+      started_at = Time.now
+
+      if row_range
+        log('Walkman replaying CSV with (row_range) %d/%d lines: %s' % [
+          [count, row_range.max].min,
+          count,
+          csv_path
+        ])
+      else
+        log("Walkman replaying CSV with #{count} lines: #{csv_path}")
+      end
+
+      @rownum = 0
+      row_cur = nil
+      CSV.foreach(csv_path, headers: true) do |row|
+        row_cur = row
+        yield @rownum, playback_row(row) if row_range.nil? || row_range.include?(@rownum)
+        @rownum += 1
+        break if row_range && @rownum > row_range.max
+      end
+    rescue StandardError => e
+      log("%s:\n%s" % [e.to_s, e.backtrace.join("\n")])
+      raise ScriptError, log(format(PLAYBACK_MSG, @rownum, csv_path, row_cur, e.inspect))
+    ensure
+      log('Replayed %d items in %.2f seconds' % [@rownum, Time.now - started_at])
+    end
+
+    def count
+      `wc -l #{csv_path}`.to_i
+    end
+
+    # Call when done to flush any buffers as necessary
+    def stop
+      flush_csv
+      log("Stopped with #{count} lines.")
+      self
+    end
+
+    def csv_path
+      @csv_path ||= @options.path_with_root(key: :frame_csv_path)
+    end
+
+    def autosave_csv
+      csvp = csv_path
+      if FileTest.exist?(csvp)
+        1.upto(100) do |n|
+          p = "#{csvp}.#{n}"
+          next if FileTest.exist?(p)
+
+          log("Autosaving #{csvp} to #{p}")
+          cp_result = `cp #{csvp} #{p}`
+          log(cp_result)
+          break
+        end
+      end
+    end
+
+    def buffered_trigger
+      if @log_buffer.length > @buffer_length
+        # log("Triggering flush @#{@log_buffer.length} / @buffer_length")
+        flush_csv
+      end
+    end
+
+    def log(msg, **opts)
+      ChaosUtils.log_msg(msg, subject: 'Walkman', **opts)
+    end
+
+    def flush_csv
+      # log("Flushing...")
+      if @log_buffer&.any?
+        CSV.open(csv_path, 'a') do |csv|
+          @log_buffer.each do |log_line|
+            csv << log_line
+          end
+        end
+        @log_buffer.clear
+      end
+    end
+
+    def write_frame(frame, frame_offset: nil)
+      csv_row = [@rownum]
+      csv_row.concat(frame_csv_fields(frame))
+
+      @log_buffer << csv_row
+      @rownum += 1
+      buffered_trigger
+    end
+
+  private
+
+    def csv_row_val(row, col_header)
+      r = COL_INDEXES[col_header]
+      raise ArgumentError, "#{col_header} not found in CSV_HEADER: #{CSV_HEADER}" if r.nil? || r < 0 || r > COL_COUNT
+
+      row[r]
+    end
+
+    def frame_csv_fields(f)
+      [
+        f.event,
+        f.mod_info&.mod_name,
+        f.mod_info&.mod_type,
+        f.fn_info.fn_path,
+        f.fn_info.fn_line,
+        f.fn_info.fn_name,
+        f.caller_info&.component_type,
+        f.caller_info&.path,
+        f.caller_info&.info,
+        f.caller_info&.name
+      ]
+    end
+
+    def init_file_with_header(filepath)
+      ChaosDetector::Utils::FSUtil.ensure_paths_to_file(filepath)
+      File.open(filepath, 'w') { |f| f.puts CSV_HEADER.join(',')}
+    end
+
+    # Play back a single given row
+    # returns the event and frame as described in #playback
+    def playback_row(row)
+      event = csv_row_val(row, :event)
+      fn_path = csv_row_val(row, :fn_path)
+      fn_line = csv_row_val(row, :fn_line)&.to_i
+
+      mod_info = ChaosDetector::Stacker::ModInfo.new(
+        mod_name: csv_row_val(row, :mod_name),
+        mod_path: fn_path,
+        mod_type: csv_row_val(row, :mod_type)
+      )
+
+      fn_info = ChaosDetector::Stacker::FnInfo.new(
+        fn_name: csv_row_val(row, :fn_name),
+        fn_line: fn_line,
+        fn_path: fn_path
+      )
+
+      caller_info = ChaosUtils.with(csv_row_val(row, :caller_type)) do |caller_type|
+        if caller_type.to_sym == :function
+          ChaosDetector::Stacker::FnInfo.new(
+            fn_name: csv_row_val(row, :caller_name),
+            fn_line: csv_row_val(row, :caller_info)&.to_i,
+            fn_path: csv_row_val(row, :caller_path)
+          )
+        else
+          ChaosDetector::Stacker::ModInfo.new(
+            mod_name: csv_row_val(row, :caller_name),
+            mod_path: csv_row_val(row, :caller_path),
+            mod_type: csv_row_val(row, :caller_info)
+          )
+        end
+      end
+
+      ChaosDetector::Stacker::Frame.new(
+        event: event.to_sym,
+        mod_info: mod_info,
+        fn_info: fn_info,
+        caller_info: caller_info
+      )
+    end
+  end
+end