termcontroller 0.2 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccc884e481a6ba710cb7edbd7edc1b05c20ed49e7f8e81cb0288813472006466
-  data.tar.gz: 6738a465db9c70c9d4d67f1626957de5209fbfbee95557cf9115f8734ff970e9
+  metadata.gz: 04632d599e81a07a9dcda4090091356de0fe257b01342d31719937fd366ccf8f
+  data.tar.gz: 8f411109feb2e00122c80bb7be2978a19e4e1af94f131b66ff6a25476fd1eb99
 SHA512:
-  metadata.gz: d6c8d516c1a855d46833a6ead5e0a28ab2a682b1ce18a8039d301933acb2811d627b65c62b2ecbd0298c8379af98a7502d86a542342fc3c48911f996ab57cfba
-  data.tar.gz: 5f313f8f34231eaa7715c0df26e7abd470ee770af60cdbffb4c4dc7f1f8c08132df5e1f4558b713e26a9be307e5f496c51cfd7817efb12c6ac557dbe87d8e5e5
+  metadata.gz: 8b693ada8e7fab935972a7ad40944eac7da728f5292f81b7217c94839dd0ff06896f909ca13ed0dddc630258020d7fa0ed3c9e4eba36efe430b679a962526b68
+  data.tar.gz: 5b189f18f46ed86916cef9fedbc7b70766c3fe3d4d229c22c4f704c1b37e05610b2ed8396b324218ed865ba0f8a23ddb34b178a2eba1f80aa61728f06ac7a27f

data/Gemfile

@@ -3,5 +3,6 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in termcontroller.gemspec
 gemspec
 
+gem "keyboard_map"
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"

data/README.md

