potty 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 025204ee0b4853237fc9ea15a4714261d6583e827077cc38fd34dbe635f186c6
-  data.tar.gz: ffc7a323d75589bbf073a70b136aec36f65a1a4ce4126d9c7a7986cabe484672
+  metadata.gz: 63152b715adc9214ddd12d6cf681554fbdc1351508ce17668f1c05b129778657
+  data.tar.gz: b2c1a6810bcb9549480761ac5384f8d1bf6eedf4074d71f2fd1a7883113f10d7
 SHA512:
-  metadata.gz: b0534b15973e60c6fde7848fd7ff1d93db9e47f7f2b8bb3fa3b6e24cedefa36dfffb1c6c22b6d9fdc8e43a174a50be526c5b82cbb20793dfa9d772ff65d3bbda
-  data.tar.gz: 1863a5f74f255b034dcb1f86dd23067c3823be15967f359249cc1d4f6c3b0ab54a959c7b18221c3a82c45f4cf573cf483ef63425cdef0196f734d0a2ce24da59
+  metadata.gz: c522818e767c48a23bac8d93619ea9f53db0f6e1987b8daa74059e1c53f0db848ee368f3c7701e6cc7236de6f5786f0fc7066a074e8dbdb66101c4511d6a914f
+  data.tar.gz: eb4a47e03d9a00ab977c3485853cf5d901fa2d4466c20e7be936811b63f59cbe2e42d66292c750f538fb24d9c5090ee7f6ce18a871cb4b8ec47ec9c2604db12b

data/CHANGELOG.md

