jls-grok 0.1.2786

data/INSTALL

@@ -0,0 +1,12 @@
+- You'll need grok installed.
+From 'grok', do:
+% make install
+# This will install grok, libgrok, and grok's headers
+
+- You'll need the 'Grok' ruby module installed.
+From 'grok/ruby' do:
+% ruby extconf.rb
+% make install
+
+# Test with:
+% ruby -e 'require "Grok"; puts "Grok OK"'

data/ext/Makefile

@@ -0,0 +1,157 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/lib/ruby/1.8/x86_64-linux
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+exec_prefix = $(prefix)
+prefix = $(DESTDIR)/usr
+sharedstatedir = $(prefix)/com
+mandir = $(prefix)/share/man
+psdir = $(docdir)
+oldincludedir = $(DESTDIR)/usr/include
+localedir = $(datarootdir)/locale
+bindir = $(exec_prefix)/bin
+libexecdir = $(prefix)/lib/ruby1.8
+sitedir = $(DESTDIR)/usr/local/lib/site_ruby
+htmldir = $(docdir)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+includedir = $(prefix)/include
+infodir = $(prefix)/share/info
+vendorlibdir = $(vendordir)/$(ruby_version)
+sysconfdir = $(DESTDIR)/etc
+libdir = $(exec_prefix)/lib
+sbindir = $(exec_prefix)/sbin
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+vendordir = $(libdir)/ruby/vendor_ruby
+datarootdir = $(prefix)/share
+pdfdir = $(docdir)
+archdir = $(rubylibdir)/$(arch)
+sitearchdir = $(sitelibdir)/$(sitearch)
+datadir = $(datarootdir)
+localstatedir = $(DESTDIR)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -fPIC -fno-strict-aliasing -g -g -O2  -fPIC $(cflags) 
+INCFLAGS = -I. -I. -I/usr/lib/ruby/1.8/x86_64-linux -I.
+DEFS     = 
+CPPFLAGS =    
+CXXFLAGS = $(CFLAGS) 
+ldflags  = -L. -Wl,-Bsymbolic-functions -rdynamic -Wl,-export-dynamic
+dldflags = 
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = $(CC) -shared
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby1.8
+RUBY_SO_NAME = ruby1.8
+arch = x86_64-linux
+sitearch = x86_64-linux
+ruby_version = 1.8
+ruby = /usr/bin/ruby1.8
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED) -lgrok  -lpthread -lrt -ldl -lcrypt -lm   -lc
+SRCS = ruby_grok.c ruby_grokmatch.c
+OBJS = ruby_grok.o ruby_grokmatch.o
+TARGET = Grok
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	@-$(RM) $@
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/ext/extconf.rb

@@ -0,0 +1,7 @@
+require "mkmf"
+find_header("tcutil.h", "/usr/local/include")
+find_header("pcre.h", "/usr/local/include")
+find_header("grok.h", "../")
+find_library("grok", "grok_init", "../")
+
+create_makefile("Grok")

data/ext/mkmf.log

@@ -0,0 +1,54 @@
+find_header: checking for tcutil.h in /usr/local/include... -------------------- yes
+
+"gcc -E -I. -I/usr/lib/ruby/1.8/x86_64-linux -I.    -fno-strict-aliasing -g -g -O2  -fPIC    conftest.c -o conftest.i"
+checked program was:
+/* begin */
+1: #include <tcutil.h>
+/* end */
+
+--------------------
+
+find_header: checking for pcre.h in /usr/local/include... -------------------- yes
+
+"gcc -E -I. -I/usr/lib/ruby/1.8/x86_64-linux -I.    -fno-strict-aliasing -g -g -O2  -fPIC    conftest.c -o conftest.i"
+checked program was:
+/* begin */
+1: #include <pcre.h>
+/* end */
+
+--------------------
+
+find_header: checking for grok.h in ../... -------------------- yes
+
+"gcc -E -I. -I/usr/lib/ruby/1.8/x86_64-linux -I.    -fno-strict-aliasing -g -g -O2  -fPIC    conftest.c -o conftest.i"
+checked program was:
+/* begin */
+1: #include <grok.h>
+/* end */
+
+--------------------
+
+find_library: checking for grok_init() in -lgrok... -------------------- yes
+
+"gcc -o conftest -I. -I/usr/lib/ruby/1.8/x86_64-linux -I.    -fno-strict-aliasing -g -g -O2  -fPIC   conftest.c  -L. -L/usr/lib -L. -Wl,-Bsymbolic-functions -rdynamic -Wl,-export-dynamic     -lruby1.8-static -lgrok  -lpthread -lrt -ldl -lcrypt -lm   -lc"
+conftest.c: In function 't':
+conftest.c:3: error: 'grok_init' undeclared (first use in this function)
+conftest.c:3: error: (Each undeclared identifier is reported only once
+conftest.c:3: error: for each function it appears in.)
+checked program was:
+/* begin */
+1: /*top*/
+2: int main() { return 0; }
+3: int t() { void ((*volatile p)()); p = (void ((*)()))grok_init; return 0; }
+/* end */
+
+"gcc -o conftest -I. -I/usr/lib/ruby/1.8/x86_64-linux -I.    -fno-strict-aliasing -g -g -O2  -fPIC   conftest.c  -L. -L/usr/lib -L. -Wl,-Bsymbolic-functions -rdynamic -Wl,-export-dynamic     -lruby1.8-static -lgrok  -lpthread -lrt -ldl -lcrypt -lm   -lc"
+checked program was:
+/* begin */
+1: /*top*/
+2: int main() { return 0; }
+3: int t() { grok_init(); return 0; }
+/* end */
+
+--------------------
+

