rails-activetree 0.1.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bd1bf8f791ab4c7267e442ce325f4714694ea63089d089cc6aaa5094148d0acc
+  data.tar.gz: 03a9e3643d4f63f8788ad555d6b5ba38f28d9dea36517bd727c4b245fcccde01
+SHA512:
+  metadata.gz: d8a8eca4520e9029783567d54aa3977f339b8ae78c81937d479b126d5abe926074d27c4aeee1773edfaded161f775884aa19019033c57746f0afcd3c14a2a6ce
+  data.tar.gz: b9d90553114dbc31b29cfefac6abae86749bb7a9f4d3ca38e6d9c8514018499c90e5815f56466f217afe962ccf65380b95dbbbb2ddcbf2d5bf60ff8b6d3e1642

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,61 @@
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  SuggestExtensions: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+    - "*.gemspec"
+
+Metrics/ClassLength:
+  Exclude:
+    - "lib/activetree/renderer.rb"
+    - "lib/activetree/tree_state.rb"
+    - "lib/activetree/cli.rb"
+
+Metrics/MethodLength:
+  Exclude:
+    - "lib/activetree/renderer.rb"
+    - "lib/activetree/cli.rb"
+    - "lib/activetree/tree_state.rb"
+    - "lib/activetree/dialog_input_handler.rb"
+    - "lib/activetree/dialog_renderer.rb"
+    - "lib/activetree/root_query.rb"
+
+Metrics/AbcSize:
+  Exclude:
+    - "lib/activetree/renderer.rb"
+    - "lib/activetree/tree_state.rb"
+    - "lib/activetree/cli.rb"
+    - "lib/activetree/dialog_renderer.rb"
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - "lib/activetree/renderer.rb"
+    - "lib/activetree/tree_state.rb"
+    - "lib/activetree/cli.rb"
+    - "lib/activetree/dialog_input_handler.rb"
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    - "lib/activetree/renderer.rb"
+    - "lib/activetree/tree_state.rb"
+
+Metrics/ParameterLists:
+  Exclude:
+    - "lib/activetree/renderer.rb"
+    - "lib/activetree/association_group_node.rb"
+
+Naming/AccessorMethodName:
+  Exclude:
+    - "lib/activetree/tree_state.rb"

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0.pre1] - 2026-03-06
+
+- Initial development release

data/CLAUDE.md

