scryglass 0.1.0

data/lib/scryglass/ro_builder.rb

@@ -0,0 +1,402 @@
+# frozen_string_literal: true
+
+module Scryglass
+  module RoBuilder
+    private
+
+    def roify(object,
+              parent_ro:,
+              key: nil,
+              key_value_relationship_indicator: false,
+              special_sub_ro_type: nil,
+              depth:)
+
+      given_ro_params = {
+        key: key,
+        key_value_relationship_indicator: key_value_relationship_indicator,
+        special_sub_ro_type: special_sub_ro_type,
+        parent_ro: parent_ro,
+        depth: depth
+      }
+
+      object_is_an_activerecord_enum = %w[ActiveRecord_Relation
+                                          ActiveRecord_Associations_CollectionProxy]
+                                       .include?(object.class.to_s.split('::').last)
+      ro =
+        if object.class == Hash
+          roify_hash(object, **given_ro_params)
+        elsif object.class == Array
+          roify_array(object, **given_ro_params)
+        elsif object_is_an_activerecord_enum
+          roify_ar_relation(object, **given_ro_params)
+        else
+          Scryglass::Ro.new(
+            scry_session: self,
+            val: object,
+            val_type: :nugget,
+            **given_ro_params
+          )
+        end
+
+      ro
+    end
+
+    def roify_array(array,
+                    key:,
+                    key_value_relationship_indicator:,
+                    parent_ro:,
+                    special_sub_ro_type: nil,
+                    depth:)
+      new_ro = Scryglass::Ro.new(
+        scry_session: self,
+        val: array,
+        val_type: :bucket,
+        key: key,
+        key_value_relationship_indicator: key_value_relationship_indicator,
+        special_sub_ro_type: special_sub_ro_type,
+        parent_ro: parent_ro,
+        depth: depth
+      )
+      return new_ro if array.empty?
+
+      task = Prog::Task.new(max_count: array.count)
+      progress_bar << task
+
+      array.each do |o|
+        new_ro.sub_ros << roify(o, parent_ro: new_ro, depth: depth + 1)
+        task.tick
+        print_progress_bar
+      end
+
+      new_ro
+    end
+
+    def roify_ar_relation(ar_relation,
+                          key:,
+                          key_value_relationship_indicator:,
+                          special_sub_ro_type: nil,
+                          parent_ro:,
+                          depth:)
+      new_ro = Scryglass::Ro.new(
+        scry_session: self,
+        val: ar_relation,
+        val_type: :bucket,
+        key: key,
+        key_value_relationship_indicator: key_value_relationship_indicator,
+        special_sub_ro_type: special_sub_ro_type,
+        parent_ro: parent_ro,
+        depth: depth
+      )
+      return new_ro if ar_relation.empty?
+
+      task = Prog::Task.new(max_count: ar_relation.count)
+      progress_bar << task
+
+      ar_relation.each do |o|
+        new_ro.sub_ros << roify(o, parent_ro: new_ro, depth: depth + 1)
+        task.tick
+        print_progress_bar
+      end
+
+      new_ro
+    end
+
+    def roify_hash(hash,
+                   key:,
+                   key_value_relationship_indicator:,
+                   special_sub_ro_type: nil,
+                   parent_ro:,
+                   depth:)
+      new_ro = Scryglass::Ro.new(
+        scry_session: self,
+        val: hash,
+        val_type: :bucket,
+        key: key,
+        key_value_relationship_indicator: key_value_relationship_indicator,
+        special_sub_ro_type: special_sub_ro_type,
+        parent_ro: parent_ro,
+        depth: depth
+      )
+      return new_ro if hash.empty?
+
+      task = Prog::Task.new(max_count: hash.count)
+      progress_bar << task
+
+      hash.each do |k, v|
+        new_ro.sub_ros << roify(v,
+              parent_ro: new_ro,
+              key: k,
+              key_value_relationship_indicator: ' => ',
+              depth: depth + 1)
+        task.tick
+        print_progress_bar
+      end
+
+      new_ro
+    end
+
+    def build_instance_variables_for_target_ros
+      original_ro_total = all_ros.count
+
+      if special_command_targets.any?
+        task = Prog::Task.new(max_count: special_command_targets.count)
+        progress_bar << task
+
+        target_ros = special_command_targets.dup # dup because some commands
+        #   create ros which are added to all_ros and then this process starts
+        #   adding them to the list of things it tries to act on!
+        target_ros.each do |target_ro|
+          build_iv_sub_ros_for(target_ro)
+          task.tick
+          print_progress_bar
+        end
+        self.special_command_targets = []
+      else
+        build_iv_sub_ros_for(current_ro)
+        expand!(current_ro) if current_ro.iv_sub_ros.any?
+      end
+
+      new_ro_total = all_ros.count
+      recalculate_indeces unless new_ro_total == original_ro_total
+    end
+
+    def build_activerecord_relations_for_target_ros
+      original_ro_total = all_ros.count
+
+      if special_command_targets.any?
+        task = Prog::Task.new(max_count: special_command_targets.count)
+        progress_bar << task
+
+        target_ros = special_command_targets.dup # dup because some commands
+        #   create ros which are added to all_ros and then this process starts
+        #   adding them to the list of things it tries to act on!
+        target_ros.each do |target_ro|
+          build_ar_sub_ros_for(target_ro)
+          task.tick
+          print_progress_bar
+        end
+        self.special_command_targets = []
+      else
+        build_ar_sub_ros_for(current_ro)
+        expand!(current_ro) if current_ro.ar_sub_ros.any?
+      end
+      new_ro_total = all_ros.count
+
+      recalculate_indeces unless new_ro_total == original_ro_total
+    end
+
+    def build_enum_children_for_target_ros
+      original_ro_total = all_ros.count
+
+      if special_command_targets.any?
+        task = Prog::Task.new(max_count: special_command_targets.count)
+        progress_bar << task
+
+        target_ros = special_command_targets.dup # dup because some commands
+        #   create ros which are added to all_ros and then this process starts
+        #   adding them to the list of things it tries to act on!
+        target_ros.each do |target_ro|
+          build_enum_children_for(target_ro)
+          task.tick
+          print_progress_bar
+        end
+        self.special_command_targets = []
+      else
+        build_enum_children_for(current_ro)
+        expand!(current_ro) if current_ro.enum_sub_ros.any?
+      end
+
+      new_ro_total = all_ros.count
+      recalculate_indeces unless new_ro_total == original_ro_total
+    end
+
+    def recalculate_indeces
+      all_ordered_ros = []
+      scanning_ro = top_ro
+
+      task = Prog::Task.new(max_count: all_ros.count)
+      progress_bar << task
+
+      while scanning_ro
+        all_ordered_ros << scanning_ro
+        next_ro = scanning_ro.next_ro_without_using_index
+        scanning_ro = next_ro
+        task.tick
+        print_progress_bar
+      end
+
+      self.all_ros = all_ordered_ros
+      all_ros.each.with_index { |ro, i| ro.index = i }
+      task.force_finish # Just in case
+    end
+
+    def build_iv_sub_ros_for(ro)
+      return if ro.iv_sub_ros.any?
+
+      iv_names = ro.value.instance_variables
+      return if iv_names.empty?
+
+      prog_task = Prog::Task.new(max_count: iv_names.count)
+      progress_bar << prog_task
+
+      iv_names.each do |iv_name|
+        iv_value = rescue_to_viewwrapped_error do
+                     ro.value.instance_variable_get(iv_name)
+                   end
+        iv_key = Scryglass::ViewWrapper.new(iv_name,
+                                            string: iv_name.to_s) # to_s removes ':'
+        ro.sub_ros << roify(iv_value,
+                            parent_ro: ro,
+                            key: iv_key,
+                            key_value_relationship_indicator: ' : ',
+                            special_sub_ro_type: :iv,
+                            depth: ro.depth + 1)
+        prog_task.tick
+        print_progress_bar
+      end
+    end
+
+    def build_ar_sub_ros_for(ro)
+      return if ro.ar_sub_ros.any?
+      return unless ro.value.class.respond_to?(:reflections)
+
+      reflections = ro.value.class.reflections
+
+      include_empty_associations =
+        Scryglass.config.include_empty_associations
+      include_through_associations =
+        Scryglass.config.include_through_associations
+      include_scoped_associations =
+        Scryglass.config.include_scoped_associations
+      show_association_types =
+        Scryglass.config.show_association_types
+
+      through_filter = lambda do |info|
+        include_through_associations || !info.options[:through]
+      end
+
+      scope_filter = lambda do |info|
+        include_scoped_associations || !info.scope
+        # This... `info.scope`
+        #   is to get rid of extraneous custom scoped associations
+        #   like current_primary_phone_number_record.
+      end
+
+      direct_close_reflections = reflections.select do |_, info|
+                                   through_filter.call(info) &&
+                                     scope_filter.call(info)
+                                 end
+
+      relation_names = direct_close_reflections.keys
+      return if relation_names.empty?
+
+      task = Prog::Task.new(max_count: relation_names.count)
+      progress_bar << task
+
+      direct_close_reflections.sort_by { |relation_name, _info| relation_name }
+                              .each do |relation_name, info|
+        ar_value = Hexes.hide_db_outputs do
+          rescue_to_viewwrapped_error do
+            ro.value.send(relation_name)
+          end
+        end
+
+        relationship_type = info.macro.to_s.split('_')
+                                .map { |s| s[0].upcase }.join('')
+        relationship_type = "(#{relationship_type})"
+
+        is_through = info.options.keys.include?(:through)
+        if include_through_associations
+          through_indicator = is_through ? '(t)' : '   '
+        end
+
+        is_scoped = info.scope.present?
+        if include_scoped_associations
+          scoped_indicator = is_scoped ? '(s)' : '   '
+        end
+
+        relation_representation =
+          if show_association_types
+            "#{relationship_type}#{through_indicator}#{scoped_indicator} #{relation_name}"
+          else
+            relation_name.to_s
+          end
+
+        if ar_value.present? || include_empty_associations
+          ar_key = Scryglass::ViewWrapper.new(
+            relation_name,
+            string: relation_representation
+          )
+          ro.sub_ros << roify(ar_value,
+                              parent_ro: ro,
+                              key: ar_key,
+                              key_value_relationship_indicator: ': ',
+                              special_sub_ro_type: :ar,
+                              depth: ro.depth + 1)
+        end
+
+        task.tick
+        print_progress_bar
+      end
+    end
+
+    def build_enum_children_for(ro)
+      return if ro.enum_sub_ros.any?
+      return if ro.bucket?
+      return unless ro.value.is_a?(Enumerable)
+
+      pretend_klass = if ro.value.respond_to?(:keys)
+                        Hash
+                      elsif ro.value.respond_to?(:each)
+                        Array
+                      end
+
+      if pretend_klass == Hash
+        key_names = ro.value.keys
+        return if key_names.empty?
+
+        prog_task = Prog::Task.new(max_count: key_names.count)
+        progress_bar << prog_task
+
+        ro.value.each do |key, value|
+          ro.sub_ros << roify(value,
+                              parent_ro: ro,
+                              key: key,
+                              key_value_relationship_indicator: ' => ',
+                              special_sub_ro_type: :enum,
+                              depth: ro.depth + 1)
+          prog_task.tick
+          print_progress_bar
+        end
+      elsif pretend_klass == Array
+        return if ro.value.count.zero?
+
+        prog_task = Prog::Task.new(max_count: ro.value.count)
+        progress_bar << prog_task
+
+        ro.value.each do |value|
+          ro.sub_ros << roify(value,
+                              parent_ro: ro,
+                              special_sub_ro_type: :enum,
+                              depth: ro.depth + 1)
+          prog_task.tick
+          print_progress_bar
+        end
+      end
+    end
+
+    def rescue_to_viewwrapped_error
+      begin
+        successful_yielded_return = yield
+      rescue => e
+        legible_error_string = [e.message, *e.backtrace].join("\n")
+        viewwrapped_error = Scryglass::ViewWrapper.new(
+          legible_error_string,
+          string: '«ERROR»'
+        )
+      ensure
+        viewwrapped_error || successful_yielded_return
+      end
+    end
+  end
+end