data/ext/rgrok.h

@@ -0,0 +1,9 @@
+#ifndef _RGROK_H_
+#define _RGROK_H_ 
+#include <ruby.h>
+
+//VALUE cGrok = Qnil;
+//VALUE cGrokMatch = Qnil;
+
+extern VALUE rGrok_new(VALUE klass);
+#endif /* _RGROK_H_ */

data/ext/ruby_grok.c

@@ -0,0 +1,190 @@
+#include <ruby.h>
+#include <grok.h>
+#include "rgrok.h"
+#include "ruby_grokmatch.h"
+
+VALUE cGrok; /* Grok class object */
+
+extern VALUE cGrokMatch;
+extern void Init_GrokMatch();
+
+static VALUE rGrok_initialize(VALUE self) {
+  /* empty */
+  return Qnil;
+}
+
+static void rGrok_free(void *p) {
+  grok_t *grok = (grok_t *)p;
+
+  /* we strdup our pattern from ruby and rb_str2cstr */
+  /* typecast to ignore warnings about freeing a const...
+   * TODO(sissel): Fix the constness */
+  free((char *)grok->pattern);
+
+  grok_free(grok);
+  free(grok);
+}
+
+VALUE rGrok_new(VALUE klass) {
+  VALUE rgrok;
+  grok_t *grok = ALLOC(grok_t);
+  grok_init(grok);
+  //grok->logmask = ~0;
+  rgrok = Data_Wrap_Struct(klass, 0, rGrok_free, grok);
+  rb_obj_call_init(rgrok, 0, 0);
+  return rgrok;
+}
+
+VALUE rGrok_compile(VALUE self, VALUE pattern) {
+  grok_t *grok;
+  char *c_pattern = NULL;
+  char *str = NULL;
+  long len = 0;
+  int ret = 0;
+  Data_Get_Struct(self, grok_t, grok);
+
+  /* Need strdup here in case 'pattern' object is deleted later in 
+   * the ruby code */
+  str = rb_str2cstr(pattern, &len);
+  c_pattern = malloc(len);
+  memcpy(c_pattern, str, len);
+
+  if (grok->pattern != NULL) {
+    /* if we've already called compile, let's free up the string we
+     * allocated last time */
+
+    /* typecast to break constness. TODO(sissel): fix const */
+    free((char *)grok->pattern);
+  }
+
+  ret = grok_compilen(grok, c_pattern, (int)len);
+  if (ret) {
+    rb_raise(rb_eArgError, "Compile failed: %s", grok->errstr);
+  }
+
+  return Qnil;
+}
+
+VALUE rGrok_match(VALUE self, VALUE input) {
+  grok_t *grok = NULL;
+  grok_match_t gm;
+  char *c_input = NULL;
+  long len = 0;
+  int ret = 0;
+
+  Data_Get_Struct(self, grok_t, grok);
+  c_input = rb_str2cstr(input, &len);
+  ret = grok_execn(grok, c_input, (int)len, &gm);
+
+  VALUE rgm = Qnil;
+  
+  //fprintf(stderr, "%d\n", ret);
+  switch (ret) {
+    case GROK_ERROR_NOMATCH:
+      rgm = Qfalse;
+      break;
+    case GROK_OK:
+      rgm = rGrokMatch_new_from_grok_match(&gm);
+      break;
+    default:
+      rb_raise(rb_eArgError, "Error from grok_execn: %d", ret);
+      rgm = Qfalse;
+  }
+
+  return rgm;
+}
+
+VALUE rGrok_add_pattern(VALUE self, VALUE name, VALUE pattern) {
+  grok_t *grok = NULL;
+  char *c_name= NULL, *c_pattern = NULL;
+  long namelen = 0, patternlen = 0;
+
+  /* Don't need strdup here, since grok_pattern_add will store a copy
+   * if the data */
+  c_name = rb_str2cstr(name, &namelen);
+  c_pattern = rb_str2cstr(pattern, &patternlen);
+  Data_Get_Struct(self, grok_t, grok);
+
+  grok_pattern_add(grok, c_name, namelen, c_pattern, patternlen);
+  return Qnil;
+}
+
+VALUE rGrok_add_patterns_from_file(VALUE self, VALUE path) {
+  grok_t *grok = NULL;
+  int ret = 0;
+  char *c_path = NULL;
+  long pathlen = 0;
+
+  /* don't need strdup here, since we don't store 'path' long-term */
+  c_path = rb_str2cstr(path, &pathlen);
+  Data_Get_Struct(self, grok_t, grok);
+
+  ret = grok_patterns_import_from_file(grok, c_path);
+
+  if (ret != GROK_OK) {
+    rb_raise(rb_eArgError, "Failed to add patterns from file %s", c_path);
+  }
+
+  return Qnil;
+}
+
+VALUE rGrok_expanded_pattern(VALUE self) {
+  grok_t *grok = NULL;
+  VALUE expanded_pattern;
+
+  Data_Get_Struct(self, grok_t, grok);
+  expanded_pattern = rb_str_new(grok->full_pattern, grok->full_pattern_len);
+  return expanded_pattern;
+}
+
+VALUE rGrok_pattern(VALUE self) {
+  grok_t *grok = NULL;
+  VALUE pattern;
+
+  Data_Get_Struct(self, grok_t, grok);
+  pattern = rb_str_new(grok->pattern, grok->pattern_len);
+  return pattern;
+}
+
+VALUE rGrok_patterns(VALUE self) {
+  VALUE patternmap = rb_hash_new();
+  TCLIST *names = NULL;
+  grok_t *grok = NULL;
+  int i = 0, len = 0;
+
+  Data_Get_Struct(self, grok_t, grok);
+  names = grok_pattern_name_list(grok);
+
+  len = tclistnum(names);
+  for (i = 0; i < len; i++)  {
+    int namelen = 0;
+    const char *name = tclistval(names, i, &namelen);
+    size_t regexplen = 0;
+    const char *regexp = NULL;
+    grok_pattern_find(grok, name, namelen, &regexp, &regexplen);
+
+    VALUE key;
+    VALUE value;
+    key = rb_tainted_str_new(name, namelen);
+    value = rb_tainted_str_new(regexp, regexplen);
+    rb_hash_aset(patternmap, key, value);
+  }
+  tclistdel(names);
+  return patternmap;
+}
+
+void Init_Grok() {
+  cGrok = rb_define_class("Grok", rb_cObject);
+  rb_define_singleton_method(cGrok, "new", rGrok_new, 0);
+  rb_define_method(cGrok, "initialize", rGrok_initialize, 0);
+  rb_define_method(cGrok, "compile", rGrok_compile, 1);
+  rb_define_method(cGrok, "match", rGrok_match, 1);
+  rb_define_method(cGrok, "expanded_pattern", rGrok_expanded_pattern, 0);
+  rb_define_method(cGrok, "pattern", rGrok_pattern, 0);
+  rb_define_method(cGrok, "add_pattern", rGrok_add_pattern, 2);
+  rb_define_method(cGrok, "add_patterns_from_file",
+                   rGrok_add_patterns_from_file, 1);
+  rb_define_method(cGrok, "patterns", rGrok_patterns, 0);
+
+  Init_GrokMatch();
+}

