lulu 0.0.2

data/README.md

@@ -0,0 +1,91 @@
+# Lulu
+
+Lulu - A ruby gem for merging map markers by agglomerative clustering.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lulu'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lulu
+
+## Usage
+
+    require 'lulu'
+
+    # Make an empty marker list
+    list = Lulu::MarkerList.new
+
+    # Add some markers.  It's list.add(x, y, size). The size is actually area.
+    10000.times{ |n| list.add(Random.rand(1000), Random.rand(1000), Random.rand(100)) }
+
+    # Get the list length.
+    p list.length  # Produces 10000
+
+    # Optionally set merge parameters. Marker calculations can assume circular or
+    # square markers, and a scale factor may be set. The scale factor is applied
+    # to marker radii so that the marker size exists in a different coordinate
+    # space from the inter-marker distances.  This makes sense, for example, if
+    # the marker coordinates are pixels on a map. A pixel on the map represents
+    # distance, a pixel in a marker something else.  Returns self.
+    list.set_info(:circle, 1)
+
+    # Merge the markers.  Pairs that are merged are deleted and replaced by a
+    # fresh marker added to the list. If the original list has N, this can
+    # result in 2N-1 markers in the result.  Subsequent merges will remove
+    # all deleted markers from previous merges. This is called compression.
+    # See below.  Returns list.length.
+    list.merge
+
+    # Get the list length again.  If markers were merged, the list grew.
+    p list.length  # Produces 10415
+
+    # Squeeze out deleted markers, i.e. ones that have been merged to form
+    # new ones. All remaining nodes are marked :single (see method parts below)
+    # Returns list.length
+    list.compress
+
+    # Merge after compress is idempotent.
+    list.merge  # doesn't change list
+
+    # Get the marker at index 1000.  This is a list [x, y, size].
+    # If the index is out of range, nil is returned.
+    p list.marker(1000)  # Produces [748.0, 187.0, 80.0]
+
+    # Get whether the marker at index 100 was deleted during a merge.
+    p list.deleted(100) # returns true
+
+    # Print the list of all undeleted markers
+    p list.markers # Produces [[601.0, 715.0, 38.0]...[647.3314285714285, 179.19619047619048, 1050.0]]
+
+    # Clear the list, returning it to the empty state.  Returns self.
+    list.clear
+
+    # For a given marker index, get the two indices of the markers (its _parts_)
+    # that were merged to create it, if any.
+    list.parts(5324)
+    # For the marker with index 5324, returns
+    # [:root, i, j] if it is the undeleted result of a merge of markers i and j
+    # [:merge, i, j] if it is the subsequently deleted result of a merge of markers i and j
+    # [:single] if it is an undeleted original node
+    # [:leaf] if ti is a deleted original node
+    # nil if 5324 is out of range
+
+The method `parts` is sufficient to walk the tree of all nodes formed by merging.
+In this manner, a parallel array of attribute information can be merged to match
+so that merged attributes are available for each `:root`.
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/lulu/fork )
+2. Create your feature branch (`git checkout -b my-new-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

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'rake/extensiontask'
+
+RSpec::Core::RakeTask.new
+
+# Rake compiler's standard doesn't match the Ruby Guides
+# http://guides.rubygems.org/gems-with-extensions/. So we need this.
+Rake::ExtensionTask.new do |ext|
+  ext.name = 'lulu'
+  ext.ext_dir = 'ext/lulu'
+  ext.lib_dir = 'lib/lulu'
+end
+
+task :default => :spec
+task :test => :spec

data/ext/lulu/Makefile

@@ -0,0 +1,220 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+n=$(NULLCMD)
+ECHO1 = $(V:1=@$n)
+ECHO = $(ECHO1:0=@echo)
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/local/rvm/rubies/ruby-1.9.3-p484/include/ruby-1.9.1
+hdrdir = /usr/local/rvm/rubies/ruby-1.9.3-p484/include/ruby-1.9.1
+arch_hdrdir = /usr/local/rvm/rubies/ruby-1.9.3-p484/include/ruby-1.9.1/$(arch)
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/usr/local/rvm/rubies/ruby-1.9.3-p484
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_BASE_NAME)-$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitedir = $(rubylibprefix)/site_ruby
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+archdir = $(rubylibdir)/$(arch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitearchdir = $(sitelibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+
+NULLCMD = :
+
+CC = /usr/local/opt/apple-gcc42/bin/gcc-4.2
+CXX = g++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   =  $(optflags) $(debugflags) $(warnflags)
+optflags = -O3
+debugflags = -ggdb
+warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wshorten-64-to-32 -Wimplicit-function-declaration
+CFLAGS   = -fno-common $(cflags)  -fno-common -pipe -std=c99 -Wno-declaration-after-statement $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =  -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags) -I/usr/local/opt/libyaml/include -I/usr/local/opt/readline/include -I/usr/local/opt/libksba/include -I/usr/local/opt/openssl/include
+CXXFLAGS = $(CFLAGS) $(cxxflags)
+ldflags  = -L. -L/usr/local/lib -L/usr/local/opt/libyaml/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/openssl/lib 
+dldflags = -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress -Wl,-flat_namespace -L/usr/local/opt/libyaml/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/openssl/lib  
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -dynamic -bundle
+LDSHAREDXX = $(CXX) -dynamic -bundle
+AR = ar
+EXEEXT = 
+
+RUBY_BASE_NAME = ruby
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby.1.9.1
+arch = x86_64-darwin13.0.0
+sitearch = $(arch)
+ruby_version = 1.9.1
+ruby = /usr/local/rvm/rubies/ruby-1.9.3-p484/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir -p
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir) /usr/local/opt/libyaml/lib /usr/local/opt/readline/lib /usr/local/opt/libksba/lib /usr/local/opt/openssl/lib
+LIBPATH =  -L. -L$(libdir) -L/usr/local/opt/libyaml/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/openssl/lib
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = /lulu
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lobjc 
+SRCS = lulu.c marker.c merger.c pq.c qt.c test.c utility.c
+OBJS = lulu.o marker.o merger.o pq.o qt.o test.o utility.o
+TARGET = lulu
+TARGET_NAME = lulu
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean: clean distclean-so distclean-rb-default distclean-rb
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		@-$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	-$(Q)$(MAKEDIRS) $(@D)
+	$(INSTALL_PROG) $(DLLIB) $(@D)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+pre-install-rb-default:
+	$(ECHO) installing default lulu libraries
+./.RUBYARCHDIR.time:
+	$(Q) $(MAKEDIRS) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .C .o
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.C.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	$(ECHO) linking shared-object lulu/$(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): $(hdrdir)/ruby.h $(hdrdir)/ruby/defines.h $(arch_hdrdir)/ruby/config.h

data/ext/lulu/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+# Turn off warnings about declarations mixed with code.
+$CFLAGS += ' -std=c99 -Wno-declaration-after-statement'
+
+create_makefile('lulu/lulu')

data/ext/lulu/lulu.c

@@ -0,0 +1,271 @@
+/*
+ ============================================================================
+ Name        : lulu.c
+ Author      : Eugene K. Ressler
+ Version     : 0.1
+ Copyright   : GPLv3
+ Description : The Lulu gem for merging map markers.
+ ============================================================================
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "ruby.h"
+#include "utility.h"
+#include "marker.h"
+#include "merger.h"
+#include "pq.h"
+#include "qt.h"
+
+static char EXT_VERSION[] = "0.1.2";
+
+// -------- C marker list to be wrapped in a Ruby object -----------------------
+
+typedef struct marker_list_s {
+    MARKER_INFO info[1];
+    MARKER *markers;
+    int size, max_size;
+} MARKER_LIST;
+
+#define MARKER_LIST_DECL(Name)  MARKER_LIST Name[1]; init_marker_list(Name)
+#define ml_set_marker_list_info(L, Kind, Scale)  mr_info_set((L)->info, (Kind), (Scale))
+
+void init_marker_list(MARKER_LIST *list) {
+    mr_info_init(list->info);
+    list->markers = NULL;
+    list->size = list->max_size = 0;
+}
+
+MARKER_LIST *new_marker_list(void) {
+    NewDecl(MARKER_LIST, list);
+    init_marker_list(list);
+    return list;
+}
+
+void clear_marker_list(MARKER_LIST *list) {
+    Free(list->markers);
+    init_marker_list(list);
+}
+
+void free_marker_list(MARKER_LIST *list) {
+    clear_marker_list(list);
+    Free(list);
+}
+
+void add_marker(MARKER_LIST *list, COORD x, COORD y, SIZE size) {
+    if (list->size >= list->max_size) {
+        list->max_size = 4 + 2 * list->max_size;
+        RenewArray(list->markers, list->max_size);
+    }
+    MARKER *marker = list->markers + list->size++;
+    mr_set(list->info, marker, x, y, size);
+}
+
+void ensure_headroom(MARKER_LIST *list) {
+    int needed_size = 2 * list->size - 1;
+    if (list->max_size < needed_size) {
+        list->max_size = needed_size;
+        RenewArray(list->markers, list->max_size);
+    }
+}
+
+void compress(MARKER_LIST *list) {
+    int dst = 0;
+    for (int src = 0; src < list->size; src++)
+        if (!mr_deleted_p(list->markers + src)) {
+            if (src != dst)
+                list->markers[dst] = list->markers[src];
+            mr_reset_parts(list->markers + dst);
+            dst++;
+        }
+    list->size = dst;
+}
+
+// -------- Ruby API implementation --------------------------------------------
+
+static void rb_api_free_marker_list(void *list) {
+	free_marker_list(list);
+}
+
+static VALUE rb_api_new_marker_list(VALUE klass) {
+	MARKER_LIST *list = new_marker_list();
+	return Data_Wrap_Struct(klass, 0, rb_api_free_marker_list, list);
+}
+
+#define MARKER_LIST_FOR_VALUE_DECL(Var) MARKER_LIST *Var; Data_Get_Struct(Var ## _value, MARKER_LIST, Var)
+
+static VALUE rb_api_initialize_copy(VALUE dst_value, VALUE src_value)
+#define ARGC_initialize_copy 1
+{
+    if (dst_value == src_value)
+        return src_value;
+
+    if (TYPE(src_value) != T_DATA || RDATA(src_value)->dfree != (RUBY_DATA_FUNC)rb_api_free_marker_list)
+        rb_raise(rb_eTypeError, "type mismatch (copy_marker_list)");
+
+    MARKER_LIST_FOR_VALUE_DECL(src);
+    MARKER_LIST_FOR_VALUE_DECL(dst);
+
+    // Shallow copy contents, then deep copy array of markers.
+    *dst = *src;
+    NewArray(dst->markers, dst->max_size);
+    CopyArray(dst->markers, src->markers, dst->max_size);
+
+    return dst_value;
+}
+
+static VALUE rb_api_clear(VALUE self_value)
+#define ARGC_clear 0
+{
+    MARKER_LIST_FOR_VALUE_DECL(self);
+    clear_marker_list(self);
+    return self_value;
+}
+
+static VALUE rb_api_set_info(VALUE self_value, VALUE kind_value, VALUE scale_value)
+#define ARGC_set_info 2
+{
+    MARKER_LIST_FOR_VALUE_DECL(self);
+
+    // Get the valid symbol values.
+    VALUE square_sym = ID2SYM(rb_intern("square"));
+    VALUE circle_sym = ID2SYM(rb_intern("circle"));
+
+    // Try to convert the kind into a symbol.  This could cause an exception.
+    VALUE kind_as_sym = rb_funcall(kind_value, rb_intern("to_sym"), 0);
+
+    // Also cause an exception if it's an incorrect symbol value.
+    if (kind_as_sym != square_sym && kind_as_sym != circle_sym)
+        rb_raise(rb_eTypeError, "invalid symbol for marker kind (set_info)");
+
+    mr_info_set(self->info, kind_as_sym == square_sym ? SQUARE : CIRCLE, rb_num2dbl(scale_value));
+
+    return self_value;
+}
+
+static VALUE rb_api_add(VALUE self_value, VALUE x_value, VALUE y_value, VALUE size_value)
+#define ARGC_add 3
+{
+    MARKER_LIST_FOR_VALUE_DECL(self);
+    add_marker(self, rb_num2dbl(x_value), rb_num2dbl(y_value), rb_num2dbl(size_value));
+    return INT2FIX(self->size);
+}
+
+static VALUE rb_api_length(VALUE self_value)
+#define ARGC_length 0
+{
+    MARKER_LIST_FOR_VALUE_DECL(self);
+    return INT2FIX(self->size);
+}
+
+static VALUE rb_api_marker(VALUE self_value, VALUE index)
+#define ARGC_marker 1
+{
+    MARKER_LIST_FOR_VALUE_DECL(self);
+    int i = NUM2INT(index);
+    if (0 <= i && i < self->size) {
+        MARKER *marker = self->markers + i;
+        VALUE triple = rb_ary_new2(3);
+        rb_ary_store(triple, 0, rb_float_new(mr_x(marker)));
+        rb_ary_store(triple, 1, rb_float_new(mr_y(marker)));
+        rb_ary_store(triple, 2, rb_float_new(marker->size));
+        return triple;
+    }
+    return Qnil;
+}
+
+static VALUE rb_api_parts(VALUE self_value, VALUE index)
+#define ARGC_parts 1
+{
+    MARKER_LIST_FOR_VALUE_DECL(self);
+    int i = NUM2INT(index);
+    if (0 <= i && i < self->size) {
+        MARKER *marker = self->markers + i;
+        VALUE rtn;
+        if (mr_merged(marker)) {
+            rtn = rb_ary_new2(3);
+            rb_ary_store(rtn, 0, ID2SYM(rb_intern(mr_deleted_p(marker) ? "merge" : "root")));
+            rb_ary_store(rtn, 1, INT2FIX(marker->part_a));
+            rb_ary_store(rtn, 2, INT2FIX(marker->part_b));
+        } else {
+            rtn = rb_ary_new2(1);
+            rb_ary_store(rtn, 0, ID2SYM(rb_intern(mr_deleted_p(marker) ? "leaf" : "single")));
+        }
+        return rtn;
+    }
+    return Qnil;
+}
+
+static VALUE rb_api_deleted(VALUE self_value, VALUE index)
+#define ARGC_deleted 1
+{
+    MARKER_LIST_FOR_VALUE_DECL(self);
+    int i = NUM2INT(index);
+    if (0 <= i && i < self->size)
+        return mr_deleted_p(self->markers + i) ? Qtrue : Qfalse;
+    return Qnil;
+}
+
+static VALUE rb_api_compress(VALUE self_value)
+#define ARGC_compress 0
+{
+    MARKER_LIST_FOR_VALUE_DECL(self);
+    compress(self);
+    return INT2FIX(self->size);
+}
+
+static VALUE rb_api_merge(VALUE self_value)
+#define ARGC_merge 0
+{
+    MARKER_LIST_FOR_VALUE_DECL(self);
+    ensure_headroom(self);
+    compress(self);
+    self->size = merge_markers_fast(self->info, self->markers, self->size);
+    return INT2FIX(self->size);
+}
+
+#define FUNCTION_TABLE_ENTRY(Name) { #Name, RUBY_METHOD_FUNC(rb_api_ ## Name), ARGC_ ## Name }
+
+static struct ft_entry {
+    const char *name;
+    VALUE (*func)(ANYARGS);
+    int argc;
+} function_table[] = {
+    FUNCTION_TABLE_ENTRY(add),
+    FUNCTION_TABLE_ENTRY(compress),
+    FUNCTION_TABLE_ENTRY(clear),
+    FUNCTION_TABLE_ENTRY(deleted),
+    FUNCTION_TABLE_ENTRY(initialize_copy),
+    FUNCTION_TABLE_ENTRY(length),
+    FUNCTION_TABLE_ENTRY(marker),
+    FUNCTION_TABLE_ENTRY(merge),
+    FUNCTION_TABLE_ENTRY(parts),
+    FUNCTION_TABLE_ENTRY(set_info),
+};
+
+#define STRING_CONST_TABLE_ENTRY(Name) { #Name, Name }
+
+static struct sct_entry {
+  const char *name;
+  const char *val;
+} string_const_table[] = {
+    STRING_CONST_TABLE_ENTRY(EXT_VERSION)
+};
+
+void Init_lulu(void)
+{
+    VALUE module = rb_define_module("Lulu");
+    VALUE klass = rb_define_class_under(module, "MarkerList", rb_cObject);
+    rb_define_alloc_func(klass, rb_api_new_marker_list);
+
+    for (int i = 0; i < STATIC_ARRAY_SIZE(function_table); i++) {
+        struct ft_entry *e = function_table + i;
+        rb_define_method(klass, e->name, e->func, e->argc);
+    }
+
+    for (int i = 0; i < STATIC_ARRAY_SIZE(string_const_table); i++) {
+        struct sct_entry *e = string_const_table + i;
+        rb_define_const(module, e->name, rb_str_new2(e->val));
+    }
+}