gap_buffer 0.1

data/README

@@ -0,0 +1,38 @@
+Implementation of a Gap Buffer for Ruby MRI.
+  (c) 2010 Lourens Naudé (methodmissing), based off work from Hsin Tsao <stsao@lazyhacker.com>
+
+  http://github.com/methodmissing/gap_buffer
+
+How Gap Buffers work :
+
+http://en.wikipedia.org/wiki/Gap_buffer
+http://www.lazyhacker.com/gapbuffer/gapbuffer.htm
+
+This library works with Ruby 1.8 and 1.9 and exposes the following API :
+
+  gb = GapBuffer.new
+  gb.size #=> 20
+  gb.offset #=> 9
+  gb << "test"
+  gb.print #=> test_______________
+  gb.insert('b')
+  gb.offset #=> 5
+  gb.print #=> testb______________
+  gb.insert_at(6, 'u')
+  gb.print #=> testbu_____________
+  gb.previous #=> b
+  gb.next #=> u
+  gb.offset = 7
+  gb.put('f')
+  gb.print #=> testbuf____________
+
+To run the test suite:
+
+  rake
+
+Todo:
+
+  Better 1.9 compat
+  Look into moving off the C++ implementation
+
+Work in progress, thanks for watching!

data/Rakefile

@@ -0,0 +1,71 @@
+#!/usr/bin/env rake
+require 'rake/testtask'
+require 'rake/clean'
+$:.unshift(File.expand_path('lib'))
+GAP_BUFFER_ROOT = 'ext/gap_buffer'
+
+desc 'Default: test'
+task :default => :test
+
+desc 'Run gap_buffer tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs = [GAP_BUFFER_ROOT]
+  t.pattern = 'test/test_*.rb'
+  t.ruby_opts << '-rtest'
+  t.libs << 'test'
+  t.warning = true
+  t.verbose = true
+end
+task :test => :build
+
+namespace :build do
+  file "#{GAP_BUFFER_ROOT}/rubymain.cpp"
+  file "#{GAP_BUFFER_ROOT}/extconf.rb"
+  file "#{GAP_BUFFER_ROOT}/Makefile" => %W(#{GAP_BUFFER_ROOT}/rubymain.cpp #{GAP_BUFFER_ROOT}/extconf.rb) do
+    Dir.chdir(GAP_BUFFER_ROOT) do
+      ruby 'extconf.rb'
+    end
+  end
+
+  desc "generate makefile"
+  task :makefile => %W(#{GAP_BUFFER_ROOT}/Makefile #{GAP_BUFFER_ROOT}/rubymain.cpp)
+
+  dlext = Config::CONFIG['DLEXT']
+  file "#{GAP_BUFFER_ROOT}/gap_buffer.#{dlext}" => %W(#{GAP_BUFFER_ROOT}/Makefile #{GAP_BUFFER_ROOT}/rubymain.cpp) do
+    Dir.chdir(GAP_BUFFER_ROOT) do
+      sh 'make' # TODO - is there a config for which make somewhere?
+    end
+  end
+
+  desc "compile gap buffer extension"
+  task :compile => "#{GAP_BUFFER_ROOT}/gap_buffer.#{dlext}"
+
+  task :clean do
+    Dir.chdir(GAP_BUFFER_ROOT) do
+      sh 'make clean'
+    end if File.exists?("#{GAP_BUFFER_ROOT}/Makefile")
+  end
+
+  CLEAN.include("#{GAP_BUFFER_ROOT}/Makefile")
+  CLEAN.include("#{GAP_BUFFER_ROOT}/gap_buffer.#{dlext}")
+end
+
+task :clean => %w(build:clean)
+
+desc "compile"
+task :build => %w(build:compile)
+
+task :install do |t|
+  Dir.chdir(GAP_BUFFER_ROOT) do
+    sh 'sudo make install'
+  end
+end
+
+desc "clean build install"
+task :setup => %w(clean build install)
+
+desc 'Run benchmarks'
+task :bench do
+  ruby "bench/gap_buffer.rb"
+end
+task :bench => :build

data/bench/gap_buffer.rb

@@ -0,0 +1,40 @@
+$:.unshift "."
+require 'benchmark'
+require File.dirname(__FILE__) + '/../ext/gap_buffer/gap_buffer'
+
+TESTS = 1000
+ITEMS = (0..TESTS).to_a
+
+def prepare
+  string = ITEMS.join
+  gb = GapBuffer.new(TESTS)
+  gb << ITEMS.join
+  [string, gb]
+end
+
+Benchmark.bmbm do |results|
+  results.report("[String] random insert") do
+    string, gb = prepare
+    TESTS.times{ r = rand(TESTS); string[r] = r.to_s }
+  end
+  results.report("[GapBuffer] random insert") do
+    string, gb = prepare
+    TESTS.times{ r = rand(TESTS); gb.insert_at(r, r.to_s); }
+  end
+  results.report("[String] insert") do
+    string, gb = prepare
+    TESTS.times{|i| string[i] = i.to_s }
+  end
+  results.report("[GapBuffer] insert") do
+    string, gb = prepare
+    TESTS.times{|i| gb.insert_at(i, i.to_s); }
+  end
+  results.report("[String] random remove") do
+    string, gb = prepare
+    TESTS.times{ r = rand(TESTS); string.delete!(r.to_s) }
+  end
+  results.report("[GapBuffer] random remove") do
+    string, gb = prepare
+    TESTS.times{ r = rand(TESTS); gb.delete(r) }
+  end
+end

data/ext/gap_buffer/extconf.rb

@@ -0,0 +1,62 @@
+require 'mkmf'
+
+dir_config('gap_buffer')
+have_func('rb_thread_blocking_region')
+
+# Shamelessly leached from Eventmachine (https://github.com/eventmachine/eventmachine)
+
+case RUBY_PLATFORM
+when /mswin32/, /mingw32/, /bccwin32/
+  check_heads(%w[windows.h winsock.h], true)
+  check_libs(%w[kernel32 rpcrt4 gdi32], true)
+
+  if GNU_CHAIN
+    CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++"
+  else
+    $defs.push "-EHs"
+    $defs.push "-GR"
+  end
+
+when /solaris/
+  add_define 'OS_SOLARIS8'
+  check_libs(%w[nsl socket], true)
+
+  if CONFIG['CC'] == 'cc' and `cc -flags 2>&1` =~ /Sun/ # detect SUNWspro compiler
+    # SUN CHAIN
+    add_define 'CC_SUNWspro'
+    $preload = ["\nCXX = CC"] # hack a CXX= line into the makefile
+    $CFLAGS = CONFIG['CFLAGS'] = "-KPIC"
+    CONFIG['CCDLFLAGS'] = "-KPIC"
+    CONFIG['LDSHARED'] = "$(CXX) -G -KPIC -lCstd"
+  else
+    # GNU CHAIN
+    # on Unix we need a g++ link, not gcc.
+    CONFIG['LDSHARED'] = "$(CXX) -shared"
+  end
+
+when /openbsd/
+  # OpenBSD branch contributed by Guillaume Sellier.
+
+  # on Unix we need a g++ link, not gcc. On OpenBSD, linking against libstdc++ have to be explicitly done for shared libs
+  CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++ -fPIC"
+  CONFIG['LDSHAREDXX'] = "$(CXX) -shared -lstdc++ -fPIC"
+
+when /darwin/
+  # on Unix we need a g++ link, not gcc.
+  # Ff line contributed by Daniel Harple.
+  CONFIG['LDSHARED'] = "$(CXX) " + CONFIG['LDSHARED'].split[1..-1].join(' ')
+
+when /linux/
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+
+when /aix/
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared -Wl,-G"
+
+else
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+end
+
+create_makefile('gap_buffer')

data/ext/gap_buffer/gap_buffer.cpp

@@ -0,0 +1,480 @@
+/*
+ *  gap_buffer.cpp
+ * 
+ *  Author: Hsin Tsao (stsao@lazyhacker.com)
+ *  Version: 1.0 (June 12, 2003) 
+ *
+ *  This provides the implementation to the GapBuffer class defined
+ *  in text_buffer.h.
+ *
+ *  Portions of this work derived from Joseph Allen's usenet
+ *  postings on comp.editor that was released to the public
+ *  domain. 
+ * 
+ *  
+ *  There are no restrictions on the use of this code other
+ *  than to include my name in any derived work.  There are
+ *  no warranty for this obviously, but you are welcomed
+ *  to modify, correct, or adapt the code to your needs.  The
+ *  author appreciates if you are willing to submit corrections
+ *  or suggestions for improvement.
+ *  
+ *  
+ *  http://www.lazyhacker.com
+ */ 
+
+#include <iostream>
+#include <cstdlib>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include "gap_buffer.h"
+
+using namespace std;
+
+GapBuffer::GapBuffer(int gsize) : GAP_SIZE(gsize)
+{
+    InitBuffer(GAP_SIZE);
+
+}
+
+
+GapBuffer::GapBuffer(FILE *file, int gsize) : GAP_SIZE(gsize)
+{
+    
+    // determine the size of the file then create
+    // a buffer of size + GAP_SIZE
+    struct stat buf;
+    
+    fstat(fileno(file), &buf);
+    long file_size = buf.st_size;
+    InitBuffer(file_size + GAP_SIZE);    
+    MoveGapToPoint();
+    ExpandGap( (int)file_size );
+    unsigned int amount = fread(gapstart, 1, file_size, file);
+
+    gapstart += amount;
+
+
+
+}
+
+/*  Copy Constructor - Since we have pointers
+ *  as member data, we need to provide our own
+ *  copy constructor because the default will
+ *  only cause copies to all point to the same
+ *  location.
+ */
+GapBuffer::GapBuffer(const GapBuffer& tb)
+{
+     GAP_SIZE = tb.GAP_SIZE;
+     
+     buffer = (char *) malloc(tb.bufend - tb.buffer);
+     
+     strcpy(buffer, tb.buffer);
+
+     bufend = buffer + (tb.bufend - tb.buffer);
+     gapstart = buffer + (tb.gapstart - tb.buffer);
+     gapend = gapstart + (tb.gapend - tb.gapstart);
+     point = buffer + (tb.point - tb.buffer);
+    
+}
+
+
+GapBuffer::~GapBuffer()
+{
+
+    if (buffer) {
+        free(buffer);
+    }
+
+}
+
+/*
+ * Copy the characters from one location to another.  We have
+ * to write our own instead of using memcopy because we are
+ * working within a single linear buffer and thus can have
+ * overlap between the source and destination.
+ */
+int GapBuffer::CopyBytes(char *destination, char *source, unsigned int length)
+{
+
+    if ( (destination == source) || (length == 0) ) {
+        return 1;
+    }
+
+    // if we're moving the character toward the front of the buffer
+    if (source > destination) {
+
+        // check to make sure that we don't go beyond the buffer
+        if ( (source + length) >= bufend ) {
+            return 0;
+        }
+
+        for (; length > 0; length--) {
+            *(destination++) = *(source++);
+        }
+
+    } else {
+
+        // To prevent overwriting characters we still
+        // need to move, go to the back and copy forward.
+        source += length;
+        destination += length;
+
+        for (; length > 0; length--) {
+            // decrement first 'cause we start one byte beyond where we want
+            *(--destination) = *(--source); 
+        }
+    }
+
+    return 1;
+
+}
+
+/*
+ *  Expand the buffer to new size + GAP_SIZE.
+ *  
+ */
+void GapBuffer::ExpandBuffer(unsigned int size)
+{   
+
+    // Check to see that we actually need to increase the buffer
+    // since BufferSize doesn't include the gap.
+    if ( ( (bufend - buffer) + size) > BufferSize() ) {
+
+        char *origbuffer = buffer;
+
+        int NewBufferSize = (bufend - buffer) + size  + GAP_SIZE;
+        
+        buffer = (char *) realloc(buffer, NewBufferSize);
+
+        point += buffer - origbuffer;
+        bufend += buffer - origbuffer;
+        gapstart += buffer - origbuffer;
+        gapend += buffer - origbuffer;
+    }
+
+}
+
+/*
+ * Move the gap to the current position of the point.
+ * The point should end in same location as gapstart.
+ */
+void GapBuffer::MoveGapToPoint()
+{
+
+
+    if (point == gapstart) {
+        return;
+    }
+
+    if (point == gapend) {
+        point = gapstart;
+        return;
+    }
+
+    // Move gap towards the left 
+    if (point < gapstart) {
+        // Move the point over by gapsize.        
+        CopyBytes(point + (gapend-gapstart), point, gapstart - point);
+        gapend -= (gapstart - point);
+        gapstart = point;
+    } else {
+        // Since point is after the gap, find distance
+        // between gapend and point and that's how
+        // much we move from gapend to gapstart.
+        CopyBytes(gapstart, gapend, point - gapend);
+        gapstart += point - gapend;
+        gapend = point;
+        point = gapstart;
+    }
+}
+
+/*
+ *  Expand the size of the gap.  If the required
+ *  size is less then the current gap size, do
+ *  nothing.  If the size is greater than the 
+ *  current size, increase the gap to the default
+ *  gap size + size.
+ */
+void GapBuffer::ExpandGap(unsigned int size)
+{
+
+
+    if (size > SizeOfGap()) {
+        size += GAP_SIZE;
+        ExpandBuffer(size);
+        CopyBytes(gapend+size, gapend, bufend - gapend);
+
+        gapend += size;
+        bufend += size;
+    }
+
+}
+
+/*
+ *  Set point to offset from start of buffer.
+ */
+void GapBuffer::SetPoint(unsigned int offset)
+{
+
+    point = buffer + offset;
+
+    if (point > gapstart) {
+        point += gapend - gapstart;
+    }
+
+}
+
+/*
+ *  Returns the current size of the gap.
+ */
+int GapBuffer::SizeOfGap()
+{
+    return gapend - gapstart;
+
+}
+
+/*
+ *  Returns offset from point to start of buffer.
+ */
+unsigned int GapBuffer::PointOffset()
+{
+
+    if (point > gapend) {
+        return ((point - buffer) - (gapend - gapstart));
+    } else {
+        return (point - buffer);
+    }
+}
+
+/*
+ * Return character that point is pointing to.
+ * If point is inside the gap, then return the
+ * the first character outside the gap.
+ */
+char GapBuffer::GetChar()
+{
+
+    // If the point is anywhere in the gap, then
+    // it should always be at the start of the gap.
+    if (point == gapstart) {
+        point = gapend;
+    }
+
+    return *point;
+}
+
+/*
+ * Return the previous character and
+ * move point back one position.
+ */
+char GapBuffer::PreviousChar()
+{
+    
+    if (point == gapend) {
+        point = gapstart;
+    }
+
+    return *(--point);
+}
+
+/*
+ * Replace the character of point.
+ */
+void GapBuffer::ReplaceChar(char ch)
+{
+
+    // Since we're just replacing the current character,
+    // we don't need to move or modify the gap.
+    if (point == gapstart) {
+        point = gapend;
+    }
+
+    if (point == bufend) {
+        ExpandBuffer(1);
+        bufend++;
+    }
+
+    *point = ch;
+}
+
+/*
+ * Increment pointer.  Returns next character.
+ */
+char GapBuffer::NextChar()
+{   
+    // point should not be in the gap.
+    if (point == gapstart) {
+        point = gapend;
+        return *point;
+    } 
+
+    return *(++point);    
+
+}
+
+void GapBuffer::PutChar(char ch)
+{
+    InsertChar(ch);
+    *point++;
+
+}
+
+/*
+ *  Insert character at point position.  Note
+ *  that repeatedly calling this function will
+ *  keep calling MoveGapToPoint since this function
+ *  doesn't advance the point.  The result is the
+ *  text appears reverse of key strokes.
+ */
+void GapBuffer::InsertChar(char ch)
+{
+    // Here we do need to move the gap if the point
+    // is not already at the start of the gap.
+
+    if (point != gapstart) {
+        MoveGapToPoint();
+    }
+
+    // check to make sure that the gap has room
+    if (gapstart == gapend) {
+        ExpandGap(1);
+    }
+
+    *(gapstart++) = ch;
+
+}
+
+/*
+ *  Delete "size" number of characters.
+ */
+void GapBuffer::DeleteChars(unsigned int size)
+{
+
+    if (point != gapstart) {
+        MoveGapToPoint();
+    }
+
+    // We shifted the gap so that gapend points to the location
+    // where we want to start deleting so extend it 
+    // to cover all the characters.
+    gapend += size;
+}
+
+void GapBuffer::InsertString(char *string, unsigned int length)
+{
+
+    MoveGapToPoint();
+
+    if (length > SizeOfGap()) {
+        ExpandGap(length);
+    }
+
+    do {
+        PutChar(*(string++));
+    } while ( length-- );
+}
+
+/*
+ * Here we initilize the buffer and set
+ * the pointers to the correct position.
+ */
+int GapBuffer::InitBuffer(unsigned int size)
+{
+
+/*
+   if (buffer) {
+        free(buffer);
+    }
+*/
+    buffer = NULL;
+    buffer = (char *) malloc(size);
+
+    if (!buffer) {
+        return 0;
+    }
+
+    point = buffer;
+    gapstart = buffer;
+    
+    // initially gapend is outside of buffer
+    gapend = buffer + size;     
+    bufend = gapend;
+
+    return 1;
+
+}
+
+int GapBuffer::BufferSize()
+{
+    return (bufend - buffer) - (gapend - gapstart);
+}
+
+char* GapBuffer::GetBuffer()
+{
+    return buffer;
+}
+
+void GapBuffer::PrintBuffer()
+{
+    /*
+    char ch;
+
+    cout << "Printing the buffer: " << endl;
+    SetPoint(0);
+    while (point < bufend) {
+        cout << GetCharMovePoint();        
+    }
+
+    cout << "Printing the buffer in reverse: " << endl;
+
+    while (point >= buffer) {
+        cout << GetPrevCharMovePoint();
+    }
+    */
+
+    char *temp = buffer;
+
+
+    while (temp < bufend) {
+
+        if ( (temp >= gapstart) && (temp < gapend) ) {
+            cout << "_";
+            temp++;
+        } else {
+            cout << *(temp++);
+        }
+
+    }
+    cout << endl;
+}
+
+int GapBuffer::SaveBufferToFile(FILE *file, unsigned int bytes)
+{
+
+    if (!bytes) {
+        return 1;
+    }
+
+    if (point == gapstart) {
+        point = gapend;
+    }
+
+    if ( (gapstart > point) && (gapstart < (point + bytes)) && (gapstart != gapend) ) {
+        if ( gapstart - point != fwrite(point, 1, gapstart-point, file) ) {
+            return 0;
+        }
+
+        if ( (bytes - (gapstart - point)) != fwrite(gapend, 1, bytes-(gapstart - point), file) ) {
+            return 1;
+        }
+
+        return 1;
+    } else {
+        return bytes == fwrite(point, 1, bytes, file);
+    }
+
+
+}

data/ext/gap_buffer/gap_buffer.h

@@ -0,0 +1,159 @@
+/*
+ *  gap_buffer.h
+ *
+ *  Author: Hsin Tsao (stsao@lazyhacker.com)
+ *  Version: 1.0 (June 12, 2003)
+ *
+ *  A text buffer class using the buffer-gap technique for managing
+ *  the text stored in the buffer.
+ *
+ *  Portions of this work derived from Joseph Allen's usenet
+ *  postings on comp.editor that was released to the public
+ *  domain.
+ *
+ *
+ *  There are no restrictions on the use of this code other
+ *  than to include my name in any derived work.  There are
+ *  no warranty for this obviously, but you are welcomed
+ *  to modify, correct, or adapt the code to your needs.  The
+ *  author appreciates if you are willing to submit corrections
+ *  or suggestions for improvement.
+ *  
+ *
+ *  http://www.lazyhacker.com
+ */
+
+#include <stdio.h>
+
+class GapBuffer {
+
+    char *point;                    // location pointer into buffer
+    char *buffer;                   // start of text buffer
+    char *bufend;                   // first location outside buffer
+    char *gapstart;                 // start of gap
+    char *gapend;                   // first location after end of gap
+    
+    unsigned int GAP_SIZE;          // expand GAP by this value
+
+    int InitBuffer(unsigned int size);
+
+    /*
+     * Copy the characters from one location to another.  We have
+     * to write our own instead of using memcopy because we are
+     * working within a single linear buffer and thus can have
+     * overlap between the source and destination.
+     */
+    int CopyBytes(char *destination, char *source, unsigned int length);
+
+    /*
+     *  Expand the size of the buffer.
+     */
+    void ExpandBuffer(unsigned int size);
+
+    /*
+     *  Expand the size of the gap.
+     */
+    void ExpandGap(unsigned int size);
+    
+public:
+
+    static const int DEFAULT_GAP_SIZE=20;
+
+    /* Constructor with default gap size. */
+    GapBuffer(int gsize=DEFAULT_GAP_SIZE);
+
+    /* Constructor with instantiating with an existing file. */
+    GapBuffer(FILE *file, int gsize=DEFAULT_GAP_SIZE);
+
+    /* Copy constructor to deal with our pointer members. */
+    GapBuffer(const GapBuffer& tb);
+
+    ~GapBuffer();    
+
+    /*
+     *  Returns the size of the buffer minus the gap.
+     */
+    int BufferSize();
+
+    /*
+     *  Move the gap to the current position of the point.
+     */
+    void MoveGapToPoint();
+
+    /*
+     *  Set point to offset from start of buffer.
+     */
+    void SetPoint(unsigned int offset);
+
+    /*
+     *  Returns the current size of the gap.
+     */
+    int SizeOfGap();    
+
+    /*
+     *  Returns offset from point to start of buffer.
+     */
+    unsigned int PointOffset();
+
+    /*
+     * Return character that point is pointing to.
+     * If point is inside the gap, then return the
+     * the first character outside the gap.
+     */
+    char GetChar();
+
+    /*
+     * Return the previous character and
+     * move point back one position.
+     */
+    char PreviousChar();
+
+    /*
+     *  Replace the character of point. Does
+     *  not move the gap.
+     */
+    void ReplaceChar(char ch);
+
+    /*
+     *  Get the next character and increment point.
+     */
+    char NextChar();
+
+    /*
+     *  Inserts a character at point location
+     *  and advance the point.
+     */
+    void PutChar(char ch);
+
+    /*
+     *  Insert character at point position, but
+     *  does NOT advance the point.
+     */
+    void InsertChar(char ch);
+
+    /*
+     *  Delete "size" number of characters.
+     */
+    void DeleteChars(unsigned int size);
+
+    /*
+     *  Inserts a length size string 
+     *  at point.
+     */
+    void InsertString(char *string, unsigned int length);
+
+    /*
+     *  Prints out the current buffer from start
+     *  to end.
+     */
+    void PrintBuffer();
+
+    /*
+     * Saves to file the number of bytes starting from
+     * the point.
+     */
+    int SaveBufferToFile(FILE *file, unsigned int bytes);
+
+    char *GetBuffer();
+    
+};

data/ext/gap_buffer/rubymain.cpp

@@ -0,0 +1,191 @@
+#include "gap_buffer.h"
+#include <ruby.h>
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(obj) RSTRING(obj)->ptr
+#endif
+ 
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(obj) RSTRING(obj)->len
+#endif
+
+#define GetGapBuffer(obj) \
+    GapBuffer *gb = NULL; \
+    Data_Get_Struct((obj), GapBuffer, gb); \
+    if (!gb) \
+        rb_raise(rb_eException, "No gap buffer!");
+
+#define GapBufferChar(chr) \
+    char c = (chr); \
+    if (c == 0) return rb_str_tmp_new(0); \
+    return rb_str_new(&c, 1);
+
+VALUE rb_cGapBuffer;
+
+static void rb_gap_buffer_free(void *gb)
+{
+    if(gb) delete((GapBuffer*) gb);
+}
+
+static VALUE rb_gap_buffer_new(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE size;
+    rb_scan_args(argc, argv, "01", &size);
+    if (NIL_P(size)) size = rb_const_get(rb_cGapBuffer, rb_intern("GAP_SIZE"));
+    GapBuffer *gb = NULL;
+    gb = new GapBuffer(NUM2INT(size));
+    if (!gb)
+       rb_raise(rb_eException, "No gap buffer!");
+    return Data_Wrap_Struct(rb_cGapBuffer, 0, rb_gap_buffer_free, (void*)gb);
+}
+
+static VALUE rb_gap_buffer_size(VALUE obj)
+{
+    GetGapBuffer(obj);
+    return INT2FIX(gb->BufferSize());
+}
+
+static VALUE rb_gap_buffer_gap_size(VALUE obj)
+{
+    GetGapBuffer(obj);
+    return INT2FIX(gb->SizeOfGap());
+}
+
+static VALUE rb_gap_buffer_print(VALUE obj)
+{
+    GetGapBuffer(obj);
+    gb->PrintBuffer();
+    return Qnil;
+}
+
+static VALUE rb_gap_buffer_append(VALUE obj, VALUE str)
+{
+    GetGapBuffer(obj);
+    Check_Type(str, T_STRING);
+    gb->InsertString(RSTRING_PTR(str), (unsigned int)RSTRING_LEN(str));
+    return obj;
+}
+
+static VALUE rb_gap_buffer_offset(VALUE obj)
+{
+    GetGapBuffer(obj);
+    return INT2FIX(gb->PointOffset());
+}
+
+static VALUE rb_gap_buffer_offset_equals(VALUE obj, VALUE offset)
+{
+    GetGapBuffer(obj);
+    gb->SetPoint(FIX2INT(offset));
+    return offset;
+}
+
+static VALUE rb_gap_buffer_move(VALUE obj)
+{
+    GetGapBuffer(obj);
+    gb->MoveGapToPoint();
+    return rb_gap_buffer_offset(obj);
+}
+
+static VALUE rb_gap_buffer_get(VALUE obj)
+{
+    GetGapBuffer(obj);
+    GapBufferChar(gb->GetChar());
+}
+
+static VALUE rb_gap_buffer_previous(VALUE obj)
+{
+    GetGapBuffer(obj);
+    GapBufferChar(gb->PreviousChar());
+}
+
+static VALUE rb_gap_buffer_next(VALUE obj)
+{
+    GetGapBuffer(obj);
+    GapBufferChar(gb->NextChar());
+}
+
+static VALUE rb_gap_buffer_replace(VALUE obj, VALUE str)
+{
+    GetGapBuffer(obj);
+    Check_Type(str, T_STRING);
+    char c = *RSTRING_PTR(str);
+    gb->ReplaceChar(c);
+    return Qnil;
+}
+
+static VALUE rb_gap_buffer_put(VALUE obj, VALUE str)
+{
+    GetGapBuffer(obj);
+    Check_Type(str, T_STRING);
+    char c = *RSTRING_PTR(str);
+    gb->PutChar(c);
+    return Qnil;
+}
+
+static VALUE rb_gap_buffer_insert(VALUE obj, VALUE str)
+{
+    GetGapBuffer(obj);
+    Check_Type(str, T_STRING);
+    char c = *RSTRING_PTR(str);
+    gb->InsertChar(c);
+    return Qnil;
+}
+
+static VALUE rb_gap_buffer_delete(VALUE obj, VALUE size)
+{
+    GetGapBuffer(obj);
+    gb->DeleteChars(FIX2INT(size));
+    return Qnil;
+}
+
+static VALUE rb_gap_buffer_to_s(VALUE obj, VALUE size)
+{
+    GetGapBuffer(obj);
+    return(rb_str_new2(gb->GetBuffer()));
+}
+
+static VALUE rb_gap_buffer_insert_at(VALUE obj, VALUE offset, VALUE str)
+{
+    GetGapBuffer(obj);
+    Check_Type(str, T_STRING);
+    char c = *RSTRING_PTR(str);
+    gb->SetPoint(FIX2INT(offset));
+    gb->InsertChar(c);
+    return Qnil;
+}
+
+static VALUE rb_gap_buffer_delete_at(VALUE obj, VALUE offset)
+{
+    GetGapBuffer(obj);
+    gb->SetPoint(FIX2INT(offset));
+    gb->DeleteChars(1);
+    return Qnil;
+}
+
+extern "C" void Init_gap_buffer()
+{
+    rb_cGapBuffer = rb_define_class("GapBuffer", rb_cObject);
+    rb_define_const(rb_cGapBuffer, "GAP_SIZE", INT2NUM(20));
+
+    rb_define_module_function(rb_cGapBuffer, "new", (VALUE(*)(...))rb_gap_buffer_new, -1);
+    rb_define_method(rb_cGapBuffer, "size", (VALUE(*)(...))rb_gap_buffer_size, 0);
+    rb_define_method(rb_cGapBuffer, "gap_size", (VALUE(*)(...))rb_gap_buffer_gap_size, 0);
+    rb_define_method(rb_cGapBuffer, "print", (VALUE(*)(...))rb_gap_buffer_print, 0);
+    rb_define_method(rb_cGapBuffer, "<<", (VALUE(*)(...))rb_gap_buffer_append, 1);
+    rb_define_method(rb_cGapBuffer, "offset", (VALUE(*)(...))rb_gap_buffer_offset, 0);
+    rb_define_method(rb_cGapBuffer, "position", (VALUE(*)(...))rb_gap_buffer_offset, 0);
+    rb_define_method(rb_cGapBuffer, "offset=", (VALUE(*)(...))rb_gap_buffer_offset_equals, 1);
+    rb_define_method(rb_cGapBuffer, "position=", (VALUE(*)(...))rb_gap_buffer_offset_equals, 1);
+    rb_define_method(rb_cGapBuffer, "move", (VALUE(*)(...))rb_gap_buffer_move, 0);
+    rb_define_method(rb_cGapBuffer, "get", (VALUE(*)(...))rb_gap_buffer_get, 0);
+    rb_define_method(rb_cGapBuffer, "previous", (VALUE(*)(...))rb_gap_buffer_previous, 0);
+    rb_define_method(rb_cGapBuffer, "next", (VALUE(*)(...))rb_gap_buffer_next, 0);
+    rb_define_method(rb_cGapBuffer, "replace", (VALUE(*)(...))rb_gap_buffer_replace, 1);
+    rb_define_method(rb_cGapBuffer, "put", (VALUE(*)(...))rb_gap_buffer_put, 1);
+    rb_define_method(rb_cGapBuffer, "insert", (VALUE(*)(...))rb_gap_buffer_insert, 1);
+    rb_define_method(rb_cGapBuffer, "delete", (VALUE(*)(...))rb_gap_buffer_delete, 1);
+    rb_define_method(rb_cGapBuffer, "to_s", (VALUE(*)(...))rb_gap_buffer_to_s, 0);
+    rb_define_method(rb_cGapBuffer, "to_str", (VALUE(*)(...))rb_gap_buffer_to_s, 0);
+    rb_define_method(rb_cGapBuffer, "insert_at", (VALUE(*)(...))rb_gap_buffer_insert_at, 2);
+    rb_define_method(rb_cGapBuffer, "delete_at", (VALUE(*)(...))rb_gap_buffer_delete_at, 1);
+}

data/gap_buffer.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = 'gap_buffer'
+  s.version = '0.1'
+  s.date = '2010-10-25'
+  s.authors = ['Lourens Naudé', 'Hsin Tsao']
+  s.email = ['lourens@methodmissing.com', 'stsao@lazyhacker.com']
+  s.description = 'WIP implementation of a Gap Buffer for Ruby MRI.'
+  s.homepage = 'http://github.com/methodmissing/gap_buffer'
+  s.summary = 'WIP implementation of a Gap Buffer for Ruby MRI.'
+  s.extensions = 'ext/gap_buffer/extconf.rb'
+  s.files = Dir.glob("{ext,test,bench}/**/*") + %w[README Rakefile gap_buffer.gemspec]
+  s.has_rdoc = true
+  s.extra_rdoc_files = Dir['ext/gap_buffer/*.c']
+end

data/test/test.rb

@@ -0,0 +1,3 @@
+$:.unshift "."
+require 'ext/gap_buffer/gap_buffer'
+require 'test/unit'

data/test/test_gap_buffer.rb

@@ -0,0 +1,140 @@
+class TestGapBuffer < Test::Unit::TestCase
+  def test_initialize
+    assert_equal 20, GapBuffer::GAP_SIZE
+    assert_instance_of GapBuffer, GapBuffer.new(10)
+    assert_equal 10, GapBuffer.new(10).gap_size
+    assert_equal 20, GapBuffer.new.gap_size
+  end
+
+  def test_size
+    gb = GapBuffer.new
+    assert_equal 0, gb.size
+  end
+
+  def test_gap_size
+    gb = GapBuffer.new
+    assert_equal 20, gb.gap_size
+  end
+
+  def test_print
+    gb = GapBuffer.new
+    gb.print
+  end
+
+  def test_append
+    gb = GapBuffer.new
+    gb << 'test'
+    assert_equal 'test', gb.to_s
+    assert_equal 5, gb.offset
+  end
+
+  def test_offset
+    gb = GapBuffer.new
+    assert_equal 0, gb.offset
+    gb << 'test'
+    assert_equal 5, gb.offset
+    gb << 'buffer'
+    assert_equal 12, gb.offset
+  end
+
+  def test_offset_equals
+    gb = GapBuffer.new
+    assert_equal 0, gb.offset
+    gb.offset = 5
+    assert_equal 5, gb.offset
+  end
+
+  def test_move
+    gb = GapBuffer.new
+    assert_equal 0, gb.offset
+    gb.offset = 5
+    gb.move
+  end
+
+  def test_get
+    gb = GapBuffer.new
+    gb << 'test'
+    gb.offset = 2
+    assert_equal 's', gb.get
+    assert_equal 2, gb.offset
+  end
+
+  def test_previous
+    gb = GapBuffer.new
+    gb << 'test'
+    assert_equal '', gb.previous
+    gb.offset = 2
+    assert_equal 'e', gb.previous
+    assert_equal 1, gb.offset
+  end
+
+  def test_next
+    gb = GapBuffer.new
+    gb << 'test'
+    assert_equal '', gb.previous
+    gb.offset = 2
+    assert_equal 't', gb.next
+    assert_equal 3, gb.offset
+  end
+
+  def test_delete
+    gb = GapBuffer.new
+    gb << 'test'
+    assert_equal '', gb.previous
+    gb.offset = 2
+    gb.delete(2)
+    assert_equal 'test', gb.to_s
+  end
+
+  def test_to_s
+    gb = GapBuffer.new
+    gb << 'test'
+    assert_equal 'test', gb.to_s
+  end
+
+  def test_replace
+    gb = GapBuffer.new
+    gb << 'test'
+    gb.offset = 2
+    gb.replace('x')
+    assert_equal 'text', gb.to_s
+  end
+
+  def test_insert
+    gb = GapBuffer.new
+    gb << 'test'
+    gb.offset = 2
+    gb.insert('x')
+    assert_equal 'text', gb.to_s
+    gb.insert('zz')
+    assert_equal 'tezt', gb.to_s
+  end
+
+  def test_insert_at
+    gb = GapBuffer.new
+    gb << 'test'
+    gb.insert_at(2, 'x')
+    assert_equal 'text', gb.to_s
+    gb.insert_at(3, 'z')
+    assert_equal 'texz', gb.to_s
+  end
+
+  def test_delete_at
+    gb = GapBuffer.new
+    gb << 'test'
+    gb.insert_at(2, 'x')
+    assert_equal 'text', gb.to_s
+    gb.delete_at(2)
+    assert_equal 'text', gb.to_s
+  end
+
+  def test_put
+    gb = GapBuffer.new
+    gb << 'test'
+    gb.offset = 2
+    gb.put('x')
+    assert_equal 'text', gb.to_s
+    gb.put('zzzzz')
+    assert_equal 'texz', gb.to_s
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: gap_buffer
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- "Lourens Naud\xC3\xA9"
+- Hsin Tsao
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-25 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: WIP implementation of a Gap Buffer for Ruby MRI.
+email: 
+- lourens@methodmissing.com
+- stsao@lazyhacker.com
+executables: []
+
+extensions: 
+- ext/gap_buffer/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- ext/gap_buffer/extconf.rb
+- ext/gap_buffer/gap_buffer.cpp
+- ext/gap_buffer/gap_buffer.h
+- ext/gap_buffer/rubymain.cpp
+- test/test.rb
+- test/test_gap_buffer.rb
+- bench/gap_buffer.rb
+- README
+- Rakefile
+- gap_buffer.gemspec
+has_rdoc: true
+homepage: http://github.com/methodmissing/gap_buffer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: WIP implementation of a Gap Buffer for Ruby MRI.
+test_files: []
+