data/ext/ruby_grokmatch.c

@@ -0,0 +1,220 @@
+#include "rgrok.h"
+#include <grok.h>
+
+VALUE cGrokMatch;
+extern VALUE cGrok;
+
+static ID id_atend;
+static ID id_atstart;
+static ID id_atcaptures;
+static ID id_atsubject;
+
+static ID id_length;
+static ID id_has_key_p;
+
+static void rGrokMatch_free(void *p);
+
+VALUE rGrokMatch_new(VALUE klass) {
+  NEWOBJ(rgm, grok_match_t);
+  OBJSETUP(rgm, klass, T_OBJECT);
+
+  return (VALUE)rgm;
+}
+
+VALUE rGrokMatch_new_from_grok_match(grok_match_t *gm) {
+  VALUE rgrokmatch;
+  grok_match_t *my_gm = NULL;
+  rgrokmatch = Data_Make_Struct(cGrokMatch, grok_match_t, 0,
+                                rGrokMatch_free, my_gm);
+  memcpy(my_gm, gm, sizeof(grok_match_t));
+
+  /* We must strdup here, otherwise ruby GC may come and re-arrange
+   * rb_str2cstr() can give a pointer to an object that is later deleted. When
+   * deleted, we won't know about it, and we'll get a garbage string from that
+   * pointer.
+   *
+   * TODO(sissel): make a GrokMatch 'ruby' friendly struct
+   * that uses VALUE types for subject.
+   */
+  my_gm->subject = strdup(gm->subject);
+  rb_obj_call_init(rgrokmatch, 0, 0);
+  return rgrokmatch;
+}
+
+VALUE rGrokMatch_initialize(VALUE self) {
+  grok_match_t *gm;
+  VALUE captures;
+  
+  Data_Get_Struct(self, grok_match_t, gm);
+
+  /* Set the @captures variable to a hash of array of strings */
+  captures = rb_hash_new();
+  //captures = rb_eval_string("Hash.new { |h,k| h[k] = Array.new }");
+  rb_iv_set(self, "@captures", captures);
+
+  return Qtrue;
+}
+
+VALUE rGrokMatch_each_capture(VALUE self) {
+  char *name;
+  const char *data;
+  int namelen, datalen;
+  grok_match_t *gm;
+  VALUE captures;
+
+  Data_Get_Struct(self, grok_match_t, gm);
+  captures = rb_iv_get(self, "@captures");
+  grok_match_walk_init(gm);
+  while (grok_match_walk_next(gm, &name, &namelen, &data, &datalen) == 0) {
+    VALUE key, value;
+
+#ifdef _TRIM_KEY_EXCESS_IN_C_
+  /* This section will skip captures of %{FOO} and rename captures of
+   * %{FOO:bar} to just 'bar' */
+    size_t koff = 0;
+    /* there is no 'strcspn' that takes a length, so do it ourselves */
+    while (koff < namelen && name[koff] != ':' && name[koff] != '\0') {
+      koff++;
+    }
+
+    /* Skip captures that aren't named specially */
+    if (koff == namelen) {
+      //printf("Skipping %.*s\n", namelen, name);
+      continue;
+    }
+
+    koff++;
+
+    key = rb_tainted_str_new(name + koff, namelen - koff);
+#else
+    key = rb_tainted_str_new(name, namelen);
+#endif
+    value = rb_tainted_str_new(data, datalen);
+
+    // Yield [key, value]
+    rb_yield(rb_ary_new3(2, key, value));
+    //rb_ary_push(ary, value);
+  }
+
+  grok_match_walk_end(gm);
+  return Qtrue;
+}
+
+VALUE rGrokMatch_captures(VALUE self) {
+  char *name;
+  const char *data;
+  int namelen, datalen;
+  grok_match_t *gm;
+  VALUE captures;
+
+  Data_Get_Struct(self, grok_match_t, gm);
+  captures = rb_iv_get(self, "@captures");
+
+  if (captures == Qnil) {
+    captures = rb_hash_new();
+  }
+
+  if (FIX2INT(rb_funcall(captures, id_length, 0)) > 0) {
+  //if (FIX2NUM(rb_hash_size(captures)) > 0) {
+    return captures;
+  }
+
+  grok_match_walk_init(gm);
+  while (grok_match_walk_next(gm, &name, &namelen, &data, &datalen) == 0) {
+    VALUE key = Qnil;
+    VALUE value = Qnil;
+
+#ifdef _TRIM_KEY_EXCESS_IN_C_
+  /* This section will skip captures of %{FOO} and rename captures of
+   * %{FOO:bar} to just 'bar' */
+    size_t koff = 0;
+    /* there is no 'strcspn' that takes a length, so do it ourselves */
+    while (koff < namelen && name[koff] != ':' && name[koff] != '\0') {
+      koff++;
+    }
+
+    /* Skip captures that aren't named specially */
+    if (koff == namelen) {
+      //printf("Skipping %.*s\n", namelen, name);
+      continue;
+    }
+
+    koff++;
+
+    key = rb_tainted_str_new(name + koff, namelen - koff);
+#else
+    key = rb_tainted_str_new(name, namelen);
+#endif
+    value = rb_tainted_str_new(data, datalen);
+
+    VALUE array;
+    //if (rb_hash_has_key(captures, key) == Qfalse) {
+    if (rb_funcall(captures, id_has_key_p, 1, key) == Qfalse) {
+      array = rb_hash_aset(captures, key, rb_ary_new());
+    } else {
+      array = rb_hash_aref(captures, key);
+    }
+    rb_ary_push(array, value);
+  }
+
+  grok_match_walk_end(gm);
+  return captures;
+}
+
+VALUE rGrokMatch_start(VALUE self) {
+  grok_match_t *gm;
+  Data_Get_Struct(self, grok_match_t, gm);
+  return INT2FIX(gm->start);
+}
+
+VALUE rGrokMatch_end(VALUE self) {
+  grok_match_t *gm;
+  Data_Get_Struct(self, grok_match_t, gm);
+  VALUE ret = Qnil;
+  ret = rb_iv_get(self, "@end");
+  if (ret == Qnil) {
+    ret = rb_iv_set(self, "@end", INT2FIX(gm->end));
+  }
+  return INT2FIX(gm->end);
+}
+
+VALUE rGrokMatch_subject(VALUE self) {
+  grok_match_t *gm;
+  Data_Get_Struct(self, grok_match_t, gm);
+  return rb_tainted_str_new2(gm->subject);
+}
+
+VALUE rGrokMatch_debug(VALUE self) {
+  grok_match_t *gm;
+  Data_Get_Struct(self, grok_match_t, gm);
+  printf("match subject: %s\n", gm->subject);
+  printf("match start: %d\n", gm->start);
+  printf("match end: %d\n", gm->end);
+  printf("grok pattern: %s\n", gm->grok->pattern);
+  return Qnil;
+}
+
+void rGrokMatch_free(void *p) {
+  grok_match_t *gm = (grok_match_t *)p;
+  free((char *)gm->subject);
+}
+
+void Init_GrokMatch() {
+  cGrokMatch = rb_define_class("GrokMatch", rb_cObject);
+  rb_define_singleton_method(cGrokMatch, "new", rGrokMatch_new, 0);
+  rb_define_method(cGrokMatch, "initialize", rGrokMatch_initialize, 0);
+  rb_define_method(cGrokMatch, "captures", rGrokMatch_captures, 0);
+  rb_define_method(cGrokMatch, "start", rGrokMatch_start, 0);
+  rb_define_method(cGrokMatch, "end", rGrokMatch_end, 0);
+  rb_define_method(cGrokMatch, "subject", rGrokMatch_subject, 0);
+  rb_define_method(cGrokMatch, "each_capture", rGrokMatch_each_capture, 0);
+
+  //rb_define_method(cGrokMatch, "debug", rGrokMatch_debug, 0);
+
+  id_atend = rb_intern("@end");
+  id_atstart = rb_intern("@start");
+  id_atcaptures = rb_intern("@captures");
+  id_atsubject = rb_intern("@subject");
+  id_length = rb_intern("length");
+  id_has_key_p = rb_intern("has_key?");
+}

data/ext/ruby_grokmatch.h

@@ -0,0 +1,14 @@
+#ifndef _RUBY_GROKMATCH_H_
+#define  _RUBY_GROKMATCH_H_
+
+#include "rgrok.h"
+#include <grok.h>
+
+#ifdef _IS_RUBY_GROKMATCH_
+  #define CONDEXTERN
+#else
+  #define CONDEXTERN extern
+#endif
+
+CONDEXTERN VALUE rGrokMatch_new_from_grok_match(grok_match_t *gm);
+#endif /*  _RUBY_GROKMATCH_H_ */

data/lib/grok.rb

@@ -0,0 +1 @@
+require "Grok"