scryglass 0.1.0

data/lib/scryglass/config.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Scryglass
+  class Config
+    using ClipStringRefinement
+
+    attr_accessor :tab_length
+    attr_accessor :include_empty_associations,
+                  :include_through_associations, :include_scoped_associations,
+                  :show_association_types
+    attr_accessor :cursor_tracking
+    attr_accessor :lenses
+    attr_accessor :tree_view_key_string_clip_length,
+                  :tree_view_value_string_clip_length
+    attr_accessor :dot_coloring
+
+    def initialize
+      ## Display
+      self.tab_length = 2 # You can make it 0, but please don't make it 0.
+      self.tree_view_key_string_clip_length = 200
+      self.tree_view_value_string_clip_length = 500
+      self.dot_coloring = true
+
+      ## UX
+      self.cursor_tracking = [:flexible_range, :dead_center][0] # One or the other
+      self.lenses = [ # Custom lenses can easily be added as name+lambda hashes! Or comment some out to turn them off.
+        { name: 'Pretty Print (`pp`)',
+          lambda: ->(o) { Hexes.capture_io(char_limit: 20_000) { pp o } } },
+        { name: 'Inspect (`.inspect`)',
+          lambda: ->(o) { Hexes.capture_io(char_limit: 20_000) { puts o.inspect } } },
+        { name: 'Yaml Print (`y`)',
+          lambda: ->(o) { Hexes.capture_io(char_limit: 20_000) { require 'yaml' ; y o } } }, # OR: `puts o.to_yaml`
+        { name: 'Puts (`puts`)',
+          lambda: ->(o) { Hexes.capture_io(char_limit: 20_000) { puts o } } },
+        # { name: 'Method Showcase',
+        #   lambda: ->(o) { Scryglass::LensHelper.method_showcase_for(o) } },
+      ]
+
+      ## Building ActiveRecord association sub-rows:
+      self.include_empty_associations = true
+      self.include_through_associations = false
+      self.include_scoped_associations = false
+      self.show_association_types = true
+    end
+
+    def validate!
+      validate_boolean_attrs!
+      validate_positive_integer_attrs!
+      validate_cursor_tracking_options!
+      validate_lenses!
+    end
+
+    private
+
+    def validate_boolean_attrs!
+      bool_attrs = [
+        :include_empty_associations,
+        :include_through_associations,
+        :include_scoped_associations,
+        :dot_coloring,
+      ]
+      bool_attrs.each do |bool_attr|
+        value = send(bool_attr)
+        unless [true, false].include?(value)
+          raise ArgumentError, "#{bool_attr} must be true or false."
+        end
+      end
+    end
+
+    def validate_positive_integer_attrs!
+      positive_integer_attrs = [
+        :tab_length,
+        :tree_view_key_string_clip_length,
+        :tree_view_value_string_clip_length,
+      ]
+      positive_integer_attrs.each do |int_attr|
+        value = send(int_attr)
+        unless value.integer? && value.positive?
+          raise ArgumentError, "#{value} is not a positive integer."
+        end
+      end
+    end
+
+    def validate_cursor_tracking_options!
+      cursor_tracking_options = [:flexible_range, :dead_center]
+      unless cursor_tracking_options.include?(cursor_tracking)
+        raise ArgumentError, "#{cursor_tracking.inspect} not in " \
+                             "[#{cursor_tracking_options.map(&:inspect).join(', ')}]."
+      end
+    end
+
+    def validate_lenses!
+      raise ArgumentError, 'lenses cannot be empty' unless lenses.any?
+
+      lenses.each do |lens|
+        unless lens.is_a?(Hash) && lens[:name].is_a?(String) && lens[:lambda].lambda?
+          raise ArgumentError, "Lens #{lens.inspect} must be a hash of the form:" \
+                               '{ name: String, lambda: lambda }'
+        end
+      end
+    end
+  end
+end

data/lib/scryglass/lens_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Scryglass
+  module LensHelper
+    def method_showcase_for(object)
+      method_list = object.methods - Object.methods
+      label_space = [method_list.map(&:length).max, 45].min
+      method_list.sort.map do |method_name|
+        label = method_name.to_s.ljust(label_space, ' ')
+        begin
+          method = object.method(method_name)
+          label + '  :  ' +
+            method.source_location.to_a.join(':') + "\n" +
+            Hexes.capture_io { puts method.source }
+        rescue => e
+          label + '  :  Error: ' +
+            e.message + "\n"
+        end
+      end.join("\n")
+    end
+  end
+end

