bestliner 0.1.0

data/ext/bestliner/bestline.h

@@ -0,0 +1,39 @@
+#pragma once
+
+typedef struct bestlineCompletions {
+  unsigned long len;
+  char **cvec;
+} bestlineCompletions;
+
+typedef void(bestlineCompletionCallback)(const char *, bestlineCompletions *);
+typedef char *(bestlineHintsCallback)(const char *, const char **,
+                                       const char **);
+typedef void(bestlineFreeHintsCallback)(void *);
+typedef unsigned(bestlineXlatCallback)(unsigned);
+
+void bestlineSetCompletionCallback(bestlineCompletionCallback *);
+void bestlineSetHintsCallback(bestlineHintsCallback *);
+void bestlineSetFreeHintsCallback(bestlineFreeHintsCallback *);
+void bestlineAddCompletion(bestlineCompletions *, const char *);
+void bestlineSetXlatCallback(bestlineXlatCallback *);
+
+char *bestline(const char *);
+char *bestlineRaw(const char *, int, int);
+char *bestlineWithHistory(const char *, const char *);
+int bestlineHistoryAdd(const char *);
+int bestlineHistorySave(const char *);
+int bestlineHistoryLoad(const char *);
+void bestlineFreeCompletions(bestlineCompletions *);
+void bestlineHistoryFree(void);
+void bestlineClearScreen(int);
+void bestlineMaskModeEnable(void);
+void bestlineMaskModeDisable(void);
+void bestlineDisableRawMode(void);
+void bestlineFree(void *);
+
+char bestlineIsSeparator(unsigned);
+char bestlineNotSeparator(unsigned);
+char bestlineIsXeparator(unsigned);
+unsigned bestlineUppercase(unsigned);
+unsigned bestlineLowercase(unsigned);
+long bestlineReadCharacter(int, char *, unsigned long);

data/ext/bestliner/bestliner.c

