rubysl-readline 0.0.1 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 926cb4be63fac4d727b0dcc528219483beb8962f
+  data.tar.gz: 697e6f288c806657af0eff194296d181af74ee75
+SHA512:
+  metadata.gz: df8bd90663d5ba8362be5aecfe5a3b03b50282f08e6a29b78c10f9fb623adf21370e27bff31cd04a491148a441086c68a37ea071ac3b6a4e40a6db6172a375bb
+  data.tar.gz: 551083b1dbdc4e52c6530353ffcbbc3b0749c870174f22ca223b0679f66ad29e9847ba8ce40abccf3c2bf18ed96165f8cb3ee70cb9a1229478965a0fd1c5bfc5

data/.gitignore

@@ -15,4 +15,3 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-.rbx

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+before_install:
+  - gem update --system
+  - gem --version
+  - gem install rubysl-bundler
+script: bundle exec mspec spec
+rvm:
+  - rbx-nightly-18mode

data/README.md

@@ -1,4 +1,4 @@
-# RubySL::Readline
+# Rubysl::Readline
 
 TODO: Write a gem description
 
@@ -24,6 +24,6 @@ TODO: Write usage instructions here
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request

data/Rakefile

@@ -1,2 +1 @@
-#!/usr/bin/env rake
 require "bundler/gem_tasks"

data/ext/rubysl/readline/extconf.rb

@@ -0,0 +1,64 @@
+require "mkmf"
+
+$readline_headers = ["stdio.h"]
+
+def have_readline_header(header)
+  if have_header(header)
+    $readline_headers.push(header)
+    return true
+  else
+    return false
+  end
+end
+
+def have_readline_var(var)
+  return have_var(var, $readline_headers)
+end
+
+dir_config('curses')
+dir_config('ncurses')
+dir_config('termcap')
+dir_config("readline")
+enable_libedit = enable_config("libedit")
+have_library("user32", nil) if /cygwin/ === RUBY_PLATFORM
+have_library("ncurses", "tgetnum") ||
+  have_library("termcap", "tgetnum") ||
+  have_library("curses", "tgetnum")
+
+if enable_libedit
+  unless (have_readline_header("editline/readline.h") ||
+          have_readline_header("readline/readline.h")) &&
+          have_library("edit", "readline")
+    exit
+  end
+else
+  unless ((have_readline_header("readline/readline.h") &&
+           have_readline_header("readline/history.h")) &&
+           (have_library("readline", "readline") ||
+            have_library("edit", "readline"))) ||
+            (have_readline_header("editline/readline.h") &&
+             have_library("edit", "readline"))
+    exit
+  end
+end
+
+have_func("rl_filename_completion_function")
+have_func("rl_username_completion_function")
+have_func("rl_completion_matches")
+have_readline_var("rl_deprep_term_function")
+have_readline_var("rl_completion_append_character")
+have_readline_var("rl_basic_word_break_characters")
+have_readline_var("rl_completer_word_break_characters")
+have_readline_var("rl_basic_quote_characters")
+have_readline_var("rl_completer_quote_characters")
+have_readline_var("rl_filename_quote_characters")
+have_readline_var("rl_attempted_completion_over")
+have_readline_var("rl_library_version")
+have_readline_var("rl_event_hook")
+have_func("rl_cleanup_after_signal")
+have_func("rl_clear_signals")
+have_func("rl_vi_editing_mode")
+have_func("rl_emacs_editing_mode")
+have_func("replace_history_entry")
+have_func("remove_history")
+create_makefile("readline/readline")

data/ext/rubysl/readline/readline.c

