scryglass 1.1.0 → 2.1.1

data/lib/refinements/clip_string_refinement.rb

@@ -6,21 +6,36 @@ module ClipStringRefinement
     def clip_at(clip_length, ignore_ansi_codes: false)
       length_method = ignore_ansi_codes ? :ansiless_length : :length
       original_length = send(length_method)
-      ansi_length = ignore_ansi_codes ? length - ansiless_length : 0
-      slice_length = clip_length + ansi_length
-      clipped_string = self[0...slice_length]
+
+      clipped_string = if ignore_ansi_codes
+                         self.ansi_slice(0...clip_length)
+                       else
+                         self[0...clip_length]
+                       end
       if clipped_string.send(length_method) < original_length
-        clipped_string = clipped_string.mark_as_abbreviated
+        clipped_string =
+          clipped_string.mark_as_abbreviated(ignore_ansi_codes: ignore_ansi_codes)
       end
 
       clipped_string
     end
 
+    def ansiless_clip_at(clip_length)
+      self.clip_at(clip_length, ignore_ansi_codes: true)
+    end
+
     # Warning: Still not going to work nicely if a string ends in an ansi code!
-    def mark_as_abbreviated
+    def mark_as_abbreviated(ignore_ansi_codes: false)
       self_dup = dup
-      self_dup[-1] = '…' if self_dup[-1]
-      self_dup[-2] = '…' if self_dup[-2]
+
+      if ignore_ansi_codes
+        self_dup.ansiless_set!(-1, '…') if self_dup.ansiless_pick(-1)
+        self_dup.ansiless_set!(-2, '…') if self_dup.ansiless_pick(-2)
+      else
+        self_dup[-1] = '…' if self_dup[-1]
+        self_dup[-2] = '…' if self_dup[-2]
+      end
+
       self_dup
     end
   end

data/lib/scryglass.rb

@@ -1,18 +1,23 @@
 # frozen_string_literal: true
-require 'stringio'
 
-## Bookkeeping and external tools:
+## Bookkeeping
 require "scryglass/version"
+
+## External tools:
 require 'io/console'
+require 'stringio'
 require 'pp'
+require 'amazing_print' # For use as a lens
+require 'method_source' # For use in lens_helper
+require 'binding_of_caller'
 require 'timeout'
 
 ## Refinements and sub-tools:
 require 'refinements/ansiless_string_refinement'
-# require 'refinements/ansi_slice_string_refinement' # Employed soon
 require 'refinements/clip_string_refinement'
 require 'refinements/constant_defined_string_refinement'
 require 'refinements/array_fit_to_refinement'
+require 'scryglass/lens_helper'
 require 'hexes'
 require 'prog'
 
@@ -20,7 +25,9 @@ require 'prog'
 require 'scryglass/config'
 require 'scryglass/ro'
 require 'scryglass/ro_builder'
+require 'scryglass/binding_tracker'
 require 'scryglass/session'
+require 'scryglass/session_manager'
 require 'scryglass/view_wrapper'
 require 'scryglass/view_panel'
 require 'scryglass/tree_panel'
@@ -28,57 +35,71 @@ require 'scryglass/lens_panel'
 
 ## Testing and Demoing:
 require 'example_material.rb'
-
+#test
 module Scryglass