data/lib/scryglass/lens_panel.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Scryglass
+  class LensPanel < Scryglass::ViewPanel
+    using ClipStringRefinement
+    using AnsilessStringRefinement
+    using ArrayFitToRefinement
+
+    private
+
+    def self.lenses
+      Scryglass.config.lenses
+    end
+
+    def uncut_body_string
+      current_lens         = scry_session.current_lens
+      current_subject_type = scry_session.current_subject_type
+      current_subject      = scry_session.current_ro.current_subject
+      ro_has_no_key        = !scry_session.current_ro.key_value_pair?
+
+      return '' if ro_has_no_key && current_subject_type == :key
+
+      lens_id = current_lens % LensPanel.lenses.count
+      lens = LensPanel.lenses[lens_id]
+
+      scry_session.current_ro.lens_strings[current_subject_type][lens_id] ||=
+        begin
+          lens[:lambda].call(current_subject)
+        rescue => e
+          [e.message, *e.backtrace].join("\n")
+        end
+    end
+
+    def uncut_header_string
+      _screen_height, screen_width = $stdout.winsize
+      dotted_line = '·' * screen_width
+
+      [
+        current_ro_subheader,
+        dotted_line,
+        lens_param_subheader,
+        dotted_line
+      ].join("\n")
+    end
+
+    def visible_body_slice(uncut_body_string)
+      screen_height, screen_width = $stdout.winsize
+      non_header_view_size = screen_height - visible_header_string.split("\n").count
+
+      split_lines = uncut_body_string.split("\n")
+
+      ## Here we cut down the (rectangular) display array in both dimensions (into a smaller rectangle), as needed, to fit the view.
+      sliced_lines = split_lines.map do |string|
+        ansi_length = string.length - string.ansiless_length # Escape codes make `length` different from display length!
+        slice_length = screen_width + ansi_length
+        string[current_view_coords[:x], slice_length] || '' # If I don't want to
+        #   opacify here, I need to account for nils when the view is fully
+        #   beyond the shorter lines.
+      end
+      sliced_list = sliced_lines[current_view_coords[:y], non_header_view_size]
+
+      sliced_list.join("\n")
+    end
+
+    def recalculate_y_boundaries
+      self.y_boundaries = 0...(uncut_body_string.count("\n") + 1)
+    end
+
+    def recalculate_x_boundaries
+      _screen_height, screen_width = $stdout.winsize
+
+      split_lines = uncut_body_string.split("\n")
+      length_of_longest_line = split_lines.map(&:length).max || 0
+      max_line_length = [length_of_longest_line, screen_width].max
+
+      self.x_boundaries = 0...max_line_length
+    end
+
+    def current_ro_subheader
+      current_ro = scry_session.current_ro
+      user_input = scry_session.user_input
+
+      row_above_string =
+        current_ro.next_visible_ro_up.to_s if current_ro.next_visible_ro_up
+      row_below_string =
+        current_ro.next_visible_ro_down.to_s if current_ro.next_visible_ro_down
+
+      tree_preview_related_commands = ['A', 'B', 'C', 'D',
+                                       '@', '.', '(', '*', '|', '-']
+      ro_view_label =
+        if tree_preview_related_commands.include?(user_input)
+          "\e[7mVIEWING:\e[00m" # Color reversed
+        else
+          'VIEWING:'
+        end
+
+      current_ro_window =
+                "          #{row_above_string}\n" \
+        "#{ro_view_label}  #{current_ro}\n" \
+                "          #{row_below_string}"
+
+      current_ro_window
+    end
+
+    def lens_param_subheader
+      _screen_height, screen_width = $stdout.winsize
+
+      current_lens         = scry_session.current_lens
+      current_subject_type = scry_session.current_subject_type
+      current_subject      = scry_session.current_ro.current_subject
+      user_input           = scry_session.user_input
+
+      lens_count = LensPanel.lenses.count
+      lens_id    = current_lens % lens_count
+      lens       = LensPanel.lenses[lens_id]
+
+      longest_lens_name_length = LensPanel.lenses.map do |lens|
+                                   lens[:name].length
+                                 end.max
+      lens_type_header_length = 9 + (lens_count.to_s.length * 2)
+                                  + longest_lens_name_length
+      subject_type_header  = "SUBJECT: #{current_subject_type}".ljust(14, ' ')
+      subject_class_header = "   CLASS: #{current_subject.class}"
+      lens_type_header     = " LENS #{lens_id + 1}/#{lens_count}: #{lens[:name]}"
+                             .ljust(lens_type_header_length, ' ')
+
+      fit_lens_header = [
+        subject_type_header, subject_class_header, lens_type_header
+      ].fit_to(screen_width)
+
+      if user_input == 'l'
+        fit_lens_header[4] = "\e[7m#{fit_lens_header[4]}" # Format to be ended by Hexes.opacify_screen_string() (using \e[00m)
+      elsif user_input == 'L'
+        fit_lens_header[0] = "\e[7m#{fit_lens_header[0]}\e[00m"
+      end
+
+      fit_lens_header.join('')
+    end
+  end
+end