@@ -0,0 +1,537 @@
+/* readline.c -- GNU Readline module
+   Copyright (C) 1997-2001  Shugo Maeda
+
+   Modified for Rubinius by Evan Phoenix and others
+*/
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <readline/readline.h>
+#include <readline/history.h>
+
+#include "ruby.h"
+
+#include <unistd.h>
+
+static VALUE mReadline;
+
+#define TOLOWER(c) (isupper(c) ? tolower(c) : c)
+
+#define COMPLETION_PROC "completion_proc"
+#define COMPLETION_CASE_FOLD "completion_case_fold"
+static ID completion_proc, completion_case_fold;
+
+static char **readline_attempted_completion_function(const char *text,
+                                                     int start, int end);
+
+static VALUE readline_unlocked(void* prompt) {
+  return (VALUE)readline((char*)prompt);
+}
+
+static VALUE
+readline_readline(VALUE self, VALUE tmp, VALUE add_hist)
+{
+    VALUE result;
+    char *prompt = NULL;
+    char *buff;
+
+    rb_secure(4);
+    SafeStringValue(tmp);
+    prompt = RSTRING_PTR(tmp);
+
+    if(!isatty(0) && errno == EBADF) rb_raise(rb_eIOError, "stdin closed");
+
+    buff = (char*)rb_thread_blocking_region(readline_unlocked, prompt, 0, 0);
+
+    if(RTEST(add_hist) && buff) {
+      add_history(buff);
+    }
+
+    if(buff) {
+      result = rb_tainted_str_new2(buff);
+      free(buff);
+    } else {
+      result = Qnil;
+    }
+
+    return result;
+}
+
+static VALUE
+readline_s_set_completion_proc(self, proc)
+    VALUE self;
+    VALUE proc;
+{
+    rb_secure(4);
+    if (!rb_respond_to(proc, rb_intern("call")))
+        rb_raise(rb_eArgError, "argument must respond to `call'");
+    return rb_ivar_set(mReadline, completion_proc, proc);
+}
+
+static VALUE
+readline_s_get_completion_proc(self)
+    VALUE self;
+{
+    rb_secure(4);
+    return rb_attr_get(mReadline, completion_proc);
+}
+
+static VALUE
+readline_s_set_completion_case_fold(self, val)
+    VALUE self;
+    VALUE val;
+{
+    rb_secure(4);
+    return rb_ivar_set(mReadline, completion_case_fold, val);
+}
+
+static VALUE
+readline_s_get_completion_case_fold(self)
+    VALUE self;
+{
+    rb_secure(4);
+    return rb_attr_get(mReadline, completion_case_fold);
+}
+
+struct complete_args {
+  const char* text;
+  int start;
+  int end;
+};
+
+static void*
+readline_complete_locked(struct complete_args* args) {
+    const char *text = args->text;
+    int start = args->start;
+    int end = args->end;
+
+    VALUE proc, ary, temp;
+    char **result;
+    int case_fold;
+    int i, matches;
+
+    proc = rb_attr_get(mReadline, completion_proc);
+    if (NIL_P(proc))
+        return NULL;
+#ifdef HAVE_RL_ATTEMPTED_COMPLETION_OVER
+    rl_attempted_completion_over = 1;
+#endif
+    case_fold = RTEST(rb_attr_get(mReadline, completion_case_fold));
+    ary = rb_funcall(proc, rb_intern("call"), 1, rb_tainted_str_new2(text));
+    ary = rb_Array(ary);
+
+    matches = rb_ary_size(ary);
+    if (matches == 0) return NULL;
+    result = ALLOC_N(char *, matches + 2);
+    for (i = 0; i < matches; i++) {
+      temp = rb_obj_as_string(rb_ary_entry(ary, i));
+      result[i + 1] = ALLOC_N(char, RSTRING_LEN(temp) + 1);
+      strcpy(result[i + 1], RSTRING_PTR(temp));
+    }
+    result[matches + 1] = NULL;
+
+    if (matches == 1) {
+        result[0] = strdup(result[1]);
+    }
+    else {
+        register int i = 1;
+        int low = 100000;
+
+        while (i < matches) {
+            register int c1, c2, si;
+
+            if (case_fold) {
+                for (si = 0;
+                     (c1 = TOLOWER(result[i][si])) &&
+                         (c2 = TOLOWER(result[i + 1][si]));
+                     si++)
+                    if (c1 != c2) break;
+            } else {
+                for (si = 0;
+                     (c1 = result[i][si]) &&
+                         (c2 = result[i + 1][si]);
+                     si++)
+                    if (c1 != c2) break;
+            }
+
+            if (low > si) low = si;
+            i++;
+        }
+        result[0] = ALLOC_N(char, low + 1);
+        strncpy(result[0], result[1], low);
+        result[0][low] = '\0';
+    }
+
+    return (void*)result;
+}
+
+static char **
+readline_attempted_completion_function(text, start, end)
+    const char *text;
+    int start;
+    int end;
+{
+  struct complete_args args = {text, start, end};
+  void* ret = rb_thread_call_with_gvl((rb_thread_call_func)readline_complete_locked, &args);
+  return (char**)ret;
+}
+
+static VALUE
+readline_s_set_completion_append_character(self, str)
+    VALUE self, str;
+{
+    rb_secure(4);
+    if (NIL_P(str)) {
+        rl_completion_append_character = '\0';
+    }
+    else {
+        SafeStringValue(str);
+        if (RSTRING_LEN(str) == 0) {
+            rl_completion_append_character = '\0';
+        } else {
+            rl_completion_append_character = RSTRING_PTR(str)[0];
+        }
+    }
+    return self;
+}
+
+static VALUE
+readline_s_get_completion_append_character(self)
+    VALUE self;
+{
+    rb_secure(4);
+    if (rl_completion_append_character == '\0')
+        return Qnil;
+
+    return rb_str_new((char*)&rl_completion_append_character, 1);
+}
+
+static VALUE
+readline_s_set_basic_word_break_characters(self, str)
+    VALUE self, str;
+{
+    static char *basic_word_break_characters = NULL;
+
+    rb_secure(4);
+    SafeStringValue(str);
+    if (basic_word_break_characters == NULL) {
+        basic_word_break_characters =
+        ALLOC_N(char, RSTRING_LEN(str) + 1);
+    }
+    else {
+        REALLOC_N(basic_word_break_characters, char, RSTRING_LEN(str) + 1);
+    }
+    strncpy(basic_word_break_characters,
+	    RSTRING_PTR(str), RSTRING_LEN(str));
+    basic_word_break_characters[RSTRING_LEN(str)] = '\0';
+    rl_basic_word_break_characters = basic_word_break_characters;
+    return self;
+}
+
+static VALUE
+readline_s_get_basic_word_break_characters(self, str)
+    VALUE self, str;
+{
+    rb_secure(4);
+    if (rl_basic_word_break_characters == NULL)
+        return Qnil;
+    return rb_tainted_str_new2(rl_basic_word_break_characters);
+}
+
+static VALUE
+readline_s_set_completer_word_break_characters(self, str)
+    VALUE self, str;
+{
+    static char *completer_word_break_characters = NULL;
+
+    rb_secure(4);
+    SafeStringValue(str);
+    if (completer_word_break_characters == NULL) {
+        completer_word_break_characters =
+	      ALLOC_N(char, RSTRING_LEN(str) + 1);
+    }
+    else {
+        REALLOC_N(completer_word_break_characters, char, RSTRING_LEN(str) + 1);
+    }
+    strncpy(completer_word_break_characters,
+	    RSTRING_PTR(str), RSTRING_LEN(str));
+    completer_word_break_characters[RSTRING_LEN(str)] = '\0';
+    rl_completer_word_break_characters = completer_word_break_characters;
+    return self;
+}
+
+static VALUE
+readline_s_get_completer_word_break_characters(self, str)
+    VALUE self, str;
+{
+    rb_secure(4);
+    if (rl_completer_word_break_characters == NULL)
+        return Qnil;
+    return rb_tainted_str_new2(rl_completer_word_break_characters);
+}
+
+static VALUE
+readline_s_set_completer_quote_characters(self, str)
+    VALUE self, str;
+{
+    static char *completer_quote_characters = NULL;
+
+    rb_secure(4);
+    SafeStringValue(str);
+    if (completer_quote_characters == NULL) {
+        completer_quote_characters =
+	      ALLOC_N(char, RSTRING_LEN(str) + 1);
+    }
+    else {
+        REALLOC_N(completer_quote_characters, char, RSTRING_LEN(str) + 1);
+    }
+    strncpy(completer_quote_characters,
+	    RSTRING_PTR(str), RSTRING_LEN(str));
+    completer_quote_characters[RSTRING_LEN(str)] = '\0';
+    rl_completer_quote_characters = completer_quote_characters;
+
+    return self;
+}
+
+static VALUE
+readline_s_get_completer_quote_characters(self, str)
+    VALUE self, str;
+{
+    rb_secure(4);
+    if (rl_completer_quote_characters == NULL)
+        return Qnil;
+    return rb_tainted_str_new2(rl_completer_quote_characters);
+}
+
+static VALUE
+hist_to_s(self)
+    VALUE self;
+{
+    return rb_str_new2("HISTORY");
+}
+
+static VALUE
+hist_get(self, index)
+    VALUE self;
+    VALUE index;
+{
+    HIST_ENTRY *entry;
+    int i;
+
+    rb_secure(4);
+    i = NUM2INT(index);
+    if (i < 0) {
+        i += history_length;
+    }
+    entry = history_get(history_base + i);
+    if (entry == NULL) {
+        rb_raise(rb_eIndexError, "invalid index");
+    }
+    return rb_tainted_str_new2(entry->line);
+}
+
+static VALUE
+hist_set(self, index, str)
+    VALUE self;
+    VALUE index;
+    VALUE str;
+{
+    HIST_ENTRY *entry;
+    int i;
+
+    rb_secure(4);
+    i = NUM2INT(index);
+    SafeStringValue(str);
+    if (i < 0) {
+        i += history_length;
+    }
+    entry = replace_history_entry(i, RSTRING_PTR(str), NULL);
+    if (entry == NULL) {
+      rb_raise(rb_eIndexError, "invalid index");
+    }
+    return str;
+}
+
+static VALUE
+hist_push(self, str)
+    VALUE self;
+    VALUE str;
+{
+    rb_secure(4);
+    SafeStringValue(str);
+    add_history(RSTRING_PTR(str));
+    return self;
+}
+
+static VALUE
+hist_push_method(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE str;
+
+    rb_secure(4);
+    while (argc--) {
+        str = *argv++;
+        SafeStringValue(str);
+        add_history(RSTRING_PTR(str));
+    }
+    return self;
+}
+
+static VALUE
+rb_remove_history(index)
+    int index;
+{
+    HIST_ENTRY *entry;
+    VALUE val;
+
+    rb_secure(4);
+    entry = remove_history(index);
+    if (entry) {
+        val = rb_tainted_str_new2(entry->line);
+        free((char*)entry->line);
+        free(entry);
+        return val;
+    }
+    return Qnil;
+}
+
+static VALUE
+hist_pop(self)
+    VALUE self;
+{
+    rb_secure(4);
+    if (history_length > 0) {
+        return rb_remove_history(history_length - 1);
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+hist_shift(self)
+    VALUE self;
+{
+    rb_secure(4);
+    if (history_length > 0) {
+        return rb_remove_history(0);
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+hist_each(self)
+    VALUE self;
+{
+    HIST_ENTRY *entry;
+    int i;
+
+    rb_secure(4);
+    for (i = 0; i < history_length; i++) {
+        entry = history_get(history_base + i);
+        if (entry == NULL)
+            break;
+        rb_yield(rb_tainted_str_new2(entry->line));
+    }
+    return self;
+}
+
+static VALUE
+hist_length(self)
+    VALUE self;
+{
+    rb_secure(4);
+    return INT2NUM(history_length);
+}
+
+static VALUE
+hist_empty_p(self)
+    VALUE self;
+{
+    rb_secure(4);
+    return history_length == 0 ? Qtrue : Qfalse;
+}
+
+static VALUE
+hist_delete_at(self, index)
+    VALUE self;
+    VALUE index;
+{
+    int i;
+
+    rb_secure(4);
+    i = NUM2INT(index);
+    if (i < 0)
+        i += history_length;
+    if (i < 0 || i > history_length - 1) {
+        rb_raise(rb_eIndexError, "invalid index");
+    }
+    return rb_remove_history(i);
+}
+
+void
+Init_readline()
+{
+    VALUE history;
+
+    /* Allow conditional parsing of the ~/.inputrc file. */
+    rl_readline_name = "Ruby";
+
+    using_history();
+
+    completion_proc = rb_intern(COMPLETION_PROC);
+    completion_case_fold = rb_intern(COMPLETION_CASE_FOLD);
+
+    mReadline = rb_define_module("Readline");
+    rb_define_singleton_method(mReadline, "perform_readline",
+                              readline_readline, 2);
+    rb_define_singleton_method(mReadline, "completion_proc=",
+                               readline_s_set_completion_proc, 1);
+    rb_define_singleton_method(mReadline, "completion_proc",
+                               readline_s_get_completion_proc, 0);
+    rb_define_singleton_method(mReadline, "completion_case_fold=",
+                               readline_s_set_completion_case_fold, 1);
+    rb_define_singleton_method(mReadline, "completion_case_fold",
+                               readline_s_get_completion_case_fold, 0);
+    rb_define_singleton_method(mReadline, "completion_append_character=",
+                               readline_s_set_completion_append_character, 1);
+    rb_define_singleton_method(mReadline, "completion_append_character",
+                               readline_s_get_completion_append_character, 0);
+    rb_define_singleton_method(mReadline, "basic_word_break_characters=",
+                               readline_s_set_basic_word_break_characters, 1);
+    rb_define_singleton_method(mReadline, "basic_word_break_characters",
+                               readline_s_get_basic_word_break_characters, 0);
+    rb_define_singleton_method(mReadline, "completer_word_break_characters=",
+                               readline_s_set_completer_word_break_characters, 1);
+    rb_define_singleton_method(mReadline, "completer_word_break_characters",
+                               readline_s_get_completer_word_break_characters, 0);
+    rb_define_singleton_method(mReadline, "completer_quote_characters=",
+                               readline_s_set_completer_quote_characters, 1);
+    rb_define_singleton_method(mReadline, "completer_quote_characters",
+                               readline_s_get_completer_quote_characters, 0);
+
+    history = rb_obj_alloc(rb_cObject);
+    rb_define_singleton_method(history,"to_s", hist_to_s, 0);
+    rb_define_singleton_method(history,"[]", hist_get, 1);
+    rb_define_singleton_method(history,"[]=", hist_set, 2);
+    rb_define_singleton_method(history,"<<", hist_push, 1);
+    rb_define_singleton_method(history,"push", hist_push_method, -1);
+    rb_define_singleton_method(history,"pop", hist_pop, 0);
+    rb_define_singleton_method(history,"shift", hist_shift, 0);
+    rb_define_singleton_method(history,"each", hist_each, 0);
+    rb_define_singleton_method(history,"length", hist_length, 0);
+    rb_define_singleton_method(history,"size", hist_length, 0);
+    rb_define_singleton_method(history,"empty?", hist_empty_p, 0);
+    rb_define_singleton_method(history,"delete_at", hist_delete_at, 1);
+    rb_define_const(mReadline, "HISTORY", history);
+
+    rb_define_const(mReadline, "VERSION", rb_str_new2(rl_library_version));
+
+    rl_attempted_completion_function = readline_attempted_completion_function;
+}