@@ -0,0 +1,136 @@
+#include <ruby.h>
+#include "bestline.h"
+
+static VALUE Bestliner;
+static ID sym_id_call;
+
+/* Callback Functions */
+
+static void completionCallback(const char *buf, bestlineCompletions *lc) {
+    VALUE proc, ary, str;
+    long i, matches;
+    proc = rb_iv_get(Bestliner, "@completion_callback");
+    ary = rb_funcall(proc, sym_id_call, 1, rb_utf8_str_new_cstr(buf));
+    Check_Type(ary, T_ARRAY);
+    matches = RARRAY_LEN(ary);
+    for (i = 0; i < matches; i++) {
+        str = rb_obj_as_string(RARRAY_AREF(ary, i));
+        bestlineAddCompletion(lc, StringValueCStr(str));
+    }
+}
+
+static char *hintsCallback(const char *buf, const char **ansi1, const char **ansi2) {
+    VALUE proc, str, a1, a2;
+    proc = rb_iv_get(Bestliner, "@hints_callback");
+    str = rb_funcall(proc, sym_id_call, 1, rb_utf8_str_new_cstr(buf));
+    if (NIL_P(str)) {
+        return NULL;
+    } else {
+        a1 = rb_iv_get(Bestliner, "@hints_before");
+        if (!NIL_P(a1)) *ansi1 = StringValueCStr(a1);
+        a2 = rb_iv_get(Bestliner, "@hints_after");
+        if (!NIL_P(a2)) *ansi2 = StringValueCStr(a2);
+        return StringValueCStr(str);
+    }
+}
+
+/* Wrapper Functions */
+
+static VALUE bestliner_bestline(VALUE self, VALUE prompt) {
+    VALUE result;
+    char *line;
+    line = bestline(StringValueCStr(prompt));
+    if (line == NULL) return Qnil;
+    result = rb_utf8_str_new_cstr(line);
+    free(line);
+    return result;
+}
+
+static VALUE bestliner_bestlineWithHistory(VALUE self, VALUE prompt, VALUE filename) {
+    VALUE result;
+    char *line;
+    line = bestlineWithHistory(StringValueCStr(prompt), StringValueCStr(filename));
+    if (line == NULL) return Qnil;
+    result = rb_utf8_str_new_cstr(line);
+    free(line);
+    return result;
+}
+
+static VALUE bestliner_bestlineRaw(VALUE self, VALUE prompt, VALUE in, VALUE out) {
+    VALUE result;
+    char *line;
+    line = bestlineRaw(StringValueCStr(prompt), NUM2INT(in), NUM2INT(out));
+    if (line == NULL) return Qnil;
+    result = rb_utf8_str_new_cstr(line);
+    free(line);
+    return result;
+}
+
+static VALUE bestliner_bestlineHistoryAdd(VALUE self, VALUE line) {
+    int rc;
+    rc = bestlineHistoryAdd(StringValueCStr(line));
+    return INT2NUM(rc);
+}
+
+static VALUE bestliner_bestlineHistorySave(VALUE self, VALUE filename) {
+    int rc;
+    rc = bestlineHistorySave(StringValueCStr(filename));
+    return INT2NUM(rc);
+}
+
+static VALUE bestliner_bestlineHistoryLoad(VALUE self, VALUE filename) {
+    int rc;
+    rc = bestlineHistoryLoad(StringValueCStr(filename));
+    return INT2NUM(rc);
+}
+
+static VALUE bestliner_bestlineHistoryFree(VALUE self) {
+    bestlineHistoryFree();
+    return Qnil;
+}
+
+static VALUE bestliner_bestlineClearScreen(VALUE self, VALUE out) {
+    bestlineClearScreen(NUM2INT(out));
+    return Qnil;
+}
+
+static VALUE bestliner_bestlineMaskModeEnable(VALUE self) {
+    bestlineMaskModeEnable();
+    return Qtrue;
+}
+
+static VALUE bestliner_bestlineMaskModeDisable(VALUE self) {
+    bestlineMaskModeDisable();
+    return Qfalse;
+}
+
+static VALUE bestliner_bestlineSetCompletionCallback(VALUE self, VALUE proc) {
+    rb_iv_set(self, "@completion_callback", proc);
+    bestlineSetCompletionCallback(completionCallback);
+    return proc;
+}
+
+static VALUE bestliner_bestlineSetHintsCallback(VALUE self, VALUE proc) {
+    rb_iv_set(self, "@hints_callback", proc);
+    bestlineSetHintsCallback(hintsCallback);
+    return proc;
+}
+
+void Init_bestliner(void) {
+    /* Setup symbols */
+    sym_id_call = rb_intern("call");
+    /* Setup module */
+    Bestliner = rb_define_module("Bestliner");
+    rb_define_singleton_method(Bestliner, "__bestline", bestliner_bestline, 1);
+    rb_define_singleton_method(Bestliner, "__bestline_with_history", bestliner_bestlineWithHistory, 2);
+    rb_define_singleton_method(Bestliner, "__bestline_raw", bestliner_bestlineRaw, 3);
+    rb_define_singleton_method(Bestliner, "__add_history", bestliner_bestlineHistoryAdd, 1);
+    rb_define_singleton_method(Bestliner, "__save_history", bestliner_bestlineHistorySave, 1);
+    rb_define_singleton_method(Bestliner, "__load_history", bestliner_bestlineHistoryLoad, 1);
+    rb_define_singleton_method(Bestliner, "__free_history", bestliner_bestlineHistoryFree, 0);
+    rb_define_singleton_method(Bestliner, "__clear_screen", bestliner_bestlineClearScreen, 1);
+    rb_define_singleton_method(Bestliner, "__mask_mode_enable", bestliner_bestlineMaskModeEnable, 0);
+    rb_define_singleton_method(Bestliner, "__mask_mode_disable", bestliner_bestlineMaskModeDisable, 0);
+    rb_define_singleton_method(Bestliner, "__set_completion_cb", bestliner_bestlineSetCompletionCallback, 1);
+    rb_define_singleton_method(Bestliner, "__set_hints_cb", bestliner_bestlineSetHintsCallback, 1);
+}

data/ext/bestliner/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+dir_config("bestline")
+have_header("bestline.h")
+create_makefile "bestliner/bestliner"

data/lib/bestliner/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Bestliner
+  VERSION = "0.1.0"
+end

