linenoise 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21125585819cb1e4b7334c6451cedf89075e8371
-  data.tar.gz: 3e135e25334f937331e1ad76152ebe23e9c8035b
+  metadata.gz: 4cd7f0921e5e628c64d106d5468fbb058392d0c3
+  data.tar.gz: f45df4beb22b1553294cf811aaecebb51b4dc094
 SHA512:
-  metadata.gz: 61dff245d9241f8f264060f8084a4cf0ab9e5a4d05f7eb0ceca5f82d741cbde7cbd6ee5b21d3cebea51e9c218de6542333c5bf312c0d985bbb7149802de64629
-  data.tar.gz: 5c29070bd3157b220d1763203884c7ca6f6dbc05735f8d12e5bf635fee98eee716a6dba751ce4fa78d7b4b235ace6d17b16735771447e3875a574e36ce9aa9fb
+  metadata.gz: 4615c8507956123c6f1e3c2120906954d15e6e79c42477385938c2e26d7674b5e74fa84fc585baef5851e0c53744039e77ddc80b6413d3542d6538d8c727449d
+  data.tar.gz: 6bd64f537d2b48b05a00a82bebff9736dee05278fd6b73325e3fdc49f149eaa384b29218059ffd896cbda63cfb4026d73f13b52325e1faf091f182aa424d1006

data/CHANGELOG.md

@@ -3,8 +3,13 @@ Linenoise Ruby Changelog
 
 ### master
 
+### [v1.1.0][v1.1.0] (December 30, 2018)
+
+* Implemented all Linenoise features (previous release had none)
+
 ### [v1.0.0][v1.0.0] (November 25, 2018)
 
 * Initial release
 
 [v1.0.0]: https://github.com/kyrylo/linenoise-rb/releases/tag/v1.0.0
+[v1.1.0]: https://github.com/kyrylo/linenoise-rb/releases/tag/v1.1.0

data/README.md