@@ -4,6 +4,47 @@ All notable changes to potty are documented here. The format is loosely based
 on [Keep a Changelog](https://keepachangelog.com/), and the project follows
 [Semantic Versioning](https://semver.org/).
 
+## [0.0.2] - 2026-05-30
+
+### Added
+- **Inline listen mode** — `InlineSurface` can now read input. With
+  `Application.new(mode: :inline, listen: true)` it puts stdin in raw mode,
+  decodes keys via `Potty::Input::Decoder`, and feeds the same event loop —
+  so existing widgets are interactive *inline*, no full-screen takeover.
+  Terminal restores to cooked on exit; Ctrl-C still quits.
+- `Potty::Mouth` — batteries-included inline helpers built on
+  `Application.new(mode: :inline)` (a convenience layer, not an Application
+  facade):
+  - `Mouth.say(text, color)` — styled line with no app; drops colour when
+    output isn't a TTY so logs stay clean. (+ `Mouth.bleep`.)
+  - `Mouth.ask(prompt)` → String, `Mouth.confirm(prompt)` → bool,
+    `Mouth.choose(prompt, options)` → value — inline prompts (gum/fzf-style)
+    composed from the existing widgets, returning a value.
+- `Potty::Input::Decoder` — raw byte stream → `Keys` codes (CSI/SS3 escape
+  sequences + bare-ESC timeout); the core that makes listen mode emit the
+  same codes curses does, so widgets work unchanged in either mode.
+- `Potty::Ansi` — the symbolic-colour → SGR mapping, shared by `InlineSurface`
+  and `Mouth` (single source of truth).
+- `RadioGroup#cursor_value` (the highlighted option, for one-shot choosers).
+- `Application.new(out:, listen:, input:)` — redirect inline output, enable
+  listening, and inject the input IO (testability/piping).
+- Second demo: `potty_inline_demo` (TTY/inline) alongside `potty_demo` (curses).
+
+### Changed
+- **`Theme` is now pure data** (no curses) — `style`/`[]`/`attr` all return a
+  `Style` (symbolic colours + attributes), resolved per surface. This is what
+  lets every widget render in *either* mode (curses pair or ANSI SGR) with no
+  per-widget special-casing. Code that drew straight to a curses window with
+  `theme[:x]` must now draw via the surface (it resolves the Style).
+- `View#spacing` is overridable; `Enter` advances focus like `Tab` when the
+  focused widget doesn't consume it (form flow).
+- Internal consolidation: `TextInput` and the list `InputItem` now share a
+  `Potty::LineEditor`; dead `Layout.split_horizontal`/`fill` and the unused
+  `WindowManager` sub-window API removed.
+
+### CI
+- GitHub Actions running the suite on Ruby 3.1–3.4.
+
 ## [0.0.1] - 2026-05-30
 
 Initial public release. (Developed privately under the working name `cursed`,

data/README.md

@@ -1,5 +1,8 @@
 # potty
 
+[![CI](https://github.com/TwilightCoders/potty/actions/workflows/ci.yml/badge.svg)](https://github.com/TwilightCoders/potty/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/potty.svg)](https://rubygems.org/gems/potty)
+
 A curses-based terminal UI framework for Ruby. Build full-screen TUIs from a
 tree of composable widgets, with view-stack navigation, a focus model, theming,
 and frame-based animation.
@@ -70,19 +73,23 @@ app = Potty::Application.new
 app.run(HelloView.new(app))
 ```
 
-For a guided tour of the whole widget set, run the bundled demo in a real
-terminal:
+Two bundled demos, one per rendering mode — run either in a real terminal:
 
 ```bash
-bin/potty_demo     # from a checkout
-potty_demo         # when the gem is installed
+bin/potty_demo          # curses: full-screen
+bin/potty_inline_demo   # inline: stays in the terminal flow
 ```
 
-It's a single self-demonstrating dashboard: one composed layout (so it shows
-off the layout system by *being* it) whose form controls reconfigure the demo
-live — the Border radio restyles the very panels you're looking at, the Title
-field renames the header, the checkboxes show/hide the live animation. See
-[`examples/test_view.rb`](examples/test_view.rb) for a smaller example.
+- **`potty_demo`** (curses) — a single self-demonstrating dashboard: one
+  composed layout (it shows off the layout system by *being* it) whose form
+  controls reconfigure the demo live — the Border radio restyles the very
+  panels you're looking at, the Title field renames the header, the checkboxes
+  show/hide the live animation.
+- **`potty_inline_demo`** (inline/TTY) — styled output, a live in-place
+  "deploy" (spinners resolving without a screen takeover), and interactive
+  prompts (`ask`/`confirm`/`choose`) — all in your normal terminal flow.
+
+See [`examples/test_view.rb`](examples/test_view.rb) for a smaller example.
 
 ## Core concepts
 

data/bin/potty_inline_demo

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# potty_inline_demo - the TTY / inline half of potty: rendering and
+# interaction that stay in your terminal's normal flow (no full-screen
+# takeover). Run it in a real terminal:
+#
+#   bin/potty_inline_demo     (from a checkout)
+#   potty_inline_demo         (when the gem is installed)
+#
+# The curses (full-screen) counterpart is `potty_demo`.
+
+lib = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'potty'
+
+module PottyInlineDemo
+  # A short live "deploy": two spinners that resolve, redrawn in place under
+  # the cursor (no screen takeover). Quits itself when finished.
+  class DeployView < Potty::View
+    def build_layout
+      @label  = Potty::Widgets::Label.new(app, text: 'Deploying (inline, in place):', color: :info)
+      @build  = Potty::Widgets::Spinner.new(app, label: 'building assets')
+      @upload = Potty::Widgets::Spinner.new(app, label: 'uploading bundle')
+      @widgets = [@label, @build, @upload]
+    end
+
+    def spacing
+      0 # pack tight so all three lines fit the sized inline region
+    end
+
+    def tick(now)
+      @start ||= now
+      super
+      elapsed = now - @start
+      @build.complete!(:success)  if elapsed > 1.0 && @build.active?
+      @upload.complete!(:success) if elapsed > 2.0 && @upload.active?
+      app.quit if elapsed > 2.6
+    end
+  end
+
+  module_function
+
+  def run
+    Potty::Mouth.say('potty - inline demo (Pretty Objects: TTY)', :info, bold: true)
+    Potty::Mouth.say('Everything below stays in your terminal - no screen takeover.', :dim)
+    puts
+
+    # Passive live region (output only): spinners resolving in place.
+    app = Potty::Application.new(mode: :inline, lines: 3)
+    app.tick_interval = 40
+    app.run(DeployView.new(app))
+    puts
+
+    # Interactive prompts (listen mode): real input, rendered in place.
+    name = Potty::Mouth.ask("What should I call you?", default: 'stranger')
+    Potty::Mouth.say("Hi, #{name}!", :success)
+
+    theme = Potty::Mouth.choose('Pick a theme:', %i[light dark auto])
+    Potty::Mouth.say("Theme: #{theme}", :info)
+
+    if Potty::Mouth.confirm('Curse a little?', default: true)
+      Potty::Mouth.say("#{Potty::Mouth.bleep('damn')} right.", :warning)
+    end
+
+    Potty::Mouth.say('Inline demo done.', :success)
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  begin
+    PottyInlineDemo.run
+  rescue Interrupt
+    warn "\nInterrupted."
+    exit 130
+  end
+end

data/lib/potty/ansi.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Potty
+  # Resolve a Style to ANSI SGR escape codes. Shared by InlineSurface (which
+  # paints a region) and Potty::Mouth (one-off styled lines), so the
+  # symbolic-colour -> SGR mapping lives in exactly one place.
+  module Ansi
+    SGR_FG = {
+      default: 39, black: 30, red: 31, green: 32, yellow: 33,
+      blue: 34, magenta: 35, cyan: 36, white: 37, bright_black: 90
+    }.freeze
+    SGR_BG = {
+      default: 49, black: 40, red: 41, green: 42, yellow: 43,
+      blue: 44, magenta: 45, cyan: 46, white: 47, bright_black: 100
+    }.freeze
+    RESET = "\e[0m"
+
+    module_function
+
+    def sgr(style)
+      return RESET if style.nil?
+
+      codes = []
+      codes << 1 if style.bold?
+      codes << 4 if style.underline?
+      codes << 7 if style.reverse?
+      codes << SGR_FG.fetch(style.fg, 39)
+      codes << SGR_BG.fetch(style.bg, 49)
+      "\e[#{codes.join(';')}m"
+    end
+
+    def reset
+      RESET
+    end
+  end
+end

data/lib/potty/application.rb

@@ -25,12 +25,15 @@ module Potty
     # ~33-50ms gives smooth animation. Required for :inline.
     attr_accessor :tick_interval
 
-    def initialize(mode: :curses, lines: nil, theme: nil)
+    def initialize(mode: :curses, lines: nil, theme: nil, out: $stdout, listen: false, input: $stdin)
       @view_stack = []
       @running = false
       @theme = theme || Theme.new
       @mode = mode
       @lines = lines
+      @out = out
+      @listen = listen
+      @input = input
       # Kept for back-compat: curses-mode consumers that draw straight to
       # window_manager.stdscr or read its dimensions.
       @window_manager = (mode == :curses ? WindowManager.new : nil)
@@ -102,7 +105,8 @@ module Potty
     def build_surface
       case @mode
       when :inline
-        Surfaces::InlineSurface.new(theme: @theme, lines: @lines, tick_interval: @tick_interval || 40)
+        Surfaces::InlineSurface.new(theme: @theme, lines: @lines, tick_interval: @tick_interval || 40,
+                                    out: @out, listen: @listen, input: @input)
       else
         Surfaces::CursesSurface.new(@window_manager, @theme, tick_interval: @tick_interval)
       end

data/lib/potty/input/decoder.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative '../keys'
+
+module Potty
+  module Input
+    # Turns a raw terminal byte stream into Keys codes. In curses mode the
+    # library gets this for free via keypad(true); inline "listen" mode reads
+    # raw bytes, so we decode here — and crucially we emit the *same* integer
+    # codes curses would, so every widget's handle_key works unchanged in
+    # either mode.
+    #
+    # Printable/control bytes pass straight through as codes. Escape sequences
+    # (ESC [ A, ESC O P, ESC [ 3 ~, …) map to Keys::UP / DELETE / etc. A lone
+    # ESC is ambiguous — it may begin a sequence — so it's held until either
+    # more bytes complete a sequence, or enough time passes (escape_timeout)
+    # that we resolve it to a bare ESC. Same heuristic curses runs internally
+    # via ESCDELAY; here it's ours.
+    #
+    # Usage (driven by the inline loop each tick):
+    #   keys = decoder.feed(bytes_available, now)   # bytes may be ""
+    #   keys.each { |code| view.handle_key(code) }
+    class Decoder
+      # Escape sequence (the bytes after ESC) -> Keys code.
+      SEQUENCES = {
+        '[A' => Keys::UP,    'OA' => Keys::UP,
+        '[B' => Keys::DOWN,  'OB' => Keys::DOWN,
+        '[C' => Keys::RIGHT, 'OC' => Keys::RIGHT,
+        '[D' => Keys::LEFT,  'OD' => Keys::LEFT,
+        '[H' => Keys::HOME,  'OH' => Keys::HOME,  '[1~' => Keys::HOME,
+        '[F' => Keys::END_,  'OF' => Keys::END_,  '[4~' => Keys::END_,
+        '[3~' => Keys::DELETE,
+        '[Z' => Keys::SHIFT_TAB
+      }.freeze
+
+      # Longest escape body we might still be completing (e.g. "[3~").
+      MAX_SEQ = SEQUENCES.keys.map(&:length).max
+
+      def initialize(escape_timeout: 0.25)
+        @escape_timeout = escape_timeout
+        @buffer = +''
+        @esc_at = nil
+      end
+
+      # Append newly-read bytes (may be empty) and return the key codes that
+      # can be resolved now. `now` is a monotonic-ish time used only for the
+      # bare-ESC timeout; pass Time.now from the loop (and in tests).
+      def feed(bytes, now)
+        @buffer << bytes.to_s
+        codes = []
+        while (code = take(now))
+          codes << code
+        end
+        codes
+      end
+
+      private
+
+      # Pull the next resolvable key from the buffer, or nil if we must wait.
+      def take(now)
+        return nil if @buffer.empty?
+
+        if @buffer.getbyte(0) == Keys::ESC
+          take_escape(now)
+        else
+          @esc_at = nil
+          byte = @buffer.getbyte(0)
+          @buffer.slice!(0)
+          byte
+        end
+      end
+
+      def take_escape(now)
+        body = @buffer[1..] || ''
+
+        # A complete, recognized sequence?
+        if (seq = SEQUENCES.keys.find { |s| body.start_with?(s) })
+          @buffer.slice!(0, 1 + seq.length)
+          @esc_at = nil
+          return SEQUENCES[seq]
+        end
+
+        # Still possibly the beginning of one? Hold and wait for more bytes,
+        # unless we've waited past the escape timeout — then it's a bare ESC.
+        if could_complete?(body)
+          @esc_at ||= now
+          return nil unless timed_out?(now)
+        end
+
+        # Bare ESC (lone, timed out, or ESC followed by an unrelated byte).
+        @buffer.slice!(0)
+        @esc_at = nil
+        Keys::ESC
+      end
+
+      # Could `body` (bytes after ESC) still grow into a known sequence?
+      def could_complete?(body)
+        return true if body.empty? && incomplete_possible?
+        return false if body.length >= MAX_SEQ
+
+        SEQUENCES.keys.any? { |s| s.start_with?(body) && s != body }
+      end
+
+      def incomplete_possible?
+        true # a lone ESC could begin any sequence
+      end
+
+      def timed_out?(now)
+        @esc_at && (now - @esc_at) >= @escape_timeout
+      end
+    end
+  end
+end

data/lib/potty/layout.rb

@@ -20,28 +20,5 @@ module Potty
         rect
       end
     end
-
-    # Horizontal split
-    def self.split_horizontal(container_rect, ratio: 0.5)
-      split_x = container_rect.x + (container_rect.width * ratio).to_i
-      left = Rect.new(
-        container_rect.x,
-        container_rect.y,
-        split_x - container_rect.x,
-        container_rect.height
-      )
-      right = Rect.new(
-        split_x,
-        container_rect.y,
-        container_rect.width - (split_x - container_rect.x),
-        container_rect.height
-      )
-      [left, right]
-    end
-
-    # Fill available space
-    def self.fill(container_rect)
-      container_rect.dup
-    end
   end
 end

data/lib/potty/line_editor.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Potty
+  # The single-line text-editing model shared by the TextInput widget and the
+  # list InputItem — a string plus a caret, with insert / delete / navigation.
+  # Pure logic, no rendering or curses: widgets own how it's drawn and when to
+  # fire change events (the mutators return whether the text changed).
+  class LineEditor
+    attr_reader :text, :cursor
+    attr_accessor :max_length
+
+    def initialize(text = '', max_length: nil)
+      @text = text.to_s.dup
+      @max_length = max_length
+      @cursor = @text.length
+    end
+
+    def text=(value)
+      @text = value.to_s.dup
+      @cursor = [@cursor, @text.length].min
+    end
+
+    # Mutators return true when the text changed (so callers know to notify).
+    def insert(str)
+      return false if @max_length && @text.length >= @max_length
+
+      @text.insert(@cursor, str)
+      @cursor += str.length
+      true
+    end
+
+    def backspace
+      return false if @cursor.zero?
+
+      @text.slice!(@cursor - 1)
+      @cursor -= 1
+      true
+    end
+
+    def delete_forward
+      return false if @cursor >= @text.length
+
+      @text.slice!(@cursor)
+      true
+    end
+
+    # Caret navigation (no text change).
+    def left  = (@cursor = [@cursor - 1, 0].max)
+    def right = (@cursor = [@cursor + 1, @text.length].min)
+    def home  = (@cursor = 0)
+    def to_end = (@cursor = @text.length)
+  end
+end

data/lib/potty/mouth.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require_relative 'style'
+require_relative 'theme'
+require_relative 'ansi'
+require_relative 'application'
+require_relative 'view'
+require_relative 'widgets/label'
+require_relative 'widgets/text_input'
+require_relative 'widgets/radio_group'
+
+module Potty
+  # potty's batteries-included inline helpers — quick terminal I/O that hides
+  # the Application/View machinery and hands you back a value:
+  #
+  #   Potty::Mouth.say("deploying…", :info)        # styled output, no app
+  #   name = Potty::Mouth.ask("Your name?")        # (with listen mode) -> String
+  #   ok   = Potty::Mouth.confirm("Proceed?")      # -> true/false
+  #
+  # This is a convenience layer *built on* Application.new(mode: :inline), not
+  # a second way to run views — to run your own inline View, use the inline
+  # Application directly. Colour is dropped when output isn't a TTY, so logs
+  # stay clean.
+  module Mouth
+    module_function
+
+    # Print one styled line. `color` is a Theme palette name (:info, :success,
+    # :error, :warning, :dim, …); unknown names fall back to :normal.
+    def say(text, color = :normal, bold: false, out: $stdout)
+      if tty?(out)
+        out.puts("#{Ansi.sgr(style_for(color, bold))}#{text}#{Ansi::RESET}")
+      else
+        out.puts(text)
+      end
+      nil
+    end
+
+    # Censor a word — a potty mouth ought to know how. Keeps the first and
+    # last letter, stars the middle. (Purely for the laugh.)
+    def bleep(word, char: '*')
+      return word if word.length <= 2
+
+      "#{word[0]}#{char * (word.length - 2)}#{word[-1]}"
+    end
+
+    # Ask for a line of text inline; returns the entered String, or nil if the
+    # user cancels with ESC. Needs a TTY — off a TTY (pipe/cron) it can't
+    # prompt, so it returns `default` rather than hanging.
+    def ask(prompt, default: '', theme: nil, out: $stdout, input: $stdin)
+      return default unless tty?(input)
+
+      app = inline_app(lines: 2, theme: theme, out: out, input: input)
+      app.run(view = Prompt::Ask.new(app, prompt: prompt, default: default))
+      view.result
+    end
+
+    # Yes/no inline; returns true/false (ESC or Enter use `default`). Off a
+    # TTY, returns `default`.
+    def confirm(prompt, default: false, theme: nil, out: $stdout, input: $stdin)
+      return default unless tty?(input)
+
+      app = inline_app(lines: 1, theme: theme, out: out, input: input)
+      app.run(view = Prompt::Confirm.new(app, prompt: prompt, default: default))
+      view.result
+    end
+
+    # Pick one of `options` (values or {value:, label:}) inline; returns the
+    # chosen value, or nil on ESC. Arrows move, Enter picks. Off a TTY,
+    # returns `default` (the first option's value unless given).
+    def choose(prompt, options, default: :__first__, theme: nil, out: $stdout, input: $stdin)
+      unless tty?(input)
+        return default == :__first__ ? value_of(options.first) : default
+      end
+
+      app = inline_app(lines: options.size + 1, theme: theme, out: out, input: input)
+      app.run(view = Prompt::Choose.new(app, prompt: prompt, options: options))
+      view.result
+    end
+
+    # Build (not run) a configured inline, listening Application for a prompt.
+    def inline_app(lines:, theme:, out:, input:)
+      app = Application.new(mode: :inline, listen: true, lines: lines, theme: theme, out: out, input: input)
+      app.tick_interval = 50
+      app
+    end
+
+    def style_for(color, bold)
+      c = Theme::PALETTE[color] || Theme::PALETTE[:normal]
+      Style.new(fg: c[:fg], bg: c[:bg], bold: bold)
+    end
+
+    def tty?(io)
+      io.respond_to?(:tty?) && io.tty?
+    end
+
+    def value_of(option)
+      option.is_a?(Hash) ? option[:value] : option
+    end
+
+    # Small inline prompt views backing ask/confirm/choose. Each captures its
+    # outcome in #result and quits the app when answered.
+    module Prompt
+      # Prompts pack tight (no inter-widget spacing) so the view height matches
+      # the inline region exactly — otherwise the default spacing pushes fields
+      # past the sized region and they render clipped/invisible.
+      class Base < Potty::View
+        def spacing
+          0
+        end
+      end
+
+      class Ask < Base
+        attr_reader :result
+
+        def initialize(app, prompt:, default: '')
+          @prompt = prompt
+          @default = default
+          @result = nil
+          super(app)
+        end
+
+        def build_layout
+          @field = Potty::Widgets::TextInput.new(app, text: @default)
+          @widgets = [Potty::Widgets::Label.new(app, text: @prompt, color: :info), @field]
+          @field.focus
+        end
+
+        def handle_key(ch)
+          # Intercept Enter before super (which would otherwise advance focus)
+          # — a single-field prompt submits on Enter.
+          if Potty::Keys.enter?(ch)
+            @result = @field.text
+            app.quit
+            return true
+          end
+          super
+        end
+
+        def handle_escape
+          @result = nil
+          app.quit
+          true
+        end
+      end
+
+      class Confirm < Base
+        attr_reader :result
+
+        def initialize(app, prompt:, default: false)
+          @prompt = prompt
+          @default = default
+          @result = nil
+          super(app)
+        end
+
+        def build_layout
+          hint = @default ? '[Y/n]' : '[y/N]'
+          @widgets = [Potty::Widgets::Label.new(app, text: "#{@prompt} #{hint}", color: :info)]
+        end
+
+        def handle_key(ch)
+          case ch
+          when 'y'.ord, 'Y'.ord then finish(true)
+          when 'n'.ord, 'N'.ord then finish(false)
+          when *Potty::Keys::ENTERS then finish(@default)
+          else false
+          end
+        end
+
+        def handle_escape
+          finish(@default)
+        end
+
+        private
+
+        def finish(value)
+          @result = value
+          app.quit
+          true
+        end
+      end
+
+      class Choose < Base
+        attr_reader :result
+
+        def initialize(app, prompt:, options:)
+          @prompt = prompt
+          @options = options
+          @result = nil
+          super(app)
+        end
+
+        def build_layout
+          opts = @options.map { |o| o.is_a?(Hash) ? o : { value: o, label: o.to_s } }
+          @radio = Potty::Widgets::RadioGroup.new(app, options: opts)
+          @widgets = [Potty::Widgets::Label.new(app, text: @prompt, color: :info), @radio]
+          @radio.focus
+        end
+
+        def handle_key(ch)
+          if Potty::Keys.enter?(ch)
+            @result = @radio.cursor_value
+            app.quit
+            return true
+          end
+          super # arrows move the radio cursor
+        end
+
+        def handle_escape
+          @result = nil
+          app.quit
+          true
+        end
+      end
+    end
+  end
+end