data/lib/bestliner.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Bestliner
+  class << self
+    # Reads text input after an optional prompt
+    #
+    # @param prompt [String] the prompt to display before the input cursor
+    # @return [String, nil] the line of input, `nil` if EOF
+    def bestline(prompt = "")
+      raise ArgumentError, "prompt must be of class String" unless prompt.is_a?(String)
+      __bestline prompt
+    end
+
+    # Reads text input after an optional prompt and saves input to a file
+    #
+    # @param prompt [String] the prompt to display before the input cursor
+    # @param filename [String] the file to use for saving input history
+    # @return (see #bestline)
+    def bestline_with_history(prompt = "", filename = ".bestliner_history")
+      raise ArgumentError, "prompt must be of class String" unless prompt.is_a?(String)
+      raise ArgumentError, "filename must be of class String" unless filename.is_a?(String)
+      __bestline_with_history prompt, filename
+    end
+
+    # Reads text input after an optional prompt from the input and displays on output
+    #
+    # @param prompt [String] the prompt to display before the input cursor
+    # @param input [IO] the stream to use as input
+    # @param output [IO] the stream to use as output
+    # @return (see #bestline)
+    def bestline_raw(prompt = "", input, output)
+      raise ArgumentError, "prompt must be of class String" unless prompt.is_a?(String)
+      raise ArgumentError, "input must be of class IO" unless input.is_a?(IO)
+      raise ArgumentError, "output must be of class IO" unless output.is_a?(IO)
+      __bestline_raw prompt, input.fileno, output.fileno
+    end
+
+    # Adds the line to the internal history
+    #
+    # @param line [String] the line to add
+    def add_history(line)
+      raise ArgumentError, "line must be of class String" unless line.is_a?(String)
+      return_code = __add_history line
+      raise IOError, "cannot write to history" unless return_code == 1
+    end
+
+    # Saves the history to the file
+    #
+    # @param filename [String] the filename to use
+    def save_history(filename)
+      raise ArgumentError, "filename must be of class String" unless filename.is_a?(String)
+      return_code = __save_history filename
+      raise IOError, "cannot save history to #{filename}" unless return_code == 0
+    end
+
+    # Loads the history from the file
+    #
+    # @param (see #save_history)
+    def load_history(filename)
+      raise Errno::ENOENT, filename unless File.exist?(filename)
+      return_code = __load_history filename
+      raise IOError, "cannot load history from #{filename}" unless return_code == 0
+    end
+
+    # Frees the memory used for the internal history
+    def free_history
+      __free_history
+    end
+
+    # Clears the screen of the output stream
+    #
+    # @param output [IO] the stream to use as output
+    def clear_screen(output)
+      raise ArgumentError, "output must be of class IO" unless output.is_a?(IO)
+      __clear_screen output.fileno
+    end
+
+    # Sets the mask mode
+    #
+    # @param is_enabled [Boolean] whether mask mode is enabled
+    def mask_mode=(is_enabled)
+      @mask_mode = if is_enabled
+        __mask_mode_enable
+      else
+        __mask_mode_disable
+      end
+    end
+
+    # Checks the status of mask mode
+    #
+    # @return [Boolean] whether mask mode is enabled
+    def mask_mode?
+      !!(defined?(@mask_mode) && @mask_mode)
+    end
+
+    # Sets the completion callback
+    #
+    # @param callback [#call] callback that returns completions
+    def completion_callback=(callback)
+      raise ArgumentError, "callback must respond to :call" unless callback.respond_to?(:call)
+      __set_completion_cb callback
+    end
+
+    # Sets the hints callback
+    #
+    # @param callback [#call] callback that returns a hint
+    def hints_callback=(callback)
+      raise ArgumentError, "callback must respond to :call" unless callback.respond_to?(:call)
+      __set_hints_cb callback
+    end
+
+
+    # Sets the ANSI code to use before a hint
+    #
+    # @param ansi_code [String] ANSI code output before hint
+    def hints_before=(ansi_code)
+      raise ArgumentError, "ansi_code must be of class String" unless ansi_code.is_a?(String)
+      @hints_before = ansi_code
+    end
+
+    # Sets the ANSI code to use after a hint
+    #
+    # @param ansi_code [String] ANSI code output after hint
+    def hints_after=(ansi_code)
+      raise ArgumentError, "ansi_code must be of class String" unless ansi_code.is_a?(String)
+      @hints_after = ansi_code
+    end
+  end
+end
+
+require "bestliner/bestliner"

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: bestliner
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michael Camilleri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Bestliner is a Ruby wrapper around bestline, a C library for interactive
+  pseudoteletypewriter command sessions using ANSI Standard X3.64 control
+  sequences. Bestliner supports Emacs-style editing shortcuts, a searchable
+  history, completion and hint support via callbacks and UTF-8 editing.
+email: mike@inqk.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bestliner.gemspec
+- ext/bestliner/Makefile
+- ext/bestliner/bestline.c
+- ext/bestliner/bestline.h
+- ext/bestliner/bestliner.c
+- ext/bestliner/extconf.rb
+- lib/bestliner.rb
+- lib/bestliner/version.rb
+homepage: https://github.com/pyrmont/bestliner
+licenses:
+- BSD-2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.15
+signing_key: 
+specification_version: 4
+summary: Ruby wrapper for bestline, a C library for reading user input
+test_files: []