data/lib/scryglass/session.rb

@@ -0,0 +1,514 @@
+# frozen_string_literal: true
+
+class Scryglass::Session
+  include Scryglass::RoBuilder
+
+  using AnsilessStringRefinement
+
+  attr_accessor :all_ros, :current_ro, :special_command_targets
+
+  attr_accessor :current_view_coords, :current_lens, :current_subject_type,
+                :view_panels, :current_panel_type,
+                :progress_bar
+
+  attr_accessor :user_input, :last_search, :number_to_move
+
+  CURSOR_CHARACTER = '–' # These are en dashes (alt+dash), not hyphens or em dashes.
+
+  SEARCH_PROMPT = "\e[7mSearch for (regex, case-sensitive): /\e[00m"
+
+  SESSION_CLOSED_MESSAGE = '(Exited scry! Resume session with `scry` or `scry_resume`)'
+
+  SUBJECT_TYPES = [
+    :value,
+    :key
+  ].freeze
+
+  CSI = "\e[" # "(C)ontrol (S)equence (I)ntroducer" for ANSI sequences
+
+  def initialize(seed)
+    self.all_ros = []
+    self.current_lens = 0
+    self.current_subject_type = :value
+    self.current_panel_type = :tree
+    self.special_command_targets = []
+    self.number_to_move = ''
+    self.user_input = nil
+    self.progress_bar = Prog::Pipe.new
+
+    top_ro = roify(seed, parent_ro: nil, depth: 1)
+    top_ro.has_cursor = true
+    self.current_ro = top_ro
+
+    expand!(top_ro)
+
+    self.view_panels = {
+      tree: Scryglass::TreePanel.new(scry_session: self),
+      lens: Scryglass::LensPanel.new(scry_session: self),
+    }
+  end
+
+  def run_scry_ui(actions:)
+    in_scry_session = true
+    redraw = true
+
+    case actions
+    when :record
+      $scry_session_actions_performed = []
+    when :playback
+      if $scry_session_actions_performed.blank?
+        raise 'Could not find recording of previous session\'s actions'
+      end
+      @input_stack = $scry_session_actions_performed.dup
+    end
+
+    # We print a full screen of lines so the first call of draw_screen doesn't
+    #   write over any previous valuable content the user had in the console.
+    print Hexes.opacify_screen_string(Hexes.simple_screen_slice(boot_screen))
+
+    while in_scry_session
+      draw_screen if redraw
+      redraw = true
+
+      case actions
+      when :record
+        self.user_input = $stdin.getch
+        $scry_session_actions_performed << user_input
+      when :playback
+        if @input_stack.any? # (IV to be easily accessible for debugging)
+          self.user_input = @input_stack.shift
+          sleep 0.05
+        else
+          self.user_input = $stdin.getch
+        end
+      else
+        self.user_input = $stdin.getch
+      end
+
+      wait_start_time = Time.now
+
+      case user_input
+      when "\u0003"
+        set_console_cursor_below_content
+        raise IRB::Abort, 'Ctrl+C Detected'
+      when 'q'
+        in_scry_session = false
+        visually_close_ui
+      when '1'
+        self.number_to_move += '1'
+        redraw = false # This allows you to type multi-digit number very
+        #   quickly and still have it process all the digits.
+      when '2'
+        self.number_to_move += '2'
+        redraw = false
+      when '3'
+        self.number_to_move += '3'
+        redraw = false
+      when '4'
+        self.number_to_move += '4'
+        redraw = false
+      when '5'
+        self.number_to_move += '5'
+        redraw = false
+      when '6'
+        self.number_to_move += '6'
+        redraw = false
+      when '7'
+        self.number_to_move += '7'
+        redraw = false
+      when '8'
+        self.number_to_move += '8'
+        redraw = false
+      when '9'
+        self.number_to_move += '9'
+        redraw = false
+      when '0'
+        if number_to_move.present? # You can append zeros to number_to_move...
+          self.number_to_move += '0'
+          redraw = false
+        else # ...but otherwise it's understood to be a view||cursor reset.
+          reset_the_view_or_cursor
+        end
+      when 'A' # Up arrow
+        action_count = number_to_move.present? ? number_to_move.to_i : 1
+        navigate_up_multiple(action_count)
+
+        self.number_to_move = ''
+        lens_view.recalculate_boundaries if current_panel_type == :lens
+        tree_view.slide_view_to_cursor
+      when 'B' # Down arrow
+        action_count = number_to_move.present? ? number_to_move.to_i : 1
+        navigate_down_multiple(action_count)
+
+        self.number_to_move = ''
+        lens_view.recalculate_boundaries if current_panel_type == :lens
+        tree_view.slide_view_to_cursor
+      when 'C' # Right arrow
+        expand_targets
+      when 'D' # Left arrow
+        collapse_targets
+        lens_view.recalculate_boundaries if current_panel_type == :lens
+      when ' '
+        toggle_view_panel
+        lens_view.recalculate_boundaries if current_panel_type == :lens
+      when 'l'
+        scroll_lens_type
+        lens_view.recalculate_boundaries if current_panel_type == :lens
+      when 'L'
+        toggle_current_subject_type
+        lens_view.recalculate_boundaries if current_panel_type == :lens
+      when 'w'
+        current_view_panel.move_view_up(5)
+      when 's'
+        current_view_panel.move_view_down(5)
+      when 'a'
+        current_view_panel.move_view_left(5)
+      when 'd'
+        current_view_panel.move_view_right(5)
+      when '∑' # Alt+w
+        current_view_panel.move_view_up(50)
+      when 'ß' # Alt+s
+        current_view_panel.move_view_down(50)
+      when 'å' # Alt+a
+        current_view_panel.move_view_left(50)
+      when '∂' # Alt+d
+        current_view_panel.move_view_right(50)
+      when '?'
+        in_scry_session = run_help_screen_ui
+      when '@'
+        build_instance_variables_for_target_ros
+        tree_view.recalculate_boundaries
+        tree_view.slide_view_to_cursor # Just a nice-to-have
+      when '.'
+        build_activerecord_relations_for_target_ros
+        tree_view.recalculate_boundaries
+        tree_view.slide_view_to_cursor # Just a nice-to-have
+      when '('
+        build_enum_children_for_target_ros
+        tree_view.recalculate_boundaries
+        tree_view.slide_view_to_cursor # Just a nice-to-have
+      when '|'
+        sibling_ros = if current_ro.top_ro?
+                        [top_ro]
+                      else
+                        current_ro.parent_ro.sub_ros.dup # If we don't dup,
+                        #   then '-' can remove ros from `sub_ros`.
+                      end
+        if special_command_targets.sort == sibling_ros.sort
+          self.special_command_targets = []
+        else
+          self.special_command_targets = sibling_ros
+        end
+      when '*'
+        all_the_ros = all_ros.dup # If we don't dup,
+        #   then '-' can remove ros from all_ros.
+        if special_command_targets.sort == all_the_ros.sort
+          self.special_command_targets = []
+        else
+          self.special_command_targets = all_the_ros
+        end
+      when '-'
+        if special_command_targets.include?(current_ro)
+          special_command_targets.delete(current_ro)
+        else
+          special_command_targets << current_ro
+        end
+      when '/'
+        $stdout.write "#{CSI}1;1H" # (Moves console cursor to top left corner)
+        $stdout.write SEARCH_PROMPT
+        $stdout.write "#{CSI}1;#{SEARCH_PROMPT.ansiless_length + 1}H" # (Moves
+        #   console cursor to just after the search prompt, before user types)
+        query = $stdin.gets.chomp
+        if query.present?
+          self.last_search = query
+          go_to_next_search_result
+        end
+      when 'n'
+        if last_search
+          go_to_next_search_result
+        else
+          $stdout.write "#{CSI}1;1H" # (Moves console cursor to top left corner)
+          $stdout.write "\e[7m-- No Search has been entered --\e[00m"
+          sleep 2
+        end
+      when "\r" # [ENTER]
+        visually_close_ui
+        return subjects_of_target_ros
+      end
+
+      print "\a" if Time.now - wait_start_time > 4 && user_input != '?' # (Audio 'beep')
+    end
+  end
+
+  def top_ro
+    all_ros.first
+  end
+
+  private
+
+  def print_progress_bar
+    screen_height, _screen_width = $stdout.winsize
+    bar = progress_bar.to_s
+    $stdout.write "#{CSI}#{screen_height};1H" # (Moves console cursor to bottom left corner)
+    print bar if bar.present?
+  end
+
+  def current_view_panel
+    view_panels[current_panel_type]
+  end
+
+  def tree_view
+    view_panels[:tree]
+  end
+
+  def lens_view
+    view_panels[:lens]
+  end
+
+  def colorize(screen_string)
+    dot = '•'
+    cyan_dot = "\e[36m#{dot}\e[00m" # cyan then back to *default*
+    screen_string.gsub!('•', cyan_dot)
+
+    screen_string
+  end
+
+  def display_active_searching_indicator
+    $stdout.write "#{CSI}1;1H" # (Moves console cursor to top left corner)
+    message = ' Searching... '
+    pad = SEARCH_PROMPT.length - message.length
+    wing = '-' * (pad / 2)
+
+    $stdout.write "\e[7m#{wing + message + wing}\e[00m"
+  end
+
+  def go_to_next_search_result
+    display_active_searching_indicator
+
+    cut_point = current_ro.index
+    search_set = ((cut_point + 1)...all_ros.count).to_a + (0...cut_point).to_a
+
+    task = Prog::Task.new(max_count: search_set.count)
+    progress_bar << task
+
+    index_of_next_match = search_set.find do |index|
+      scanned_ro = all_ros[index]
+      task.tick
+      print_progress_bar
+      scanned_ro.key_string =~ /#{last_search}/ ||
+        (scanned_ro.nugget? && scanned_ro.value_string =~ /#{last_search}/)
+    end
+    task.force_finish
+
+    if index_of_next_match
+      next_found_ro = all_ros[index_of_next_match]
+      move_cursor_to(next_found_ro)
+
+      scanning_ro = next_found_ro
+      while scanning_ro.parent_ro
+        expand!(scanning_ro.parent_ro)
+        scanning_ro = scanning_ro.parent_ro
+      end
+
+      tree_view.recalculate_boundaries # Yes, necessary :)
+      lens_view.recalculate_boundaries # Yes, necessary :)
+      tree_view.current_view_coords = { y: 0, x: 0 }
+      tree_view.slide_view_to_cursor
+    else
+      $stdout.write "#{CSI}1;1H" # (Moves console cursor to top left corner)
+      message = ' No Match Found '
+      pad = SEARCH_PROMPT.length - message.length
+      wing = '-' * (pad / 2)
+
+      $stdout.write "\e[7m#{wing + message + wing}\e[00m"
+      sleep 2
+    end
+  end
+
+  def run_help_screen_ui
+    screen_height, _screen_width = $stdout.winsize
+
+    in_help_screen = true
+    current_help_screen_index = 0
+    help_screens = [Scryglass::HELP_SCREEN, Scryglass::HELP_SCREEN_ADVANCED]
+
+    while in_help_screen
+      current_help_screen = help_screens[current_help_screen_index]
+      sliced_help_screen = Hexes.simple_screen_slice(current_help_screen)
+      help_screen_string = Hexes.opacify_screen_string(sliced_help_screen)
+      Hexes.overwrite_screen(help_screen_string)
+      help_screen_user_input = $stdin.getch
+
+      case help_screen_user_input
+      when '?'
+        current_help_screen_index += 1
+      when 'q'
+        $stdout.write "#{CSI}#{screen_height};1H" # (Moves console cursor to
+        #   bottom left corner). This helps 'q' not print the console prompt at
+        #   the top of the screen, overlapping with the old display.
+        return false
+      when "\u0003"
+        screen_height, _screen_width = $stdout.winsize
+        puts "\n" * screen_height
+        raise IRB::Abort, 'Ctrl+C Detected'
+      end
+
+      current_help_screen = help_screens[current_help_screen_index]
+      unless current_help_screen
+        return true
+      end
+    end
+  end
+
+  def collapse_targets
+    if special_command_targets.any?
+      target_ros = special_command_targets.dup # dup because some commands
+      #  create ros which are added to all_ros and then this process starts
+      #  adding them to the list of things it tries to act on!
+      target_ros.each { |target_ro| collapse!(target_ro) }
+      self.special_command_targets = []
+    elsif current_ro.expanded
+      collapse!(current_ro)
+    elsif current_ro.parent_ro
+      collapse!(current_ro.parent_ro)
+    end
+
+    move_cursor_to(current_ro.parent_ro) until current_ro.visible?
+    tree_view.slide_view_to_cursor
+    tree_view.recalculate_boundaries # TODO: should these be conditional? If they are, I might need a potential tree view recalc after toggling lens view to tree view.
+  end
+
+  def expand_targets
+    if special_command_targets.any?
+      target_ros = special_command_targets.dup # dup because some commands
+      #  create ros which are added to all_ros and then this process starts
+      #  adding them to the list of things it tries to act on!
+      target_ros.each { |target_ro| expand!(target_ro) }
+      self.special_command_targets = []
+    else
+      expand!(current_ro)
+    end
+    tree_view.recalculate_boundaries
+  end
+
+  def reset_the_view_or_cursor
+    if current_view_panel.current_view_coords != { x: 0, y: 0 }
+      current_view_panel.current_view_coords = { x: 0, y: 0 }
+    elsif current_panel_type == :tree
+      move_cursor_to(top_ro)
+    end
+  end
+
+  def draw_screen
+    current_view_panel.ensure_correct_view_coords
+    screen_string = current_view_panel.screen_string
+
+    screen_string = colorize(screen_string) if Scryglass.config.dot_coloring
+    Hexes.overwrite_screen(screen_string)
+    $stdout.write "#{CSI}1;1H" # Moves terminal cursor to top left corner,
+                               #   mostly for consistency.
+  end
+
+  def set_console_cursor_below_content
+    bare_screen_string =
+      current_view_panel.visible_header_string + "\n" +
+      current_view_panel.visible_body_string
+    split_lines = bare_screen_string.split("\n")
+    rows_filled = split_lines.count
+    $stdout.write "#{CSI}#{rows_filled};1H\n" # Moves console cursor to bottom
+                                              #   of *content*, then one more.
+  end
+
+  def visually_close_ui
+    _screen_height, screen_width = $stdout.winsize
+    set_console_cursor_below_content
+    puts '·' * screen_width, "\n"
+    puts SESSION_CLOSED_MESSAGE
+  end
+
+  def subjects_of_target_ros
+    if special_command_targets.any?
+      return_targets = special_command_targets
+      self.special_command_targets = []
+      return return_targets.map(&:current_subject)
+    end
+
+    current_ro.current_subject
+  end
+
+  def navigate_up_multiple(action_count)
+    task = Prog::Task.new(max_count: action_count)
+    progress_bar << task
+    action_count.times do
+      navigate_up
+      task.tick
+      print_progress_bar
+    end
+  end
+
+  def navigate_down_multiple(action_count)
+    task = Prog::Task.new(max_count: action_count)
+    progress_bar << task
+    action_count.times do
+      navigate_down
+      task.tick
+      print_progress_bar
+    end
+  end
+
+  def expand!(ro)
+    ro.expanded = true if ro.sub_ros.any?
+  end
+
+  def collapse!(ro)
+    ro.expanded = false if ro.expanded
+  end
+
+  def toggle_view_panel
+    self.current_panel_type =
+      case current_panel_type
+      when :tree
+        :lens
+      when :lens
+        :tree
+      end
+  end
+
+  def toggle_current_subject_type
+    self.current_subject_type =
+      case current_subject_type
+      when :value
+        :key
+      when :key
+        :value
+      end
+  end
+
+  def scroll_lens_type
+    self.current_lens += 1
+  end
+
+  def move_cursor_to(new_ro)
+    current_ro.has_cursor = false
+    new_ro.has_cursor = true
+    self.current_ro = new_ro
+  end
+
+  def navigate_up
+    next_up = current_ro.next_visible_ro_up
+    move_cursor_to(next_up) if next_up
+  end
+
+  def navigate_down
+    next_down = current_ro.next_visible_ro_down
+    move_cursor_to(next_down) if next_down
+  end
+
+  def boot_screen
+    screen_height, screen_width = $stdout.winsize
+    stars = (1..(screen_height * screen_width))
+            .to_a
+            .map { rand(100).zero? ? '.' : ' ' }
+    stars.each_slice(screen_width).map { |set| set.join('') }.join("\n")
+  end
+end