data/lib/scryglass/ro.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Scryglass
+  # A ro is essentially a complex wrapper for an object that deals with how it is
+  #   nested and displayed relative to other ros/objects.
+  class Ro
+    using ClipStringRefinement
+
+    attr_accessor :key, :value, :val_type,
+                  :key_string, :value_string, :lens_strings,
+                  :key_value_relationship_indicator, :special_sub_ro_type,
+                  :wrappers
+
+    attr_accessor :has_cursor, :expanded,
+                  :parent_ro, :sub_ros,
+                  :depth, :index, :scry_session
+
+    WRAPPER_TYPES = {
+      'Hash' => '{}',
+      'Array' => '[]',
+      'ActiveRecord_Relation' => '<>',
+      'ActiveRecord_Associations_CollectionProxy' => '‹›',
+    }.freeze
+
+    def initialize(scry_session:,
+                   val:,
+                   val_type:,
+                   parent_ro:,
+                   key:,
+                   depth:,
+                   key_value_relationship_indicator: false,
+                   special_sub_ro_type: nil)
+      key_clip_length = Scryglass.config.tree_view_key_string_clip_length
+      value_clip_length = Scryglass.config.tree_view_value_string_clip_length
+
+      self.has_cursor = false
+      self.expanded = false
+
+      self.key_value_relationship_indicator = key_value_relationship_indicator
+
+      ## Open up ViewWrappers and grab their objects and their custom strings
+      if key.class == Scryglass::ViewWrapper
+        self.key_string = key.to_s.clip_at(key_clip_length)
+        self.key = key.model
+      else
+        self.key_string = key.inspect.clip_at(key_clip_length)
+        self.key = key
+      end
+      if val.class == Scryglass::ViewWrapper
+        self.value_string = val.to_s.clip_at(value_clip_length)
+        self.value = val.model
+      else
+        self.value_string = val.inspect.clip_at(value_clip_length)
+        self.value = val
+      end
+
+      self.sub_ros = []
+      self.parent_ro = parent_ro
+      self.val_type = val_type
+      self.special_sub_ro_type = special_sub_ro_type
+      self.depth = depth
+      self.wrappers = WRAPPER_TYPES[value.class.to_s.split('::').last] || '?¿'
+
+      self.lens_strings = { key: {}, value: {} }
+
+      self.index = scry_session.all_ros.count
+      scry_session.all_ros << self
+      self.scry_session = scry_session
+    end
+
+    def top_ro?
+      parent_ro.nil?
+    end
+
+    def to_s
+      value_indicator =
+        bucket? ? bucket_indicator : value_string
+
+      key_value_spacer =
+        key_value_pair? ? key_string + key_value_relationship_indicator : ''
+
+      special_sub_ro_expansion_indicator =
+        special_sub_ros.any? && !expanded ? '•' : ' '
+
+      left_fill_string + special_sub_ro_expansion_indicator +
+        key_value_spacer + value_indicator
+    end
+
+    def next_visible_ro_down
+      subsequent_ros = scry_session.all_ros[(index + 1)..-1]
+      subsequent_ros.find(&:visible?)
+    end
+
+    def next_visible_ro_up
+      preceding_ros = scry_session.all_ros[0...index]
+      preceding_ros.reverse.find(&:visible?)
+    end
+
+    def current_subject
+      send(scry_session.current_subject_type)
+    end
+
+    def iv_sub_ros
+      sub_ros.select { |sub_ro| sub_ro.special_sub_ro_type == :iv }
+    end
+
+    def ar_sub_ros
+      sub_ros.select { |sub_ro| sub_ro.special_sub_ro_type == :ar }
+    end
+
+    def enum_sub_ros
+      sub_ros.select { |sub_ro| sub_ro.special_sub_ro_type == :enum }
+    end
+
+    # (Used for recalculate_indeces after new Ros have been injected)
+    def next_ro_without_using_index
+      if sub_ros.any?
+        sub_ros.first
+      elsif top_ro?
+        nil
+      elsif sibling_down.present?
+        sibling_down
+      else
+        upward_feeler_ro = self
+        until upward_feeler_ro.sibling_down.present? || upward_feeler_ro.top_ro?
+          upward_feeler_ro = upward_feeler_ro.parent_ro
+        end
+        upward_feeler_ro.sibling_down
+      end
+    end
+
+    def sibling_down
+      return nil if top_ro?
+
+      siblings = parent_ro.sub_ros
+      self_index = siblings.index(self)
+      return nil if self == siblings.last
+
+      siblings[self_index + 1]
+    end
+
+    ## This exists so that an easy *unordered array match* can occur elsewhere.
+    def <=>(other)
+      unless self.class == other.class
+        raise ArgumentError, "Comparison of #{self.class} with #{other.class}"
+      end
+
+      object_id <=> other.object_id
+    end
+
+
+    def visible?
+      return true if top_ro?
+
+      scanning_ro = parent_ro
+      until scanning_ro.top_ro? || !scanning_ro.expanded
+        scanning_ro = scanning_ro.parent_ro
+      end
+
+      scanning_ro.expanded
+    end
+
+    def bucket?
+      val_type == :bucket
+    end
+
+    def nugget?
+      val_type == :nugget
+    end
+
+    def key_value_pair?
+      !!key_value_relationship_indicator
+    end
+
+    private
+
+    def special_sub_ros
+      sub_ros.select(&:special_sub_ro_type)
+    end
+
+    def normal_sub_ros
+      sub_ros.reject(&:special_sub_ro_type)
+    end
+
+    def bucket_indicator
+      if expanded && normal_sub_ros.any?
+        wrappers[0]
+      elsif normal_sub_ros.any?
+        # Number of dots indicating order of magnitude for Enumerable's count:
+        #   Turning this off (the consistent three dots is more like an ellipsis,
+        #   communicating with a solid preexisting symbol), but keeping the idea here:
+        #     sub_ros_order_of_magnitude = normal_sub_ros.count.to_s.length
+        #     wrappers.dup.insert(1, '•' * sub_ros_order_of_magnitude)
+        wrappers.dup.insert(1, '•••')
+      else
+        wrappers
+      end
+    end
+
+    def left_fill_string
+      left_fill = if has_cursor
+                    cursor_string
+                  else
+                    ' ' * cursor_length
+                  end
+
+      if scry_session.special_command_targets.any? && scry_session.special_command_targets.map(&:index).include?(index)
+        left_fill[-2..-1] = '->'
+      end
+      left_fill
+    end
+
+    def cursor_length
+      tab_length = Scryglass.config.tab_length
+
+      consistent_margin = [4 - tab_length, 0].max
+
+      (tab_length * depth) + consistent_margin
+    end
+
+    def cursor_string
+      cursor = Scryglass::Session::CURSOR_CHARACTER * cursor_length
+
+      if nugget? && has_cursor && value.is_a?(Enumerable) &&
+                                  value.any? &&
+                                  enum_sub_ros.empty?
+        cursor[0] = '('
+      end
+
+      if value.instance_variables.any? && iv_sub_ros.empty?
+        cursor[1] = '@'
+      end
+
+      cursor
+    end
+  end
+end