@@ -1,33 +1,122 @@
-Linenoise
-=========
+Linenoise Ruby
+==============
+
+[![CircleCI](https://circleci.com/gh/kyrylo/linenoise-rb.svg?style=svg)](https://circleci.com/gh/kyrylo/linenoise-rb)
+[![Gem Version](https://badge.fury.io/rb/linenoise.svg)](http://badge.fury.io/rb/linenoise)
+[![Documentation Status](http://inch-ci.org/github/kyrylo/linenoise.svg?branch=master)](http://inch-ci.org/github/kyrylo/linenoise)
+[![Downloads](https://img.shields.io/gem/dt/linenoise.svg?style=flat)](https://rubygems.org/gems/linenoise)
+
+* [Documentation][documentation]
 
 Introduction
 ------------
 
-TBA
+The Linenoise gem is a wrapper around the small self-contained alternative to
+Readline and Libedit called [Linenoise](https://github.com/antirez/linenoise).
+
+Features
+--------
+
+* History support
+* Completion
+* Hints (suggestions at the right of the prompt as you type)
+* Single and multiline editing mode with the usual key bindings
 
 Installation
 ------------
 
-TBA
+### Bundler
+
+Add the Linenoise gem to your Gemfile:
+
+```ruby
+gem 'linenoise', '~> 1.1'
+```
+
+### Manual
+
+Invoke the following command from your terminal:
+
+```sh
+gem install linenoise
+```
 
 Examples
 --------
 
-TBA
+### Basic example
+
+```ruby
+require 'linenoise'
+
+while buf = Linenoise.linenoise('> ')
+  p buf
+end
+```
+
+### Completion
 
-API
----
+```ruby
+require 'linenoise'
 
-TBA
+LIST = %w[
+  search download open help history quit url next clear prev past
+].freeze
 
+Linenoise.completion_proc = proc do |input|
+  LIST.grep(/\A#{Regexp.escape(input)}/)
+end
+
+while line = Linenoise.linenoise('> ')
+  p line
+end
+```
+
+### Hints
+
+```ruby
+require 'linenoise'
+
+Linenoise.hint_proc = proc do |input|
+  case input
+  when /git show/
+    ' [<options>] [<object>...]'
+  when /git log/
+    ' [<options>] [<revision range>]'
+  else
+    ' --help'
+  end
+end
+
+while line = Linenoise.linenoise('> ')
+  p line
+end
+```
+
+More examples and full API explanation is available on the
+[documentation][documentation] page.
+
+Development
+-----------
+
+### Running tests
+
+```sh
+bundle exec rake compile spec
+```
+
+### Launching development console
+
+```
+bundle exec rake compile console
+```
 
 Contact
 -------
 
 In case you have a problem, question or a bug report, feel free to:
 
-* [file an issue](https://github.com/kyrylo/linenoise/issues)
+* [file an issue](https://github.com/kyrylo/linenoise-rb/issues)
 * send me an email (see https://github.com/kyrylo)
 * [tweet at me](https://twitter.com/kyrylosilin)
 
@@ -35,3 +124,5 @@ License
 -------
 
 The project uses the MIT License. See LICENSE.md for details.
+
+[documentation]: https://www.rubydoc.info/github/kyrylo/linenoise-rb/Linenoise

data/ext/linenoise/line_noise.c

@@ -1086,6 +1086,14 @@ static void freeHistory(void) {
     }
 }
 
+// Allocate fresh memory for history and reset history length.
+static void resetHistory(void) {
+    history = malloc(sizeof(char*)*history_max_len);
+    if (history == NULL) return;
+    memset(history, 0, (sizeof(char*)*history_max_len));
+    history_len = 0;
+}
+
 /* At exit we'll try to fix the terminal to the initial conditions. */
 static void linenoiseAtExit(void) {
     disableRawMode(STDIN_FILENO);
@@ -1106,9 +1114,8 @@ int linenoiseHistoryAdd(const char *line) {
 
     /* Initialization on first call. */
     if (history == NULL) {
-        history = malloc(sizeof(char*)*history_max_len);
+        resetHistory();
         if (history == NULL) return 0;
-        memset(history,0,(sizeof(char*)*history_max_len));
     }
 
     /* Don't add duplicated lines. */
@@ -1199,3 +1206,35 @@ int linenoiseHistoryLoad(const char *filename) {
     fclose(fp);
     return 0;
 }
+
+int linenoiseHistorySize(void) {
+    return history_len;
+}
+
+char *linenoiseHistoryGet(int index) {
+    if (index < 0 || index+1 > history_len)
+        return NULL;
+    return history[index];
+}
+
+char *linenoiseHistoryReplaceLine(int index, char *line) {
+    char *linecopy, *old_line;
+
+    if (index < 0 || index+1 > history_len)
+        return NULL;
+
+    /* Allocate memory for this new line so it can be freed */
+    linecopy = strdup(line);
+    if (!linecopy)
+        return NULL;
+
+    old_line = history[index];
+    history[index] = linecopy;
+
+    return old_line;
+}
+
+void linenoiseHistoryClear(void) {
+    freeHistory();
+    resetHistory();
+}

data/ext/linenoise/line_noise.h

@@ -62,6 +62,10 @@ int linenoiseHistoryAdd(const char *line);
 int linenoiseHistorySetMaxLen(int len);
 int linenoiseHistorySave(const char *filename);
 int linenoiseHistoryLoad(const char *filename);
+int linenoiseHistorySize();
+char *linenoiseHistoryGet(int index);
+char *linenoiseHistoryReplaceLine(int index, char *line);
+void linenoiseHistoryClear();
 void linenoiseClearScreen(void);
 void linenoiseSetMultiLine(int ml);
 void linenoisePrintKeyCodes(void);

data/ext/linenoise/linenoise.c

@@ -1,31 +1,596 @@
 #include <ruby.h>
+#include <ruby/io.h>
+#include <string.h>
 #include "line_noise.h"
 
+static VALUE mLinenoise;
+static ID id_call, id_multiline, id_hint_bold, id_hint_color, completion_proc,
+          hint_proc;
+static VALUE hint_boldness;
+static int hint_color;
+
+#define COMPLETION_PROC "completion_proc"
+#define HINT_PROC "hint_proc"
+
+/*
+ * Document-module: Linenoise
+ *
+ * The Linenoise module provides interface for the Linenoise library, which is a
+ * Readline replacement used in Redis, MongoDB, and Android.
+ *
+ * This module defines a number of methods to facilitate completion and accesses
+ * input history from the Ruby interpreter.
+ *
+ * Linenoise:: https://github.com/antirez/linenoise
+ *
+ * Reads one inputted line with line edit via the {Linenoise.linenoise} method.
+ *
+ *   require 'linenoise'
+ *
+ *   while buf = Linenoise.linenoise('> ')
+ *     p buf
+ *   end
+ *
+ * User input can be persisted via the history feature. The history can be
+ * accessed through the {Linenoise::HISTORY} constant.
+ *
+ *   require 'linenoise'
+ *
+ *   while buf = Linenoise.linenoise('> ')
+ *     p Linenoise::HISTORY.to_a
+ *     print('-> ', buf, '\n')
+ *   end
+ *
+ * == Using history
+ *
+ * History can be accessed through {Linenoise::HISTORY}. It can be saved to a
+ * file, or loaded from a file.
+ *
+ * === Adding lines to the history
+ *
+ *   Linenoise::HISTORY << '1 + 1'
+ *
+ *   # Or push multiple items.
+ *   Linenoise::HISTORY.push('2', '3')
+ *   Linenoise::HISTORY.size
+ *   #=> 3
+ *
+ * === Iterating lines & accessing individual entries
+ *
+ *   # Read a line at given index.
+ *   Linenoise::HISTORY[0]
+ *   #=> '1 + 1'
+ *
+ *   # Replace a line in the history with another one.
+ *   Linenoise::HISTORY[0] = 'begin'
+ *   Linenoise::HISTORY[0]
+ *   #=> 'begin'
+ *
+ *   # Iterate over lines like an array (HISTORY is enumerable).
+ *   Linenoise::HISTORY.each { |line| puts line }
+ *
+ * === Saving & loading
+ *
+ *   # Save to file.
+ *   Linenoise::HISTORY.save('linenoise_history')
+ *
+ *   # Load from file.
+ *   Linenoise::HISTORY.load('linenoise_history')
+ *
+ *   # Wipe out current history (doesn't delete the file).
+ *   Linenoise::HISTORY.clear
+ *   Linenoise::HISTORY.size
+ *   #=> 0
+ *
+ * === Setting maximum size of history
+ *
+ *   # The cap sets how many entries history can hold. When the capacity is
+ *   # exceeded, older entries are removed.
+ *   Linenoise::HISTORY.max_size = 3
+ */
+
+/* Hint colors */
+enum {red = 31, green, yellow, blue, magenta, cyan, white};
+
+static void
+mustbe_callable(VALUE proc)
+{
+    if (!NIL_P(proc) && !rb_respond_to(proc, id_call))
+        rb_raise(rb_eArgError, "argument must respond to `call'");
+}
+
+/*
+ * call-seq:
+ *   Linenoise.linenoise(prompt) -> string or nil
+ *
+ * Shows the +prompt+ and reads the inputted line with line editing.
+ *
+ * Returns nil when the inputted line is empty and user inputs EOF
+ * (Presses ^D on UNIX).
+ *
+ * Aliased as +readline+ for easier integration with Readline-enabled apps.
+ */
 static VALUE
 linenoise_linenoise(VALUE self, VALUE prompt)
 {
-  VALUE result;
-  char *line;
+    VALUE result;
+    char *line;
+
+    line = linenoise(StringValueCStr(prompt));
+    if (line) {
+        result = rb_locale_str_new_cstr(line);
+    }
+    else
+        result = Qnil;
+    if (line) free(line);
+
+    return result;
+}
+
+static void
+linenoise_attempted_completion_function(const char *buf, struct linenoiseCompletions *lc)
+{
+    VALUE proc, ary, str;
+    long i, matches;
+    rb_encoding *enc;
+    VALUE encobj;
+
+    proc = rb_attr_get(mLinenoise, completion_proc);
+    if (NIL_P(proc))
+        return;
+
+    ary = rb_funcall(proc, id_call, 1, rb_locale_str_new_cstr(buf));
+    if (!RB_TYPE_P(ary, T_ARRAY))
+        ary = rb_Array(ary);
+
+    matches = RARRAY_LEN(ary);
+    if (matches == 0)
+        return;
+
+    enc = rb_locale_encoding();
+    encobj = rb_enc_from_encoding(enc);
+    for (i = 0; i < matches; i++) {
+        str = rb_obj_as_string(RARRAY_AREF(ary, i));
+        StringValueCStr(str);
+        rb_enc_check(encobj, str);
+        linenoiseAddCompletion(lc, RSTRING_PTR(str));
+    }
+}
+
+/*
+ * call-seq:
+ *   Linenoise.completion_proc = proc
+ *
+ * Specifies a Proc object +proc+ to determine completion behavior. It should
+ * take input string and return an array of completion candidates.
+ *
+ *   require 'linenoise'
+ *
+ *   LIST = %w[
+ *     search download open help history quit url next clear prev past
+ *   ].freeze
+ *
+ *   Linenoise.completion_proc = proc do |input|
+ *     LIST.grep(/\A#{Regexp.escape(input)}/)
+ *   end
+ *
+ *   while line = Linenoise.linenoise('> ')
+ *     p line
+ *   end
+ *
+ * @raise ArgumentError if +proc+ is not a Proc
+ */
+static VALUE
+linenoise_set_completion_proc(VALUE self, VALUE proc)
+{
+    mustbe_callable(proc);
+    linenoiseSetCompletionCallback(linenoise_attempted_completion_function);
+    return rb_ivar_set(mLinenoise, completion_proc, proc);
+}
+
+/*
+ * call-seq:
+ *   Linenoise.completion_proc -> proc
+ *
+ * Returns the completion Proc object.
+ */
+static VALUE
+linenoise_get_completion_proc(VALUE self)
+{
+    return rb_attr_get(mLinenoise, completion_proc);
+}
+
+/*
+ * call-seq:
+ *   Linenoise.multiline = bool -> bool
+ *
+ * Specifies multiline mode. By default, Linenoise uses single line editing,
+ * that is, a single row on the screen will be used, and as the user types more,
+ * the text will scroll towards left to make room.
+ */
+static VALUE
+linenoise_set_multiline(VALUE self, VALUE vbool)
+{
+    int i = RTEST(vbool) ? 1 : 0;
+    rb_ivar_set(mLinenoise, id_multiline, vbool);
+    linenoiseSetMultiLine(i);
+    return vbool;
+}
+
+/*
+ * call-seq:
+ *   Linenoise.multiline?
+ *
+ * Checks if multiline mode is enabled.
+ */
+static VALUE
+linenoise_get_multiline(VALUE self)
+{
+    return rb_attr_get(mLinenoise, id_multiline);
+}
+
+static char *
+linenoise_attempted_hint_function(const char *buf, int *color, int *bold)
+{
+    VALUE proc, str, encobj;
+    rb_encoding *enc;
+
+    *bold = RTEST(hint_boldness) ? 1 : 0;
+    *color = hint_color;
+
+    proc = rb_attr_get(mLinenoise, hint_proc);
+    if (NIL_P(proc))
+        return NULL;
+
+    str = rb_funcall(proc, id_call, 1, rb_locale_str_new_cstr(buf));
+    enc = rb_locale_encoding();
+    encobj = rb_enc_from_encoding(enc);
+    StringValueCStr(str);
+    rb_enc_check(encobj, str);
+
+    return RSTRING_PTR(str);
+}
+
+/*
+ * call-seq:
+ *   Linenoise.hint_proc = proc
+ *
+ * Specifies a Proc object +proc+ to determine hint behavior. It should take
+ * input string and return the completion according to the input.
+ *
+ *   require 'linenoise'
+ *
+ *   Linenoise.hint_proc = proc do |input|
+ *     case input
+ *     when /git show/
+ *       ' [<options>] [<object>...]'
+ *     when /git log/
+ *       ' [<options>] [<revision range>]'
+ *     else
+ *       ' --help'
+ *     end
+ *   end
+ *
+ *   while line = Linenoise.linenoise('> ')
+ *     p line
+ *   end
+ *
+ * @raise ArgumentError if +proc+ is not a Proc
+ */
+static VALUE
+linenoise_set_hint_proc(VALUE self, VALUE proc)
+{
+    mustbe_callable(proc);
+    linenoiseSetHintsCallback(linenoise_attempted_hint_function);
+    return rb_ivar_set(mLinenoise, hint_proc, proc);
+}
+
+/*
+ * call-seq:
+ *   Linenoise.hint_proc -> proc
+ *
+ * Returns the hint Proc object.
+ */
+static VALUE
+linenoise_get_hint_proc(VALUE self)
+{
+    return rb_attr_get(mLinenoise, hint_proc);
+}
+
+/*
+ * call-seq:
+ *   Linenoise.hint_color = Integer -> Integer
+ *
+ * Sets the hint color. Allowed values are in a range from 31 to 37. Setting
+ * this option to 0 removes the color and uses the default font color.
+ *
+ * There are convenience constants for setting colors:
+ *
+ *   # Make the hint red.
+ *   Linenoise.hint_color = Linenoise::RED
+ *
+ *   # Remove the color.
+ *   Linenoise.hint_color = Linenoise::DEFAULT
+ *
+ * @raise TypeError if +color+ is not an Integer
+ * @raise ArgumentError if +color+ is not 0 or in range of 31-37
+ */
+static VALUE
+linenoise_set_hint_color(VALUE self, VALUE color)
+{
+    int c = 0;
+
+    switch (TYPE(color)) {
+      case T_NIL:
+        break;
+      case T_FIXNUM:
+        c = NUM2INT(color);
+        break;
+      default:
+        rb_raise(rb_eTypeError, "hint color is not an Integer");
+    }
+
+    if (c == 0 || (c >= 31 && c <= 37)) {
+        hint_color = c;
+    }
+    else
+        rb_raise(rb_eArgError, "color '%d' is not in range (31-37)", c);
+
+    return rb_ivar_set(mLinenoise, id_hint_color, color);
+}
+
+/*
+ * call-seq:
+ *   Linenoise.hint_color -> Integer
+ *
+ * Checks hint font color.
+ */
+static VALUE
+linenoise_get_hint_color(VALUE self)
+{
+    return rb_attr_get(mLinenoise, id_hint_color);
+}
+
+/*
+ * call-seq:
+ *   Linenoise.hint_bold = bool -> bool
+ *
+ * Sets hint boldness. +false+ means normal text, +true+ means bold. Defults to
+ * +false+.
+ *
+ *   Linenoise.hint_bold = true
+ */
+static VALUE
+linenoise_set_hint_boldness(VALUE self, VALUE boldness)
+{
+    hint_boldness = boldness;
+    return rb_ivar_set(mLinenoise, id_hint_bold, boldness);
+}
+
+/*
+ * call-seq:
+ *   Linenoise.hint_bold? -> bool
+ *
+ * Checks if the hint font is bold.
+ */
+static VALUE
+linenoise_get_hint_boldness(VALUE self)
+{
+    return rb_attr_get(mLinenoise, id_hint_bold);
+}
+
+/*
+ * call-seq:
+ *   Linenoise.clear_screen -> self
+ *
+ * Clears screen from characters.
+ */
+static VALUE
+linenoise_clear_screen(VALUE self)
+{
+    linenoiseClearScreen();
+    return self;
+}
+
+static VALUE
+hist_set_max_len(VALUE self, VALUE len)
+{
+    linenoiseHistorySetMaxLen(NUM2INT(len));
+    return len;
+}
 
-  line = linenoise(StringValueCStr(prompt));
-  if (line) {
-    result = rb_locale_str_new_cstr(line);
-  }
-  else
-    result = Qnil;
-  if (line) free(line);
+static VALUE
+hist_push(VALUE self, VALUE str)
+{
+    linenoiseHistoryAdd(StringValueCStr(str));
+    return self;
+}
+
+static VALUE
+hist_push_method(int argc, VALUE *argv, VALUE self)
+{
+    VALUE str;
+
+    while (argc--) {
+        str = *argv++;
+        linenoiseHistoryAdd(StringValueCStr(str));
+    }
+    return self;
+}
+
+static VALUE
+hist_save(VALUE self, VALUE filename)
+{
+    char *file = StringValueCStr(filename);
+
+    if (linenoiseHistorySave(file) == -1) {
+        rb_raise(rb_eArgError,
+                 "couldn't save Linenoise history to file '%s'", file);
+    }
+    return filename;
+}
+
+
+static VALUE
+hist_load(VALUE self, VALUE filename)
+{
+    char *file = StringValueCStr(filename);
 
-  return result;
+    if (linenoiseHistoryLoad(file) == -1) {
+        rb_raise(rb_eArgError,
+                 "couldn't load Linenoise history from file '%s'", file);
+    }
+    return filename;
+}
+
+static VALUE
+hist_length(VALUE self)
+{
+    return INT2NUM(linenoiseHistorySize());
+}
+
+static VALUE
+hist_each(VALUE self)
+{
+    char *line;
+    int i;
+
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    for (i = 0; i < linenoiseHistorySize(); i++) {
+        line = linenoiseHistoryGet(i);
+        if (line == NULL)
+            break;
+        rb_yield(rb_locale_str_new_cstr(line));
+    }
+    return self;
+}
+
+static VALUE
+hist_get(VALUE self, VALUE index)
+{
+    char *line = NULL;
+    int i;
+
+    i = NUM2INT(index);
+    if (i < 0) {
+        i += linenoiseHistorySize();
+    }
+    if (i >= 0) {
+        line = linenoiseHistoryGet(i);
+    }
+    if (line == NULL) {
+        rb_raise(rb_eIndexError, "invalid index");
+    }
+    return rb_locale_str_new_cstr(line);
+}
+
+static VALUE
+hist_set(VALUE self, VALUE index, VALUE str)
+{
+    char *old_line = NULL;
+    int i;
+
+    i = NUM2INT(index);
+    StringValueCStr(str);
+    if (i < 0) {
+        i += linenoiseHistorySize();
+    }
+    if (i >= 0) {
+        old_line = linenoiseHistoryReplaceLine(i, RSTRING_PTR(str));
+    }
+    if (old_line == NULL) {
+        rb_raise(rb_eIndexError, "invalid index");
+    }
+    return str;
+}
+
+/*
+ * call-seq:
+ *   Linenoise.hist_clear -> self
+ *
+ * Clears input history.
+ */
+static VALUE
+hist_clear(VALUE self)
+{
+    linenoiseHistoryClear();
+    return self;
 }
 
 void
 Init_linenoise(void)
 {
-  VALUE mLinenoise = rb_define_module("Linenoise");
-  rb_define_module_function(mLinenoise, "linenoise",
-			    linenoise_linenoise, 1);
-  rb_define_alias(rb_singleton_class(mLinenoise), "readline", "linenoise");
+    VALUE history;
+
+    id_call = rb_intern("call");
+    id_multiline = rb_intern("multiline");
+    id_hint_bold = rb_intern("hint_bold");
+    id_hint_color = rb_intern("hint_color");
+
+    completion_proc = rb_intern(COMPLETION_PROC);
+    hint_proc = rb_intern(HINT_PROC);
+
+    mLinenoise = rb_define_module("Linenoise");
+    /* Version string of Linenoise. */
+    rb_define_const(mLinenoise, "VERSION", rb_str_new_cstr("1.0"));
+    rb_define_module_function(mLinenoise, "linenoise",
+                              linenoise_linenoise, 1);
+    rb_define_alias(rb_singleton_class(mLinenoise), "readline", "linenoise");
+    rb_define_singleton_method(mLinenoise, "completion_proc=",
+                               linenoise_set_completion_proc, 1);
+    rb_define_singleton_method(mLinenoise, "completion_proc",
+                               linenoise_get_completion_proc, 0);
+    rb_define_singleton_method(mLinenoise, "multiline=",
+                               linenoise_set_multiline, 1);
+    rb_define_singleton_method(mLinenoise, "multiline?",
+                               linenoise_get_multiline, 0);
+    rb_define_singleton_method(mLinenoise, "hint_proc=",
+                               linenoise_set_hint_proc, 1);
+    rb_define_singleton_method(mLinenoise, "hint_proc",
+                               linenoise_get_hint_proc, 0);
+    rb_define_singleton_method(mLinenoise, "hint_color=",
+                               linenoise_set_hint_color, 1);
+    rb_define_singleton_method(mLinenoise, "hint_color",
+                               linenoise_get_hint_color, 0);
+    rb_define_singleton_method(mLinenoise, "hint_bold=",
+                               linenoise_set_hint_boldness, 1);
+    rb_define_singleton_method(mLinenoise, "hint_bold?",
+                               linenoise_get_hint_boldness, 0);
+    rb_define_singleton_method(mLinenoise, "clear_screen",
+                               linenoise_clear_screen, 0);
+
+    history = rb_obj_alloc(rb_cObject);
+    rb_extend_object(history, rb_mEnumerable);
+    rb_define_singleton_method(history, "max_size=", hist_set_max_len, 1);
+    rb_define_singleton_method(history, "<<", hist_push, 1);
+    rb_define_singleton_method(history, "push", hist_push_method, -1);
+    rb_define_singleton_method(history, "save", hist_save, 1);
+    rb_define_singleton_method(history, "load", hist_load, 1);
+    rb_define_singleton_method(history, "size", hist_length, 0);
+    rb_define_singleton_method(history, "clear", hist_clear, 0);
+    rb_define_singleton_method(history, "each", hist_each, 0);
+    rb_define_singleton_method(history, "[]", hist_get, 1);
+    rb_define_singleton_method(history, "[]=", hist_set, 2);
+
+    /*
+     * The history buffer. It extends Enumerable module, so it behaves just like
+     * an array. For example, gets the fifth content that the user input by
+     * HISTORY[4].
+     */
+    rb_define_const(mLinenoise, "HISTORY", history);
+
+    /* Hint color helpers */
+    rb_define_const(mLinenoise, "DEFAULT", Qnil);
+    rb_define_const(mLinenoise, "RED", INT2NUM(red));
+    rb_define_const(mLinenoise, "GREEN", INT2NUM(green));
+    rb_define_const(mLinenoise, "YELLOW", INT2NUM(yellow));
+    rb_define_const(mLinenoise, "BLUE", INT2NUM(blue));
+    rb_define_const(mLinenoise, "MAGENTA", INT2NUM(magenta));
+    rb_define_const(mLinenoise, "CYAN", INT2NUM(cyan));
+    rb_define_const(mLinenoise, "WHITE", INT2NUM(white));
 
-  /* Version string of Linenoise. */
-  rb_define_const(mLinenoise, "VERSION", rb_str_new_cstr("1.0"));
+    rb_funcall(mLinenoise, rb_intern("multiline="), 1, Qtrue);
+    rb_funcall(mLinenoise, rb_intern("hint_color="), 1, Qnil);
+    rb_funcall(mLinenoise, rb_intern("hint_bold="), 1, Qfalse);
 }

data/lib/linenoise/version.rb

@@ -1,3 +1,3 @@
 module Linenoise
-  GEM_VERSION = '1.0.0'.freeze
+  GEM_VERSION = '1.1.0'.freeze
 end

data/spec/linenoise_history_spec.rb

@@ -0,0 +1,71 @@
+RSpec.describe Linenoise::HISTORY do
+  after { subject.clear }
+
+  describe "#push" do
+    it "appends to history" do
+      subject.max_size = 3
+
+      subject << "123"
+      expect(subject.size).to eq(1)
+
+      subject.push("1", "2")
+      expect(subject.size).to eq(3)
+
+      subject.push("3", "4")
+      expect(subject.size).to eq(3)
+    end
+  end
+
+  describe "#save" do
+    let(:filename) { 'history_file' }
+
+    after { File.delete(filename) }
+
+    it "saves history" do
+      expect(File.exist?(filename)).not_to be_truthy
+      subject.save(filename)
+      expect(File.exist?(filename)).to be_truthy
+    end
+  end
+
+  describe "#load" do
+    let(:filename) { 'history_file' }
+
+    before do
+      File.open(filename, 'w+') { |f| f.puts("1\n2\n") }
+    end
+
+    after { File.delete(filename) }
+
+    it "loads history" do
+      subject.load(filename)
+      expect(subject.size).to eq(2)
+    end
+  end
+
+  describe "#[]=" do
+    before { subject.push('1', '2', '3') }
+
+    it "replaces a line in history" do
+      subject[0] = 'begin'
+      subject[-1] = 'end'
+
+      expect(subject[0]).to eq('begin')
+      expect(subject[1]).to eq('2')
+      expect(subject[2]).to eq('end')
+    end
+
+    it "raises error when index is out of boundary" do
+      expect { subject[100] = 'begin' }
+        .to raise_error(IndexError, 'invalid index')
+    end
+  end
+
+  describe "#each" do
+    before { subject.push('1', '2', '3') }
+
+    it "iterates over history lines" do
+      expect(subject.each.to_a.join).to eq('123')
+    end
+  end
+end

data/spec/linenoise_spec.rb

@@ -1,9 +1,64 @@
 RSpec.describe Linenoise do
   it "has a version number" do
-    expect(Linenoise::VERSION).not_to be_a(String)
+    expect(Linenoise::VERSION).to be_a(String)
   end
 
   it "has a gem version number" do
-    expect(Linenoise::GEM_VERSION).not_to be_a(String)
+    expect(Linenoise::GEM_VERSION).to be_a(String)
+  end
+
+  describe "#completion_proc=" do
+    it "raises error when passed value doesn't implement #call" do
+      expect { described_class.completion_proc = 1 }
+        .to raise_error(ArgumentError, "argument must respond to `call'")
+    end
+  end
+
+  describe "#hint_proc=" do
+    it "raises error when passed value doesn't implement #call" do
+      expect { described_class.hint_proc = 1 }
+        .to raise_error(ArgumentError, "argument must respond to `call'")
+    end
+  end
+
+  describe "#hint_color=" do
+    after { Linenoise.hint_color = Linenoise::DEFAULT }
+
+    it "sets hint color" do
+      Linenoise.hint_color = Linenoise::RED
+      expect(Linenoise.hint_color).to eq(Linenoise::RED)
+    end
+
+    it "raises error if color is not in range" do
+      expect { Linenoise.hint_color = -1 }
+        .to raise_error(ArgumentError, "color '-1' is not in range (31-37)")
+    end
+
+    it "raises error if color is not an integer" do
+      expect { Linenoise.hint_color = 'salamat' }
+        .to raise_error(TypeError, 'hint color is not an Integer')
+    end
+  end
+
+  describe "#hint_bold=" do
+    after { Linenoise.hint_bold = false }
+
+    it "sets hint color" do
+      Linenoise.hint_bold = true
+      expect(Linenoise.hint_bold?).to be_truthy
+    end
+  end
+
+  describe "#multiline?" do
+    after { Linenoise.multiline = true }
+
+    it "is `true` by default" do
+      expect(Linenoise).to be_multiline
+    end
+
+    it "can be set to `false`" do
+      Linenoise.multiline = false
+      expect(Linenoise).not_to be_multiline
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: linenoise
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Kyrylo Silin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-24 00:00:00.000000000 Z
+date: 2018-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 description: ''
 email:
 - silin@kyrylo.org
@@ -69,6 +97,7 @@ files:
 - ext/linenoise/linenoise.c
 - lib/linenoise.rb
 - lib/linenoise/version.rb
+- spec/linenoise_history_spec.rb
 - spec/linenoise_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/kyrylo/linenoise
@@ -99,5 +128,6 @@ signing_key:
 specification_version: 4
 summary: ''
 test_files:
+- spec/linenoise_history_spec.rb
 - spec/spec_helper.rb
 - spec/linenoise_spec.rb