termcontroller 0.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccc884e481a6ba710cb7edbd7edc1b05c20ed49e7f8e81cb0288813472006466
-  data.tar.gz: 6738a465db9c70c9d4d67f1626957de5209fbfbee95557cf9115f8734ff970e9
+  metadata.gz: 137ab6e058cbc71d9ac66d57479fcb01a9ab87fb403c795c553c880498c21410
+  data.tar.gz: b51e7f7353b269fc8e0375d858e9c0ee8605ea0e340b1c4f000ec4557e6ac281
 SHA512:
-  metadata.gz: d6c8d516c1a855d46833a6ead5e0a28ab2a682b1ce18a8039d301933acb2811d627b65c62b2ecbd0298c8379af98a7502d86a542342fc3c48911f996ab57cfba
-  data.tar.gz: 5f313f8f34231eaa7715c0df26e7abd470ee770af60cdbffb4c4dc7f1f8c08132df5e1f4558b713e26a9be307e5f496c51cfd7817efb12c6ac557dbe87d8e5e5
+  metadata.gz: 4a1d7893783340263e8d92ed7503ef239b77407e4466305f2fbbb1700b73108bb34d23eb34f8fcb3f8680bf5ac40f191cce9eba7ff8d3188d4213c0885c04d16
+  data.tar.gz: a6270a9cb7c27ee6744540013e6abc599851f846cc5b8b1a76bc08f34a4bc1784cf60ef89e999e588d653afa38f3e407f3d12c9ae4bfddf61e01529e8d5638ce

data/Gemfile

@@ -3,5 +3,6 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in termcontroller.gemspec
 gemspec
 
+gem "keyboard_map" #, path: "../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/lib/termcontroller/controller.rb

@@ -1,6 +1,7 @@
-# coding: utf-8
+# coding utf-8
 
 require 'io/console'
+require 'fcntl'
 
 # # Controller
 #
@@ -11,248 +12,279 @@ 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 }
+
+      @@controllers << @t
 
-  def readloop
-    loop do
-      if paused?
-        sleep(0.05)
-      elsif @mode == :cooked
-        read_input
-      else
-        fill_buf
-      end
     end
-  end
 
-  def pause
-    old = @mode
-    @mode = :pause
-    sleep(0.1)
-    IO.console.cooked!
-    yield
-  rescue Interrupt
-  ensure
-    @mode = old
-  end
+    def paused?; @mode == :pause; end
 
-  def fill_buf(timeout=0.1)
-    if paused?
-      sleep(0.1)
-      Thread.pass
-      return
+    def push_target(t)
+      @target_stack << @target
+      @target = t
     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
-      end
-      @buf.slice!(0) if !paused? && @mode == :cooked
-    else
-      sleep(0.1)
-      Thread.pass
-      return nil
+    def pop_target
+      t = @target
+      @target = @target_stack.pop
+      t
     end
-  rescue Interrupt
-  end
-
-  def raw
-    @mode = :raw
-    yield
-  rescue Interrupt
-  ensure
-    @mode = :cooked
-  end
 
-  def read_char
-    sleep(0.01) if @buf.empty?
-    @buf.slice!(0)
-  rescue Interrupt
-  end
 
-  def get_command
-    map = @keybindings
-    loop do
-      c = nil
-      char = getc
-      return nil if !char
+    #
+    # 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
+          setup
+          r
+        rescue Interrupt
+        ensure
+          @mode = old
+        end
+      end
+    end
 
-      c1 = Array(@kb.call(char)).first
-      c = map[c1.to_sym] if c1
+    # 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
 
-      if c.nil? && c1.kind_of?(String)
-        return [:insert_char, c1]
+    def handle_input
+      if c = @commands.pop
+        do_command(c)
       end
+      return Array(c)
+    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
+    def suspend
+      pause do
+        yield if block_given?
+        Process.kill("STOP", 0)
       end
+    end
 
-      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
+    def resume
+      @mode = :cooked
+      setup
+      @commands << [:resume]
     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}"
+    private # # ########################################################
+
+    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
+      STDOUT.print "\e[?25l"   # Hide cursor
+      @con.raw!
+    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) #
+
+      @con.cooked!
+      STDOUT.print "\e[?2004l" #Disable bracketed paste
+      STDOUT.print "\e[?1000l" #Disable mouse reporting
+      STDOUT.print "\e[?25h"   # Show cursor
     end
-  end
 
-  def read_input
-    c = get_command
-    if !c
-      Thread.pass
-      return
+    def quit
+      @@controllers.each {|t| t.kill }
+      cleanup
     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 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
-    @commands << c
-    Thread.pass
-  end
 
-  def next_command
-    if @commands.empty?
-      sleep(0.001)
-      Thread.pass
+
+    def getc
+      while @buf.empty?
+        fill_buf
+      end
+      @buf.slice!(0) if !paused? && @mode == :cooked
+    rescue Interrupt
     end
-    @commands.shift
-  end
 
-  def handle_input(prefix="",timeout=0.1)
-    if c = next_command
-      do_command(c)
+    # 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
-    return c
-  end
 
-  def pry(e=nil)
-    pause do
-      cleanup
-      puts ANSI.cls
-      binding.pry
+    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
-    setup
-  end
 
-  def suspend
-    pause do
-      yield if block_given?
-      Process.kill("STOP", 0)
+    def read_input
+      c = get_command
+      if !c
+        Thread.pass
+        return
+      end
+
+      @commands << c
     end
-  end
 
-  def resume
-    @mode = :cooked
-    setup
-  end
-end
-end
+    def readloop
+      loop do
+        if @mode == :cooked
+          read_input
+        else
+          fill_buf
+        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.3"
 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.3'
 platform: ruby
 authors:
 - Vidar Hokstad
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-17 00:00:00.000000000 Z
-dependencies: []
+date: 2023-08-02 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