@@ -0,0 +1,50 @@
+# ActiveTree
+
+A tree-based admin interface for ActiveRecord, built as a Ruby gem. Currently a split-pane TUI rendered with `tty-box`, `tty-screen`, and `pastel`; planned evolution into a mountable Rails Engine.
+
+## Naming
+
+- **Module:** `ActiveTree` (capital T) — matches Rails conventions (`ActiveRecord`, `ActiveSupport`)
+- **Gem name / file paths:** `activetree` (lowercase, no separator) — per RubyGems convention
+- Never use `Activetree` (that's what `bundle gem` scaffolds, and we renamed it)
+
+## Architecture
+
+**Runtime architecture:** CLI → TreeState → Renderer loop. TreeState owns a tree of nodes (`TreeNode` base → `RecordNode`, `AssociationGroupNode`, `LoadMoreNode`, `QueryResultsNode`/`ListNode`). The `ActiveTree::Model` concern provides per-model DSL (`tree_fields`, `tree_children`, `tree_label`). InputHandler reads raw keypresses; Renderer composes a full-screen frame each tick using two side-by-side `TTY::Box.frame` calls (tree pane + detail pane) with absolute positioning, plus a cursor-positioned footer. Screen is cleared (`\e[H\e[J`) before each frame to prevent stale content. The two panes share a focus model toggled by Tab — the focused pane gets a magenta border while the unfocused pane dims to bright-black. Each pane scrolls independently (`scroll_offset` for tree, `detail_scroll_offset` for detail) and renders a `░`/`█` scrollbar when content overflows.
+
+**Query mode:** Pressing `q` (or launching with no args) opens a dialog overlay. `Dialog` is the base class (manages fields, focus, submission); `QueryDialog` specializes it with model/query fields. `DialogField` handles text input with cursor navigation; `DialogInputHandler` maps keystrokes to dialog actions; `DialogRenderer` draws the centered overlay box. `RootQuery` validates input, executes the query (numeric ID via `find` or DSL expression via `instance_eval` on the model relation), and determines cardinality — single results become a `RecordNode` root, multiple results become a `QueryResultsNode` (extends `ListNode` with pagination).
+
+**Engine upgrade path:** The Railtie is designed to swap its superclass to `Rails::Engine`, add `isolate_namespace`, and gain `config/routes.rb` + `app/` directories. Existing initializer and rake blocks transfer unchanged.
+
+## Code style
+
+- Ruby >= 3.1, double-quoted strings everywhere
+- RuboCop with `NewCops: enable`, `Style/Documentation` disabled, `Metrics/*` cops excluded for `renderer.rb` and `tree_state.rb` (most cops), `cli.rb` (`MethodLength` only) — intentional, these files are inherently complex TUI code
+- `frozen_string_literal: true` in every `.rb` file
+- RSpec for tests (`bundle exec rspec`), RuboCop for linting (`bundle exec rubocop`)
+
+## Key conventions
+
+- `spec.files` uses `git ls-files` — new files must be git-tracked before `gem build` will include them
+- Model discovery uses `config.after_initialize` (not `initializer`) because models aren't fully loaded during Rails initialization in development
+- `Gemfile.lock` is committed (Bundler recommends tracking it for gems and apps alike)
+- All runtime dependencies are explicitly declared in the gemspec — unused tty-* gems (`tty-table`, `tty-tree`, `tty-prompt`, `tty-cursor`) have been removed, and `pastel` + `strings-ansi` are now direct dependencies
+
+## Dependencies
+
+Runtime: `activerecord >= 7.0`, `railties >= 7.0`, `tty-box`, `tty-screen`, `pastel`, `strings-ansi`
+Dev: `rspec`, `rubocop`, `rake`, `irb`
+
+## Commands
+
+```bash
+bin/setup              # Install dependencies
+bundle exec rspec      # Run tests
+bundle exec rubocop    # Lint
+ruby -Ilib exe/activetree  # Run TUI standalone (outside bundler)
+bundle exec activetree     # Run TUI via bundler
+```
+
+## Repository
+
+GitHub org is `babylist` — https://github.com/babylist/activetree

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Baby List, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,259 @@
+# ActiveTree
+
+An interactive tree-based admin interface for ActiveRecord. ActiveTree renders a persistent split-pane TUI (terminal UI) for browsing records, their associations, and field values.
+
+## Installation
+
+Add to your application's Gemfile:
+
+```ruby
+gem "activetree"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Usage
+
+### Launching the TUI
+
+ActiveTree browses a single root record and its association tree. Pass a model name and a query:
+
+```bash
+# Within a Rails app — browse a specific record by ID
+bin/rails "activetree:tree[User,42]"
+bundle exec activetree User 42
+
+# Query with ActiveRecord DSL expressions
+bundle exec activetree User "where(active: true)"
+bundle exec activetree Order "where(status: 'pending').limit(10)"
+
+# No arguments — opens an interactive query dialog
+bundle exec activetree
+```
+
+The TUI opens a full-screen split-pane interface:
+- **Left pane** — navigable tree with expand/collapse for associations
+- **Right pane** — field/value detail view for the selected record
+
+Use `Tab` to switch focus between panes. The focused pane is highlighted with a magenta border. Both panes scroll independently and show a scrollbar when content overflows.
+
+Tree nodes use disclosure icons to communicate expand/collapse state and whether children have been loaded from the database:
+
+| Icon | Meaning |
+|------|---------|
+| ▶ | Collapsed, children already loaded |
+| ▼ | Expanded, children already loaded |
+| ▷ | Collapsed, children not yet loaded |
+| ▽ | Expanded, children not yet loaded |
+
+### Key Bindings
+
+| Key | Action |
+|-----|--------|
+| `j` / `Down` | Move cursor down (tree) or scroll down (detail) |
+| `k` / `Up` | Move cursor up (tree) or scroll up (detail) |
+| `l` / `Right` | **Tree:** expand collapsed node → descend into expanded node → select leaf & switch to detail. **Detail:** no-op |
+| `h` / `Left` | **Tree:** collapse expanded node → jump to parent. **Detail:** switch focus back to tree |
+| `Tab` | Switch focus between tree and detail panes |
+| `Space` | Expand / collapse node |
+| `Enter` | Select record (show details in right pane) |
+| `f` | Toggle field mode (configured fields vs. all columns) |
+| `r` | Make selected record the new root |
+| `q` | Open query dialog |
+| `Ctrl-C` | Quit |
+
+### Query Mode
+
+Press `q` at any time (or launch with no arguments) to open the query dialog. The dialog presents two fields:
+
+- **Model class** — the ActiveRecord model name (e.g. `User`, `Order`)
+- **Query** — a numeric ID or an ActiveRecord DSL expression (e.g. `42`, `where(active: true)`, `where(status: 'pending').order(:created_at)`)
+
+Use `Tab` to move between fields, `Enter` to submit, and `Esc` to cancel and return to the current tree.
+
+The results of the query become the root of the tree. If multiple results are returned, they are paginated according to the `default_limit` configuration.
+
+If the model isn't found or the query returns no results, an error message appears in the dialog.
+
+### Field Mode
+
+By default the detail pane shows only the fields declared via `tree_fields` (or `:id` if none are configured). Press `f` to toggle **field mode** — this switches the detail pane to display every column in the model's database schema. Press `f` again to return to the configured view.
+
+The current mode is shown at the top of the detail pane ("Field mode: configured" or "Field mode: all columns"). Field mode is tracked per model class, so toggling on a `User` record won't affect how `Order` records are displayed.
+
+Boolean fields are rendered with visual indicators: `true` displays as a green ✓ and `false` as a red ✗.
+
+### Configuring Models
+
+Include `ActiveTree::Model` in your AR models to control what appears in the TUI:
+
+```ruby
+class User < ApplicationRecord
+  include ActiveTree::Model
+
+  tree_fields :id, :email, :name, :created_at
+  tree_children :orders, :profile
+  tree_label { |record| "#{record.name} (#{record.email})" }
+end
+```
+
+Singular forms accept keyword options:
+
+```ruby
+class Order < ApplicationRecord
+  include ActiveTree::Model
+
+  tree_field :id
+  tree_field :status, label: "Order Status"
+  tree_child :line_items, label: "Items"
+  tree_child :shipments
+end
+```
+
+The plural forms also accept inline option hashes to customize individual entries:
+
+```ruby
+class User < ApplicationRecord
+  include ActiveTree::Model
+
+  tree_fields :id, :email, { name: { label: "Full Name" } }, :created_at
+  tree_children :orders, { shipments: { label: "User Shipments" } }
+end
+```
+
+### Scoping Child Relations
+
+An ActiveRecord scope can be passed for children to filter which records appear in the tree. The scope proc is merged onto the association relation via `ActiveRecord::Relation#merge`, so named scopes and query methods work naturally:
+
+```ruby
+class User < ApplicationRecord
+  include ActiveTree::Model
+
+  tree_child :comments, -> { approved }, label: "Approved Comments"
+  tree_child :orders, -> { where(status: "active") }
+end
+```
+
+The `tree_children` hash form supports `scope:` as well:
+
+```ruby
+class User < ApplicationRecord
+  include ActiveTree::Model
+
+  tree_children :orders, { comments: { scope: -> { approved }, label: "Approved" } }
+end
+```
+
+Scopes work for both collection (`has_many`) and singular (`has_one`, `belongs_to`) associations. The scope is merged with the existing association relation — it never replaces it.
+
+| Method | Default | Description |
+|-----------|---------|-------------|
+| `tree_fields` | `:id` only | Fields shown in the detail pane (batch) |
+| `tree_field` | — | Add a single field with keyword options (`label:`) |
+| `tree_children` | None | Associations expandable as tree children (batch) |
+| `tree_child` | — | Add a single child with options (`label:`, positional scope proc) |
+| `tree_label` | `-> (record) { "#{record.class.name} ##{record.id}" }` | Custom label block for tree nodes and detail pane |
+
+Models **without** the mixin still appear in the tree if referenced as children of another model, using the defaults above.
+
+### Centralized Configuration via DSL
+
+ActiveTree can also be configured centrally with a DSL (e.g. in an initializer). This is especially useful for third-party models or keeping tree config separate from your models:
+
+```ruby
+# config/initializers/activetree.rb
+ActiveTree.configure do
+  max_depth 5
+  default_limit 50
+
+  model "User" do
+    fields :id, :email, :name, :created_at
+    children :orders, :profile
+    label { |record| "#{record.name} (#{record.email})" }
+  end
+
+  model "Order" do
+    field :id
+    field :status, label: "Order Status"
+    child :line_items, label: "Items"
+    child :shipments
+  end
+end
+```
+
+Model names are passed as strings because classes may not be loaded when the initializer runs. The DSL methods mirror the `ActiveTree::Model` concern without the `tree_` prefix:
+
+| DSL Method | Equivalent Concern Method | Description |
+|-----------|--------------------------|-------------|
+| `field :name, label: "..."` | `tree_field` | Add a single field |
+| `fields :id, :email, ...` | `tree_fields` | Add multiple fields |
+| `child :orders, scope, label: "..."` | `tree_child` | Add a single child (optional scope proc + label) |
+| `children :orders, :shipments` | `tree_children` | Add multiple children |
+| `label { \|r\| ... }` | `tree_label` | Custom label block |
+
+#### Merging with the Model Concern
+
+Both configuration styles write to the same underlying config. If a model is configured in an initializer _and_ includes `ActiveTree::Model`, the results merge — fields and children accumulate, and last-write-wins for any given name:
+
+### Global Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `max_depth` | `3` | Maximum nesting depth for associations NOT YET IMPLEMENTED |
+| `default_limit` | `25` | Max records loaded per has_many expansion (paginated) |
+| `global_scope` | `nil` | A proc merged into every relation ActiveTree queries (see below) |
+
+#### Global Scope
+
+`global_scope` applies a scope to **every** query ActiveTree makes — the root record lookup and all association loads (both collection and singular). This is useful for multi-tenancy, soft-delete filtering, or any cross-cutting constraint.
+
+The proc is merged onto each relation via `ActiveRecord::Relation#merge`, so named scopes and query methods work naturally:
+
+```ruby
+# DSL style
+ActiveTree.configure do
+  global_scope { where(organization_id: Current.organization_id) }
+end
+
+# Direct assignment
+ActiveTree.config.global_scope = -> { where(deleted_at: nil) }
+```
+
+When a child association also has its own scope, both are applied — global scope first, then the per-child scope:
+
+```ruby
+ActiveTree.configure do
+  global_scope { where(organization_id: Current.organization_id) }
+
+  model "User" do
+    # The final relation for orders will have both the org filter AND the status filter
+    child :orders, -> { where(status: "active") }, label: "Active Orders"
+  end
+end
+```
+
+### Pagination
+
+Large `has_many` associations are loaded in pages of `default_limit` records. When more records exist, a `[load more...]` node appears at the bottom of the group. Activate it with `Space` to load the next page.
+
+Once loaded, association groups show a record count in their label — e.g. `orders [3]` when all records are loaded, or `orders [25+]` when more pages remain. Singular associations (`has_one`, `belongs_to`) and unloaded groups show just the association name.
+
+## Development
+
+```bash
+bin/setup            # Install dependencies
+bundle exec rspec    # Run tests
+bundle exec rubocop  # Lint
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/babylist/activetree.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/activetree

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Boot the host Rails application, then launch the ActiveTree TUI.
+# Must be run from the root of a Rails app:
+#   bundle exec activetree User 42
+
+env_file = File.expand_path("config/environment.rb", Dir.pwd)
+
+unless File.exist?(env_file)
+  warn "Error: could not find config/environment.rb in #{Dir.pwd}"
+  warn ""
+  warn "activetree must be run from the root of a Rails application."
+  exit 1
+end
+
+begin
+  puts "Loading Rails environment..."
+  require env_file
+rescue StandardError => e
+  warn "Error: failed to load Rails environment"
+  warn "  #{e.class}: #{e.message}"
+  exit 1
+end
+
+require "activetree"
+require "activetree/cli"
+
+ActiveTree::CLI.start(ARGV)

data/lib/activetree/association_group_node.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveTree
+  class AssociationGroupNode < ListNode
+    attr_reader :record, :association_name, :reflection
+
+    def initialize(record:, association_name:, reflection:, tree_state: nil, depth: 0, parent: nil)
+      super(relation: nil, tree_state: tree_state, depth: depth, parent: parent)
+      @record = record
+      @association_name = association_name
+      @reflection = reflection
+    end
+
+    def label
+      if singular?
+        association_configuration.label
+      else
+        "#{association_configuration.label}#{count_label}"
+      end
+    end
+
+    def load_children!
+      if singular?
+        @children = []
+        @loaded = true
+        load_singular_association
+      else
+        super
+      end
+    end
+
+    def base_relation
+      apply_scope(record.public_send(association_name))
+    end
+
+    private
+
+    def singular?
+      %i[has_one belongs_to].include?(reflection.macro)
+    end
+
+    def load_singular_association
+      associated = if association_configuration&.scope || ActiveTree.config.global_scope
+                     apply_scope(record.association(association_name).scope).first
+                   else
+                     record.public_send(association_name)
+                   end
+      return unless associated
+
+      @children << build_record_node(associated)
+    end
+
+    def apply_scope(relation)
+      relation = relation.merge(ActiveTree.config.global_scope) if ActiveTree.config.global_scope
+      return relation unless association_configuration&.scope
+
+      relation.merge(association_configuration.scope)
+    end
+
+    def association_configuration
+      @association_configuration ||= ActiveTree.config.model_configuration(record.class).children[association_name]
+    end
+  end
+end

data/lib/activetree/char_reader.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveTree
+  module CharReader
+    private
+
+    def read_char
+      @input.raw(min: 1) do |io|
+        char = io.getc
+        return nil unless char
+        return read_escape_sequence(char, io) if char == "\e"
+
+        char
+      end
+    end
+
+    def read_escape_sequence(char, io)
+      second = safe_read(io)
+      third = safe_read(io)
+      return "#{char}#{second}#{third}" if second
+
+      char
+    end
+
+    def safe_read(io)
+      io.read_nonblock(1)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/activetree/cli.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module ActiveTree
+  class CLI
+    DISPATCH = {
+      toggle_focus: :toggle_focus,
+      navigate_right: :navigate_right,
+      navigate_left: :navigate_left,
+      move_up: :cursor_up,
+      move_down: :cursor_down,
+      toggle_expand: :toggle_expand,
+      select: :select_current,
+      make_root: :make_selected_record_root,
+      toggle_field_mode: :toggle_field_mode
+    }.freeze
+
+    def self.start(argv = [])
+      puts Pastel.new.magenta.bold("Starting ActiveTree v#{ActiveTree::VERSION}...")
+      new(argv).run
+    end
+
+    def initialize(argv = [])
+      @argv = argv
+    end
+
+    def run
+      state = TreeState.new
+      renderer = Renderer.new(state)
+      input = InputHandler.new
+      dialog_input = DialogInputHandler.new
+
+      # Try to resolve root from CLI args
+      apply_query_result(RootQuery.new(@argv[0], @argv[1]), state) if @argv.size >= 2
+
+      begin
+        enter_alternate_screen
+        if state.empty?
+          # Fall through to query dialog if no root node was resolved from args
+          open_query_dialog(state, renderer, dialog_input)
+          return unless state.root
+        end
+        main_loop(state, renderer, input, dialog_input)
+      ensure
+        exit_alternate_screen
+      end
+    end
+
+    private
+
+    def main_loop(state, renderer, input, dialog_input)
+      loop do
+        $stdout.print renderer.render
+        $stdout.flush
+
+        action = input.read_action
+        break if action == :quit
+
+        if action == :open_query_dialog
+          open_query_dialog(state, renderer, dialog_input)
+        else
+          dispatch(action, state)
+        end
+      end
+    end
+
+    def dispatch(action, state)
+      state.public_send(DISPATCH[action]) if DISPATCH[action]
+    end
+
+    def open_query_dialog(state, renderer, dialog_input)
+      dialog = QueryDialog.new
+      loop do
+        dialog_loop(dialog, renderer, dialog_input)
+        return if dialog.cancelled?
+
+        begin
+          apply_query_result(dialog.root_query, state)
+          return
+        rescue ArgumentError => e
+          dialog.error_message = e.message
+          reset_dialog_for_retry(dialog)
+        end
+      end
+    end
+
+    def dialog_loop(dialog, renderer, dialog_input)
+      loop do
+        $stdout.print renderer.render(dialog: dialog)
+        $stdout.flush
+
+        action = dialog_input.read_action
+        next unless action
+
+        case action
+        when :cancel
+          dialog.cancel!
+        when :submit
+          dialog.error_message = nil
+          dialog.submit!
+        when :next_field
+          dialog.next_field
+        when :backspace
+          dialog.backspace
+        when :cursor_left
+          dialog.cursor_left
+        when :cursor_right
+          dialog.cursor_right
+        when Array
+          dialog.insert_char(action[1]) if action[0] == :insert
+        end
+
+        break if dialog.resolved?
+      end
+    end
+
+    def apply_query_result(root_query, state)
+      state.set_root_node(root_query.as_tree_node)
+    end
+
+    def reset_dialog_for_retry(dialog)
+      # Reset submitted/cancelled state so dialog can be re-shown
+      dialog.instance_variable_set(:@submitted, false)
+      dialog.instance_variable_set(:@cancelled, false)
+    end
+
+    def enter_alternate_screen
+      $stdout.print "\e[?1049h" # alternate screen buffer
+      $stdout.print "\e[?25l"   # hide cursor
+      $stdout.flush
+    end
+
+    def exit_alternate_screen
+      $stdout.print "\e[?25h"   # show cursor
+      $stdout.print "\e[?1049l" # restore screen
+      $stdout.flush
+    end
+  end
+end