@@ -4,6 +4,12 @@ A very basic Controller (in the MVC sense) for Ruby terminal
 applications. This was pulled out of my text editor,
 [Re](https://github.com/vidarh/re).
 
+**YOU ALMOST CERTAINLY DO NOT YET WANT TO USE THIS FOR YOUR OWN CODE**
+
+I do intend to clean it up and make it usable for others, but it's not
+there yet - if you think it'd be useful for you, feel free to drop me a
+message.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -22,7 +28,36 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+require 'termcontroller'
+
+class Target
+  def initialize
+    # Second argument is a keyboard mapping.
+    @ctrl = Termcontroller::Controller.new(self, {
+      :f1 => :help
+    })
+  end
+
+  def help
+    puts "This is a help text"
+  end
+
+  def run
+    loop do
+      p @ctrl.handle_input
+      print "\r"
+    end
+  end
+
+  def ctrl_c; exit; end
+end
+
+puts "Ctrl+c to quit"
+Target.new.run
+```
+
+
 
 ## Development
 

data/examples/draw.rb

@@ -0,0 +1,57 @@
+
+$: << File.expand_path(File.dirname(__FILE__)+"/../lib/")
+
+require 'termcontroller'
+
+class Target
+
+  def initialize
+    keymap = { :ctrl_c => :quit }
+    @ctrl = Termcontroller::Controller.new(self, keymap)
+    @c = " "
+    @col = 1
+  end
+
+  # If a method exists in the target class passed to Controller.new
+  # that matches the keymap, then it is called directly.
+  #
+  # In this case `quit` is defined in the map above,
+  # while `char` is a default.
+  #
+  # If nothing is mapped, then `handle_input` will return the
+  # symbol instead, as shown for `mouse_down`.
+  #
+  def quit    = (@running = false)
+  def char(c) = (@c = c)
+
+  def call
+    @running = true
+    col = 1
+    while @running
+      cmd = @ctrl.handle_input
+      case cmd.first
+      when :mouse_down
+        print "\e[5;1H#{cmd.inspect}"
+        print "\e[#{cmd[3]};#{cmd[2]}H"
+        if cmd[1] & 3 == 0
+          # left
+          print "\e[4#{col}m#{@c}\e[49m"
+          print "\e[1;1H[DRAWING] "
+        elsif cmd[1] & 3 == 2
+          # right
+          print " "
+          print "\e[1;1H[ERASING] "
+        end
+      end
+    end
+  end
+end
+
+
+print "\e[2J"   # Clear screen
+print "\e[4;1HHold left button and move mouse to draw; Hold right button and move to clear"
+print "\e[3;1HPress any letter to set a character to fill with on draw."
+print "\e[2;1HCtrl+c to quit"
+Target.new.call
+print "\e[2J"   # Clear screen
+print "\e[1;1H" # Move top left

data/lib/termcontroller/controller.rb

@@ -1,6 +1,7 @@
-# coding: utf-8
+# coding utf-8
 
 require 'io/console'
+require 'fcntl'
 
 # # Controller
 #
@@ -11,248 +12,297 @@ require 'io/console'
 # the command directly to a specified target object based on the
 # key bindings.
 #
+# Note that *currently* `#handle_input` will block on retrieving a
+# command with no timeout. This is because Re is the only current
+# client of this class, and *currently* does not have a need for
+# anything async. That *will* change, as Re will eventually start
+# receiving evented updates. Current "hack" to work around this:
+# push things into the `commands` queue. This may well be the ongoing
+# way to do it, and I might consider breaking it out.
+#
 # It works well enough to e.g. allow temporarily pausing the processing
 # and then dispatching "binding.pry" and re-enable the processing when
 # it returns.
 #
-# FIXME: Split it into a separate gem.
+# That said there are lots of hacks in here that needs to be cleaned up
 #
 # FIXME: Should probably treat this as a singleton.
 #
 #
 
+require 'keyboard_map'
+
 module Termcontroller
+  DOUBLE_CLICK_INTERVAL=0.5
+
   class Controller
+    @@controllers = []
 
-    attr_reader :lastcmd,:lastkey,:lastchar
-    attr_accessor :mode
-
-    @@con = IO.console
-  
-    # Pause *any* Controller instance
-    @@pause = false
-    def self.pause!
-      old = @@pause
-      @@pause = true
-      @@con.cooked do
-        yield
-      end
-    ensure
-      @@pause = old
-    end
+    attr_reader :lastcmd, :commands
 
-    def paused?
-      @mode == :pause || @@pause
-    end
+    def initialize(target=nil, keybindings={})
+      @m = Mutex.new
 
-    def initialize(target, keybindings)
       @target = target
+      @target_stack = []
+
       @keybindings = keybindings
       @buf = ""
-      @commands = []
+      @commands = Queue.new
       @mode = :cooked
 
       @kb = KeyboardMap.new
-      @@con = @con = IO.console
+      @con = IO.console
       raise if !@con
-    
-      at_exit do
-        cleanup
-      end
-      
-      trap("CONT") { resume }
 
-    @t = Thread.new { readloop }
-  end
+      at_exit { quit }
+      trap("CONT")  { resume }
+      trap("WINCH") { @commands << :resize }
 
-  def setup
-    STDOUT.print "\e[?2004h" # Enable bracketed paste
-    STDOUT.print "\e[?1000h" # Enable mouse reporting
-    STDOUT.print "\e[?1006h" # Enable extended reporting
-  end
+      setup
 
-  def cleanup
-    STDOUT.print "\e[?2004l" #Disable bracketed paste
-    STDOUT.print "\e[?1000l" #Disable mouse reporting
-  end
+      @t = Thread.new { readloop }
 
-  def readloop
-    loop do
-      if paused?
-        sleep(0.05)
-      elsif @mode == :cooked
-        read_input
-      else
-        fill_buf
+      @@controllers << @t
+
+    end
+
+    def paused?; @mode == :pause; end
+
+    def push_target(t)
+      @target_stack << @target
+      @target = t
+    end
+
+    def pop_target
+      t = @target
+      @target = @target_stack.pop
+      t
+    end
+
+
+    #
+    # Pause processing so you can read directly from stdin
+    # yourself. E.g. to use Readline, or to suspend
+    #
+    def pause
+      @m.synchronize do
+        old = @mode
+        begin
+          @mode = :pause
+          IO.console.cooked!
+          cleanup
+          r = yield
+          r
+        rescue Interrupt
+        ensure
+          @mode = old
+          setup
+        end
       end
     end
-  end
 
-  def pause
-    old = @mode
-    @mode = :pause
-    sleep(0.1)
-    IO.console.cooked!
-    yield
-  rescue Interrupt
-  ensure
-    @mode = old
-  end
+    # FIXME: The first event after the yield
+    # appears to fail to pass the mapping.
+    # Maybe move the mapping to the client thread?
+    def raw
+      keybindings = @keybindings
+      @keybindings = {}
+      push_target(nil)
+      yield
+    rescue Interrupt
+    ensure
+      @keybindings = keybindings
+      pop_target
+    end
 
-  def fill_buf(timeout=0.1)
-    if paused?
-      sleep(0.1)
-      Thread.pass
-      return
+    def handle_input
+      if c = @commands.pop
+        do_command(c)
+      end
+      return Array(c)
     end
-    @con.raw!
-    return if !IO.select([$stdin],nil,nil,0.1)
-    str = $stdin.read_nonblock(4096)
-    str.force_encoding("utf-8")
-    @buf << str
-  rescue IO::WaitReadable
-  end
 
-  def getc(timeout=0.1)
-    if !paused?
-      while @buf.empty?
-        fill_buf
+    # USE WITH CAUTION. This will pause processing,
+    # yield to the provided block if any, and then send
+    # SIGSTOP to the process.
+    #
+    # This is meant to allow for handling ctrl-z to
+    # suspend in processes that need to be able to
+    # reset the terminal to a better state before stopping.
+    #
+    # FIXME: It seems like it does not work as expected.
+    #
+    def suspend
+      pause do
+        yield if block_given?
+        Process.kill("STOP", 0)
       end
-      @buf.slice!(0) if !paused? && @mode == :cooked
-    else
-      sleep(0.1)
-      Thread.pass
-      return nil
     end
-  rescue Interrupt
-  end
 
-  def raw
-    @mode = :raw
-    yield
-  rescue Interrupt
-  ensure
-    @mode = :cooked
-  end
+    def resume
+      @mode = :cooked
+      setup
+      @commands << [:resume]
+    end
 
-  def read_char
-    sleep(0.01) if @buf.empty?
-    @buf.slice!(0)
-  rescue Interrupt
-  end
+    def hide_cursor
+      STDOUT.print "\e[?25l"   # Hide cursor
+    end
 
-  def get_command
-    map = @keybindings
-    loop do
-      c = nil
-      char = getc
-      return nil if !char
+    def show_cursor
+      STDOUT.print "\e[?25h"   # Show cursor
+    end
 
-      c1 = Array(@kb.call(char)).first
-      c = map[c1.to_sym] if c1
+    private # # ########################################################
 
-      if c.nil? && c1.kind_of?(String)
-        return [:insert_char, c1]
-      end
+    def setup
+      STDOUT.print "\e[?2004h" # Enable bracketed paste
+      STDOUT.print "\e[?1000h" # Enable mouse reporting
+      STDOUT.print "\e[?1002h" # Enable mouse *move when clicked* reporting
+      STDOUT.print "\e[?1006h" # Enable extended reporting
+      hide_cursor
+      @con.raw!
+    end
 
-      if c.nil?
-        if c1
-          @lastchar = c1.to_sym
-          args = c1.respond_to?(:args) ? c1.args : []
-          return Array(c1.to_sym).concat(args || [])
-        else
-          @lastchar = char.inspect
-          return nil
-        end
-      end
+    def cleanup
+      # Some programs, like more and docker struggles if the terminal
+      # is not returned to blocking mode
+      stdin_flags = STDIN.fcntl(Fcntl::F_GETFL)
+      STDIN.fcntl(Fcntl::F_SETFL, stdin_flags & ~Fcntl::O_NONBLOCK) #
 
-      if c.kind_of?(Hash)
-        map = c
-      else
-        @lastchar = c1.to_sym.to_s.split("_").join(" ")
-        @lastchar += " (#{c.to_s})" if c.to_s != @lastchar
-        return c
-      end
+      @con.cooked!
+      STDOUT.print "\e[?2004l" #Disable bracketed paste
+      STDOUT.print "\e[?1000l" #Disable mouse reporting
+      show_cursor
     end
-  end
 
-  def do_command(c)
-    return nil if !c
-    if @target.respond_to?(Array(c).first)
-      @lastcmd = c
-      @target.instance_eval { send(*Array(c)) }
-    else
-      @lastchar = "Unbound: #{Array(c).first.inspect}"
+    def quit
+      @@controllers.each {|t| t.kill }
+      cleanup
     end
-  end
 
-  def read_input
-    c = get_command
-    if !c
-      Thread.pass
-      return
+
+    def fill_buf
+      # We do this to ensure the other thread gets a chance
+      sleep(0.01)
+
+      @m.synchronize do
+        @con.raw!
+        return if !IO.select([$stdin],nil,nil,0.1)
+        str = $stdin.read_nonblock(4096)
+
+        # FIXME...
+        str.force_encoding("utf-8")
+        @buf << str
+      end
+    rescue IO::WaitReadable
     end
-    if Array(c).first == :insert_char
-      # FIXME: Attempt to combine multiple :insert_char into one.
-      #Probably should happen in get_command
-      #while (c2 = get_command) && Array(c2).first == :insert_char
-      #  c.last << c2.last
-      #end
-      #@commands << c
-      #c = c2
-      #return nil if !c
+
+
+    def getc
+      while @buf.empty?
+        fill_buf
+      end
+      @buf.slice!(0) if !paused? && @mode == :cooked
+    rescue Interrupt
     end
-    @commands << c
-    Thread.pass
-  end
 
-  def next_command
-    if @commands.empty?
-      sleep(0.001)
-      Thread.pass
+    # We do this because @keybindings can be changed
+    # on the main thread if the client changes the bindings,
+    # e.g. by calling `#raw`. This is the *only* sanctioned
+    # way to look up the binding.
+    #
+    def map(key, map = @keybindings)
+      map && key ? map[key.to_sym] : nil
     end
-    @commands.shift
-  end
 
-  def handle_input(prefix="",timeout=0.1)
-    if c = next_command
-      do_command(c)
+    def get_command
+      # Keep track of compound mapping
+      cmap = nil
+      cmdstr = ""
+
+      loop do
+        c = nil
+        char = getc
+        return nil if !char
+
+        a = Array(@kb.call(char))
+        c1 = a.first
+
+        if c1 == :mouse_up
+          t  = Time.now
+          dt = @lastclick ? t - @lastclick : 999
+          if dt < DOUBLE_CLICK_INTERVAL
+            c1 = :mouse_doubleclick
+          else
+            c1 = :mouse_click
+          end
+          @lastclick = t
+        end
+
+        c = map(c1, cmap || @keybindings)
+
+        if c.nil? && c1.kind_of?(String)
+          return [:char, c1]
+        end
+
+        if c.nil?
+          if c1
+            args = c1.respond_to?(:args) ? c1.args : []
+            @lastcmd = cmdstr + c1.to_sym.to_s
+            return Array(c1.to_sym).concat(args || [])
+          else
+            @lastcmd = cmdstr + char.inspect
+            return nil
+          end
+        end
+
+        str = c1.to_sym.to_s.split("_").join(" ")
+        if cmdstr.empty?
+          cmdstr = str
+        else
+          cmdstr += " + " + str
+        end
+
+        if c.kind_of?(Hash) # Compound mapping
+          cmap = c
+        else
+          @lastcmd = cmdstr + " (#{c.to_s})" if c.to_s != @lastcmd
+          return c
+        end
+      end
     end
-    return c
-  end
 
-  def pry(e=nil)
-    pause do
-      cleanup
-      puts ANSI.cls
-      binding.pry
+    def read_input
+      c = get_command
+      if !c
+        Thread.pass
+        return
+      end
+
+      @commands << c
     end
-    setup
-  end
 
-  def suspend
-    pause do
-      yield if block_given?
-      Process.kill("STOP", 0)
+    def readloop
+      loop do
+        if @mode == :cooked
+          read_input
+        else
+          fill_buf
+        end
+      end
     end
-  end
 
-  def resume
-    @mode = :cooked
-    setup
-  end
-end
-end
+    def do_command(c)
+      return nil if !c || !@target
+      a = Array(c)
+      if @target.respond_to?(a.first)
+        @target.instance_eval { send(*a) }
+      else
+        @lastcmd = "Unbound: #{a.first.inspect}"
+      end
+    end
 
-at_exit do
-  #
-  # FIXME: This is a workaround for Controller putting
-  # STDIN into nonblocking mode and not cleaning up, which
-  # causes all kind of problems with a variety of tools (more,
-  # docker etc.) which expect it to be blocking.
-  Termcontroller::Controller.pause! do
-    stdin_flags = STDIN.fcntl(Fcntl::F_GETFL)
-    STDIN.fcntl(Fcntl::F_SETFL, stdin_flags & ~Fcntl::O_NONBLOCK) #
-    IO.console.cooked!
   end
 end

data/lib/termcontroller/version.rb

@@ -1,3 +1,3 @@
 module Termcontroller
-  VERSION = "0.2"
+  VERSION = "0.5"
 end

data/lib/termcontroller.rb

@@ -3,5 +3,4 @@ require "termcontroller/controller"
 
 module Termcontroller
   class Error < StandardError; end
-  # Your code goes here...
 end

data/termcontroller.gemspec

@@ -26,4 +26,5 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+  spec.add_dependency "keyboard_map", ">=0.1.3"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: termcontroller
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.5'
 platform: ruby
 authors:
 - Vidar Hokstad
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-17 00:00:00.000000000 Z
-dependencies: []
+date: 2025-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: keyboard_map
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
 description: 
 email:
 - vidar@hokstad.com
@@ -26,6 +40,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/draw.rb
 - lib/termcontroller.rb
 - lib/termcontroller/controller.rb
 - lib/termcontroller/version.rb
@@ -50,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: Controller/input processing for terminal applications