-  HELP_SCREEN = <<~'HELPSCREENPAGE'
-          q : Quit Scry                               ? : Cycle help panels (1/2)
+  HELP_SCREEN = <<~"HELPSCREENPAGE"
+          \e[36mq\e[0m : Quit Scry                               \e[36m?\e[0m : Cycle help panels (1/2)
 
     BASIC NAVIGATION: · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·
       ·                                                                               ·
-      ·   UP / DOWN : Navigate (You can type a number first)                          ·
-      ·   RIGHT     : Expand   current or selected row(s)                             ·
-      ·   LEFT      : Collapse current or selected row(s)                             ·
+      ·   \e[36mUP / DOWN\e[0m : Navigate (To move further, type a number first or use \e[36mSHIFT\e[0m)    ·
+      ·   \e[36mRIGHT\e[0m     : Expand   current or selected row(s)                             ·
+      ·   \e[36mLEFT\e[0m      : Collapse current or selected row(s)                             ·
+      ·                                                                               ·
+      ·               (\e[36mh/j/k/l\e[0m  on the home row can also serve as arrow keys)         ·
       ·                                                                               ·
-      ·   ENTER : Close Scry, returning current or selected object(s) (Key or Value)  ·
+      ·   \e[36mENTER\e[0m : Close Scry, returning current or selected object(s) (Key or Value)  ·
       ·                                                                               ·
       · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·
 
     INSPECTING WITH LENS VIEW:  · · · · · · · · · · · · · ·
       ·                                                   ·
-      ·   SPACEBAR : Toggle Lens View                     ·
-      ·          l : Cycle through lens types             ·
-      ·          L : Toggle subject  (Key/Value of row)   ·
+      ·   \e[36mSPACEBAR\e[0m : Toggle Lens View                     ·
+      ·   \e[36m     >  \e[0m : Cycle through lens types             ·
+      ·   \e[36m   <    \e[0m : Toggle subject  (Key/Value of row)   ·
       ·                                                   ·
       · · · · · · · · · · · · · · · · · · · · · · · · · · ·
 
     MORE NAVIGATION:  · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·
       ·                                                                       ·
-      ·      [w]    :  Move view window           0 : Reset view location     ·
-      ·   [a][s][d]   (ALT increases speed)      (Press again: reset cursor)  ·
+      ·   \e[36m   [w]   \e[0m :  Move view window           \e[36m0\e[0m : Reset view location     ·
+      ·   \e[36m[a][s][d]\e[0m   (\e[36mALT\e[0m increases speed)      (Press again: reset cursor)  ·
       ·                                                                       ·
       · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·
   HELPSCREENPAGE
 
-  HELP_SCREEN_ADVANCED = <<~'HELPSCREENADVANCEDPAGE'
-          q : Quit Scry                               ? : Cycle help panels (2/2)
+  HELP_SCREEN_ADVANCED = <<~"HELPSCREENADVANCEDPAGE"
+          \e[36mq\e[0m : Quit Scry                               \e[36m?\e[0m : Cycle help panels (2/2)
 
     ADVANCED: · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·
       ·  DIGGING DEEPER:                                                                    ·
       ·    For current or selected row(s)...                                                ·
-      ·      @ : Build instance variable sub-rows                                           ·
-      ·      . : Build ActiveRecord association sub-rows                                    ·
-      ·      ( : Attempt to smart-build sub-rows, if Enumerable. Usually '@' is preferable. ·
+      ·      \e[36m@\e[0m : Build instance variable sub-rows                                           ·
+      ·      \e[36m.\e[0m : Build ActiveRecord association sub-rows                                    ·
+      ·      \e[36m(\e[0m : Attempt to smart-build sub-rows, if Enumerable. Usually '@' is preferable  ·
+      ·      \e[36mo\e[0m : Quick Open: builds the most likely helpful sub-rows ( '.' || '@' || '(' )  ·
+      ·        ·                                                                            ·
+      ·      \e[36mc\e[0m : Enter method text to call on object(s), results becomes navigable sub-rows ·
       ·                                                                                     ·
       ·  SELECTING ROWS:                                                                    ·
-      ·    * : Select/Deselect ALL rows                                                     ·
-      ·    | : Select/Deselect every sibling row under the same parent row                  ·
-      ·    - : Select/Deselect current row                                                  ·
+      ·    \e[36m*\e[0m : Select/Deselect ALL rows                                                     ·
+      ·    \e[36m|\e[0m : Select/Deselect every sibling row under the same parent row                  ·
+      ·    \e[36m-\e[0m : Select/Deselect current row                                                  ·
+      ·                                                                                     ·
+      ·  MANAGING MULTIPLE SESSION TABS:                                                    ·
+      ·    \e[36mTab\e[0m : Change session tab (to the right)  (\e[36mShift+Tab\e[0m moves left)                  ·
+      ·      \e[36mQ\e[0m : Close current session tab                                                  ·
+      ·      \e[36mt\e[0m : [Open new]... session tab with current or selected row(s) as the seed      ·
+      ·      \e[36mT\e[0m :  [Restart]... session tab with current or selected row(s) as the seed      ·
       ·                                                                                     ·
       ·  TEXT SEARCH:                                                                       ·
-      ·    / : Begin a text search (in tree view)                                           ·
-      ·    n : Move to next search result                                                   ·
+      ·    \e[36m/\e[0m : Begin a text search (in tree view)                                           ·
+      ·    \e[36mn\e[0m : Move to next search result                                                   ·
+      ·                                                                                     ·
+      ·                                                                                     ·
+      ·  \e[36m=\e[0m   : Open prompt to type a console handle for current or selected row(s)          ·
       ·                                                                                     ·
-      ·  Esc : Resets selection, last search, and number-to-move. (or returns to Tree View) ·
+      ·  \e[36mEsc\e[0m : Resets selection, last search, and number-to-move. (or returns to Tree View) ·
       ·                                                                                     ·
       · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·
   HELPSCREENADVANCEDPAGE
@@ -97,7 +118,8 @@ module Scryglass
 
   def self.load_silently
     begin
-      add_kernel_methods
+      add_kernel_method
+      create_scryglass_session_manager
       { success: true, error: nil }
     rescue => e
       { success: false, error: e }
@@ -130,8 +152,7 @@ module Scryglass
       |  >   my_object.scry
       |
       |  To resume the previous session:   (in same console session)
-      |  >   scry   OR
-      |  >   scry_resume (if you're in a breakpoint pry)
+      |  >   scry
       \e[0m
     CONSOLE_HELP
 
@@ -140,39 +161,51 @@ module Scryglass
 
   private
 
-  def self.add_kernel_methods
+  def self.create_scryglass_session_manager
+    $scry_session_manager = Scryglass::SessionManager.new
+  end
+
+  def self.add_kernel_method
     Kernel.module_eval do
-      def scry(arg = nil, actions = nil) # `actions` can't be a keyword arg due
-        #   to this ruby issue: https://bugs.ruby-lang.org/issues/8316
+      def scry(arg = nil, _actions = nil)
+        # `actions` can't be a keyword arg due to this ruby issue:
+        #   https://bugs.ruby-lang.org/issues/8316
 
-        receiver = self unless to_s == 'main'
+        Scryglass.config.validate!
+
+        current_console_binding = binding.of_caller(1)
+
+        receiver_is_just_the_console = self == current_console_binding.receiver
+        receiver = self unless receiver_is_just_the_console
         # As in: `receiver.scry`,
         #   and no receiver means scry was called on 'main', (unless self is
         #   different in the because you've pry'd into something!)
 
         seed_object = arg || receiver
 
-        $scry_session = Scryglass::Session.new(seed_object) if seed_object
-        # If it's been given an arg or receiver, create new session!
-        # The global variable is purposeful, and not accessible outside of
-        #   the one particular console instance.
-
-        scry_resume(actions) # Pick up the new or previous session
-      end
-
-      # For the user, this is mainly just for pry sessions where `self` isn't `main`
-      def scry_resume(actions = nil)
-        Scryglass.config.validate!
+        if seed_object
+          # If it's been given an arg or receiver, create new session!
+          # The global variable is purposeful, and not accessible outside of
+          #   the one particular console instance.
+          $scry_session_manager << Scryglass::Session.new(seed_object)
+        end
 
-        no_previous_session = $scry_session.nil?
-        if no_previous_session
+        unless $scry_session_manager.current_session
           raise ArgumentError,
-                '`scry` requires either an argument, a receiver, or a past' \
+                '`scry` requires either an argument, a receiver, or a past ' \
                 'session to reopen. try `Scryglass.help`'
         end
 
-        Hexes.stdout_rescue do
-          $scry_session.run_scry_ui(actions: actions)
+        $scry_session_manager.track_binding!(current_console_binding)
+
+        begin
+          Hexes.stdout_rescue do
+            $scry_session_manager.run_scry_ui
+          end
+        rescue => e # Here we ensure good visibility in case of errors
+          screen_height, _screen_width = $stdout.winsize
+          $stdout.write "\e[#{screen_height};1H\n" # (Moves console cursor to bottom left corner)
+          raise e
         end
       end
     end

data/lib/scryglass/binding_tracker.rb

@@ -0,0 +1,10 @@
+module Scryglass
+  class BindingTracker
+    attr_accessor :console_binding, :user_named_variables
+
+    def initialize(console_binding:)
+      self.user_named_variables = []
+      self.console_binding = console_binding
+    end
+  end
+end

data/lib/scryglass/config.rb

@@ -26,16 +26,25 @@ module Scryglass
       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: 'Amazing Print (`ap`)',
+          lambda: ->(o) { Hexes.capture_io(char_limit: 20_000) { ap o } } }, # This has colors!
         { 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) } },
+        { name: 'Method Showcase',
+          lambda: ->(o) { Scryglass::LensHelper.method_showcase_for(o, char_limit: 20_000) } },
       ]
 
+      ## AmazingPrint defaults, if the user has not set their own:
+      ::AmazingPrint.defaults ||= {
+        index: false,  # (Don't display array indices).
+        raw:   true,   # (Recursively format instance variables).
+      }
+      # See https://github.com/amazing-print/amazing_print
+
       ## Building ActiveRecord association sub-rows:
       self.include_empty_associations = true
       self.include_through_associations = false

data/lib/scryglass/lens_helper.rb

@@ -2,21 +2,83 @@
 
 module Scryglass
   module LensHelper
-    def method_showcase_for(object)
+    using ClipStringRefinement
+
+    def self.method_showcase_for(object, char_limit: nil)
+      # method_list = object.methods - Object.methods
       method_list = object.methods - Object.methods
+      return '' if method_list.empty?
+
       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"
+      method_list.sort!
+      running_method_showcase = ''.dup
+
+      method_list.each do |method_name|
+        label = method_name.to_s
+        label_padding = ' ' * [(label_space - label.length), 0].max
+        label = "\e[1;34m#{label}\e[0m" # make blue and bold
+
+        if char_limit && running_method_showcase.length >= char_limit
+          break
         end
-      end.join("\n")
+
+        running_method_showcase <<
+          begin
+            method = object.method(method_name)
+
+            method_source_location = method.source_location.to_a.join(':')
+            source_location_line =
+              unless method_source_location.empty?
+                "  \e[36m\e[4m#{method_source_location}\e[0m\n" # Cyan, underlined
+              end
+
+            highlighted_space = "\e[7m\s\e[0m"
+            method_lines = Hexes.capture_io { puts method.source }.split("\n")
+            method_lines.prepend('')
+            method_source = method_lines.map do |line|
+                              '    ' + highlighted_space + line
+                            end.join("\n")
+
+            translated_parameters = method.parameters.map do |pair|
+              arg_type = pair[0]
+              arg_name = pair[1]
+
+              case arg_type
+              when :req
+                "#{arg_name}"
+              when :opt
+                "#{arg_name} = ?"
+              when :keyreq
+                "#{arg_name}:"
+              when :key
+                "#{arg_name}: ?"
+              when :rest
+                "*#{arg_name}"
+              when :keyrest
+                "**#{arg_name}"
+              when :block
+                "&#{arg_name}"
+              end
+            end
+
+            arg_preview = "(#{translated_parameters.join(', ')})"
+
+            "#{label} #{arg_preview}\n" +
+              source_location_line +
+              "#{method_source}\n\n"
+          rescue => e
+            "#{label}#{label_padding}  :  " \
+              "Error: \e[31m#{e.message}\n\e[0m" +
+              (source_location_line || '') +
+              "\n"
+          end
+      end
+
+      if char_limit
+        running_method_showcase.ansiless_clip_at(char_limit)
+      else
+        running_method_showcase
+      end
     end
   end
 end

data/lib/scryglass/lens_panel.rb

@@ -51,29 +51,30 @@ module Scryglass
 
       ## 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.
+        string.ansi_slice(current_view_coords[:x], screen_width) || '' # 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")
+      sliced_list
     end
 
     def recalculate_y_boundaries
-      self.y_boundaries = 0...(uncut_body_string.count("\n") + 1)
+      number_of_lines = uncut_body_string.count("\n") + 1
+      preview_row = 1
+      self.y_boundaries = 0...(number_of_lines + preview_row)
     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
+      length_of_longest_line = split_lines.map(&:ansiless_length).max || 0
       max_line_length = [length_of_longest_line, screen_width].max
+      preview_column = 1
 
-      self.x_boundaries = 0...max_line_length
+      self.x_boundaries = 0...(max_line_length + preview_column)
     end
 
     def current_ro_subheader
@@ -85,10 +86,29 @@ module Scryglass
       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',
-                                       '@', '.', '(', '*', '|', '-']
+      tree_preview_related_keys = ::Scryglass::Session::KEY_MAP.slice(
+        :move_cursor_up,
+        :move_cursor_down,
+        :homerow_move_cursor_up,
+        :homerow_move_cursor_down,
+        :homerow_move_cursor_up_fast,
+        :homerow_move_cursor_down_fast,
+        :open_bucket,
+        :close_bucket,
+        :homerow_open_bucket,
+        :homerow_close_bucket,
+        :build_instance_variables,
+        :build_ar_relations,
+        :build_enum_children,
+        :smart_open,
+        :select_siblings,
+        :select_all,
+        :select_current,
+        :continue_search,
+      ).values
+
       ro_view_label =
-        if tree_preview_related_commands.include?(last_keypress)
+        if tree_preview_related_keys.include?(last_keypress)
           "\e[7mVIEWING:\e[00m" # Color reversed
         else
           'VIEWING:'
@@ -109,6 +129,7 @@ module Scryglass
       current_subject_type = scry_session.current_subject_type
       current_subject      = scry_session.current_ro.current_subject
       last_keypress        = scry_session.last_keypress
+      key_map              = ::Scryglass::Session::KEY_MAP
 
       lens_count = LensPanel.lenses.count
       lens_id    = current_lens % lens_count
@@ -117,23 +138,26 @@ module Scryglass
       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)
+      lens_type_header_length = 13 + (lens_count.to_s.length * 2)
                                   + longest_lens_name_length
-      subject_type_header  = "SUBJECT: #{current_subject_type}".ljust(14, ' ')
+      subject_type_header  = "[<] SUBJECT: #{current_subject_type}".ljust(18, ' ')
       subject_class_header = "   CLASS: #{current_subject.class}"
-      lens_type_header     = " LENS #{lens_id + 1}/#{lens_count}: #{lens[:name]}"
+      lens_type_header     = " [>] LENS #{lens_id + 1}/#{lens_count}: #{lens[:name]}"
                              .ljust(lens_type_header_length, ' ')
 
+      user_just_switched_lens         = last_keypress == key_map[:switch_lens]
+      user_just_switched_subject_type = last_keypress == key_map[:switch_subject_type]
+
+      if user_just_switched_lens
+        lens_type_header = "\e[7m#{lens_type_header}\e[00m" # Color reversed
+      elsif user_just_switched_subject_type
+        subject_type_header = "\e[7m#{subject_type_header}\e[00m" # Color reversed
+      end
+
       fit_lens_header = [
         subject_type_header, subject_class_header, lens_type_header
       ].fit_to(screen_width)
 
-      if last_keypress == 'l'
-        fit_lens_header[4] = "\e[7m#{fit_lens_header[4]}" # Format to be ended by Hexes.opacify_screen_string() (using \e[00m)
-      elsif last_keypress == 'L'
-        fit_lens_header[0] = "\e[7m#{fit_lens_header[0]}\e[00m"
-      end
-
       fit_lens_header.join('')
     end
   end