jls-grok 0.2.3104 → 0.3.3209

data/grok.gemspec

@@ -6,22 +6,15 @@ Gem::Specification.new do |spec|
     examples/grok-web.rb
     examples/pattern-discovery.rb
     examples/test.rb
-    ext
-    ext/extconf.rb
-    ext/rgrok.h
-    ext/ruby_grok.c
-    ext/ruby_grokdiscover.c
-    ext/ruby_grokmatch.c
-    ext/ruby_grokmatch.h
     grok.gemspec
     lib
     lib/grok
     lib/grok.rb
+    lib/grok/match.rb
     lib/grok/pile.rb
     test
     test/Makefile
     test/alltests.rb
-    test/core
     test/general
     test/general/basic_test.rb
     test/general/captures_test.rb
@@ -45,16 +38,16 @@ Gem::Specification.new do |spec|
 
   svnrev = %x{svn info}.split("\n").grep(/Revision:/).first.split(" ").last.to_i
   spec.name = "jls-grok"
-  spec.version = "0.2.#{svnrev}"
+  spec.version = "0.3.#{svnrev}"
 
   spec.summary = "grok bindings for ruby"
   spec.description = "Grok ruby bindings - pattern match/extraction tool"
   spec.files = files
-  spec.require_paths << "ext"
-  spec.extensions = ["ext/extconf.rb"]
 
-  spec.author = "Jordan Sissel"
-  spec.email = "jls@semicomplete.com"
+  spec.add_dependency("ffi", ">= 1.0.5")
+
+  spec.authors = ["Jordan Sissel", "Pete Fritchman"]
+  spec.email = ["jls@semicomplete.com", "petef@databits.net"]
   spec.homepage = "http://code.google.com/p/semicomplete/wiki/Grok"
 end
 

data/lib/grok/match.rb

@@ -0,0 +1,75 @@
+require "rubygems"
+require "ffi"
+require "grok"
+
+class Grok::Match < FFI::Struct
+  module CGrokMatch
+    extend FFI::Library
+    ffi_lib "libgrok.so"
+
+    attach_function :grok_match_get_named_substring,
+                    [:pointer, :pointer], :pointer
+    attach_function :grok_match_walk_init, [:pointer], :void
+    attach_function :grok_match_walk_next,
+                    [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+    attach_function :grok_match_walk_end, [:pointer], :void
+  end
+
+  include CGrokMatch
+  layout :grok, :pointer,
+         :subject, :string,
+         :start, :int,
+         :end, :int
+
+  public
+  def initialize
+    super
+
+    @captures = nil
+  end
+
+  private
+  def _get_captures
+    @captures = Hash.new { |h, k| h[k] = Array.new }
+    grok_match_walk_init(self)
+    name_ptr = FFI::MemoryPointer.new(:pointer)
+    namelen_ptr = FFI::MemoryPointer.new(:int)
+    data_ptr = FFI::MemoryPointer.new(:pointer)
+    datalen_ptr = FFI::MemoryPointer.new(:int)
+    while grok_match_walk_next(self, name_ptr, namelen_ptr, data_ptr, datalen_ptr) == Grok::GROK_OK
+      namelen = namelen_ptr.read_int
+      name = name_ptr.get_pointer(0).get_string(0, namelen)
+      datalen = datalen_ptr.read_int
+      data = data_ptr.get_pointer(0).get_string(0, datalen)
+      @captures[name] << data
+    end
+    grok_match_walk_end(self)
+  end
+
+  public
+  def captures
+    _get_captures if @captures.nil?
+    return @captures
+  end
+
+  public
+  def start
+    return self[:start]
+  end
+
+  public
+  def end
+    return self[:end]
+  end
+
+  public
+  def subject
+    return self[:subject]
+  end
+
+  public
+  def each_capture
+    _get_captures if @captures.nil?
+    @captures.each { |k, v| yield([k, v]) }
+  end
+end # Grok::Match

data/lib/grok/pile.rb

@@ -2,53 +2,55 @@ require "grok"
 
 # A grok pile is an easy way to have multiple patterns together so
 # that you can try to match against each one.
-# The API provided should be similar to the normal Grok 
+# The API provided should be similar to the normal Grok
 # interface, but you can compile multiple patterns and match will
 # try each one until a match is found.
-class Grok::Pile
-  def initialize
-    @groks = []
-    @patterns = {}
-    @pattern_files = []
-  end # def initialize
+class Grok
+  class Pile
+    def initialize
+      @groks = []
+      @patterns = {}
+      @pattern_files = []
+    end # def initialize
 
-  # see Grok#add_pattern
-  def add_pattern(name, string)
-    @patterns[name] = string
-  end # def add_pattern
+    # see Grok#add_pattern
+    def add_pattern(name, string)
+      @patterns[name] = string
+    end # def add_pattern
 
-  # see Grok#add_patterns_from_file
-  def add_patterns_from_file(path)
-    if !File.exists?(path)
-      raise "File does not exist: #{path}"
-    end
-    @pattern_files << path
-  end # def add_patterns_from_file
+    # see Grok#add_patterns_from_file
+    def add_patterns_from_file(path)
+      if !File.exists?(path)
+        raise "File does not exist: #{path}"
+      end
+      @pattern_files << path
+    end # def add_patterns_from_file
 
-  # see Grok#compile
-  def compile(pattern)
-    grok = Grok.new
-    @patterns.each do |name, value|
-      grok.add_patterne(name, value)
-    end
-    @pattern_files.each do |path|
-      grok.add_patterns_from_file(path)
-    end
-    grok.compile(pattern)
-    @groks << grok
-  end # def compile
+    # see Grok#compile
+    def compile(pattern)
+      grok = Grok.new
+      @patterns.each do |name, value|
+        grok.add_patterne(name, value)
+      end
+      @pattern_files.each do |path|
+        grok.add_patterns_from_file(path)
+      end
+      grok.compile(pattern)
+      @groks << grok
+    end # def compile
 
-  # Slight difference from Grok#match in that it returns
-  # the Grok instance that matched successfully in addition
-  # to the GrokMatch result.
-  # See also: Grok#match
-  def match(string)
-    @groks.each do |grok|
-      match = grok.match(string)
-      if match
-        return [grok, match]
+    # Slight difference from Grok#match in that it returns
+    # the Grok instance that matched successfully in addition
+    # to the GrokMatch result.
+    # See also: Grok#match
+    def match(string)
+      @groks.each do |grok|
+        match = grok.match(string)
+        if match
+          return [grok, match]
+        end
       end
-    end
-    return false
-  end # def match
-end # class Grok::Pile
+      return false
+    end # def match
+  end # class Pile
+end # class Grok

data/lib/grok.rb

@@ -1,8 +1,107 @@
-require "Grok"
-require "grok/pile"
+require "rubygems"
+require "ffi"
+
+class Grok < FFI::Struct
+  module CGrok
+    extend FFI::Library
+    ffi_lib "libgrok.so"
+
+    attach_function :grok_new, [], :pointer
+    attach_function :grok_compilen, [:pointer, :pointer, :int], :int
+    attach_function :grok_pattern_add,
+                    [:pointer, :pointer, :int, :pointer, :int], :int
+    attach_function :grok_patterns_import_from_file, [:pointer, :pointer], :int
+    attach_function :grok_execn, [:pointer, :pointer, :int, :pointer], :int
+  end
+
+  include CGrok
+  layout :pattern, :string,
+         :pattern_len, :int,
+         :full_pattern, :string,
+         :full_pattern_len, :int,
+         :__patterns, :pointer, # TCTREE*, technically
+         :__re, :pointer, # pcre*
+         :__pcre_capture_vector, :pointer, # int*
+         :__pcre_num_captures, :int,
+         :__captures_by_id, :pointer, # TCTREE*
+         :__captures_by_name, :pointer, # TCTREE*
+         :__captures_by_subname, :pointer, # TCTREE*
+         :__captures_by_capture_number, :pointer, # TCTREE*
+         :__max_capture_num, :int,
+         :pcre_errptr, :string,
+         :pcre_erroffset, :int,
+         :pcre_errno, :int,
+         :logmask, :uint,
+         :logdepth, :uint,
+         :errstr, :string
+
+  GROK_OK = 0
+  GROK_ERROR_FILE_NOT_ACCESSIBLE = 1
+  GROK_ERROR_PATTERN_NOT_FOUND = 2
+  GROK_ERROR_UNEXPECTED_READ_SIZE = 3
+  GROK_ERROR_COMPILE_FAILED = 4
+  GROK_ERROR_UNINITIALIZED = 5
+  GROK_ERROR_PCRE_ERROR = 6
+  GROK_ERROR_NOMATCH = 7
+
+  public
+  def initialize
+    super(grok_new)
+  end
+
+  public
+  def add_pattern(name, pattern)
+    name_c = FFI::MemoryPointer.from_string(name)
+    pattern_c = FFI::MemoryPointer.from_string(pattern)
+    grok_pattern_add(self, name_c, name.length, pattern_c, pattern.length)
+    return nil
+  end
+
+  public
+  def add_patterns_from_file(path)
+    path_c = FFI::MemoryPointer.from_string(path)
+    ret = grok_patterns_import_from_file(self, path_c)
+    if ret != GROK_OK
+      raise ArgumentError, "Failed to add patterns from file #{path}"
+    end
+    return nil
+  end
+
+  public
+  def pattern
+    return self[:pattern]
+  end
+
+  public
+  def expanded_pattern
+    return self[:full_pattern]
+  end
+
+  public
+  def compile(pattern)
+    pattern_c = FFI::MemoryPointer.from_string(pattern)
+    ret = grok_compilen(self, pattern_c, pattern.length)
+    if ret != GROK_OK
+      raise ArgumentError, "Compile failed: #{self[:errstr]})"
+    end
+    return ret
+  end
+
+  public
+  def match(text)
+    match = Grok::Match.new
+    text_c = FFI::MemoryPointer.from_string(text)
+    rc = grok_execn(self, text_c, text.size, match)
+    case rc
+    when GROK_OK
+      return match
+    when GROK_ERROR_NOMATCH
+      return false
+    end
+
+    raise ValueError, "unknown return from grok_execn: #{rc}"
+  end
 
-# extend Grok to add simpler access to the discover feature.
-class Grok
   public
   def discover(input)
     init_discover if @discover == nil
@@ -15,4 +114,7 @@ class Grok
     @discover = GrokDiscover.new(self)
     @discover.logmask = logmask
   end
-end
+end # Grok
+
+require "grok/match"
+require "grok/pile"

data/test/Makefile

@@ -2,6 +2,8 @@
 .PHONY: test
 test:
 	$(MAKE) -C ../../ libgrok.so
-	[ -f "../Makefile" ] || (cd ../ext; ruby extconf.rb)
-	$(MAKE) -C ../ext Grok.so
-	LD_LIBRARY_PATH="$${LD_LIBRARY_PATH}:$$PWD/../../" RUBYLIB="$$PWD/../ext" ruby alltests.rb
+	LD_LIBRARY_PATH="$${LD_LIBRARY_PATH}:$$PWD/../../" RUBYLIB="$$PWD/../lib" ruby alltests.rb
+
+test_jruby:
+	$(MAKE) -C ../../ libgrok.so
+	LD_LIBRARY_PATH="$${LD_LIBRARY_PATH}:$$PWD/../../" RUBYLIB="$$PWD/../lib" jruby alltests.rb

data/test/general/captures_test.rb

@@ -24,7 +24,7 @@ class GrokPatternCapturingTests < Test::Unit::TestCase
     input = "hello world"
     match = @grok.match(input)
     assert_equal("(?<0000>.*)", @grok.expanded_pattern)
-    assert_kind_of(GrokMatch, match)
+    assert_kind_of(Grok::Match, match)
     assert_kind_of(Hash, match.captures)
     assert_equal(match.captures.length, 1)
     assert_kind_of(Array, match.captures["foo"])

metadata

@@ -1,30 +1,48 @@
 --- !ruby/object:Gem::Specification 
 name: jls-grok
 version: !ruby/object:Gem::Version 
-  hash: 6231
-  prerelease: false
+  hash: 6401
+  prerelease: 
   segments: 
   - 0
-  - 2
-  - 3104
-  version: 0.2.3104
+  - 3
+  - 3209
+  version: 0.3.3209
 platform: ruby
 authors: 
 - Jordan Sissel
+- Pete Fritchman
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-11-15 00:00:00 -08:00
+date: 2011-02-14 00:00:00 -08:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 1
+        - 0
+        - 5
+        version: 1.0.5
+  type: :runtime
+  version_requirements: *id001
 description: Grok ruby bindings - pattern match/extraction tool
-email: jls@semicomplete.com
+email: 
+- jls@semicomplete.com
+- petef@databits.net
 executables: []
 
-extensions: 
-- ext/extconf.rb
+extensions: []
+
 extra_rdoc_files: []
 
 files: 
@@ -33,18 +51,12 @@ files:
 - examples/grok-web.rb
 - examples/pattern-discovery.rb
 - examples/test.rb
-- ext/extconf.rb
-- ext/rgrok.h
-- ext/ruby_grok.c
-- ext/ruby_grokdiscover.c
-- ext/ruby_grokmatch.c
-- ext/ruby_grokmatch.h
 - grok.gemspec
 - lib/grok.rb
+- lib/grok/match.rb
 - lib/grok/pile.rb
 - test/Makefile
 - test/alltests.rb
-- test/core
 - test/general/basic_test.rb
 - test/general/captures_test.rb
 - test/patterns/day.rb
@@ -69,7 +81,6 @@ rdoc_options: []
 
 require_paths: 
 - lib
-- ext
 required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
@@ -91,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.1
 signing_key: 
 specification_version: 3
 summary: grok bindings for ruby

data/ext/extconf.rb

@@ -1,21 +0,0 @@
-require "mkmf"
-
-# TODO(sissel): I don't think we need these two headers.
-#if !find_header("tcutil.h", "/usr/local/include")
-#if !find_header("pcre.h", "/usr/local/include")
-
-if !find_header("grok.h", "/usr/local/include", "../../", "/usr/include")
-  raise "Could not find grok.h"
-end
-
-if !find_library("grok", "grok_init", "../", "../../", "/usr/local/lib", "/usr/lib")
-  raise "Could not find libgrok, is it installed?"
-end
-
-create_makefile("Grok")
-
-#with_cflags("-g") do
-  #with_ldflags("-g") do
-    #create_makefile("Grok")
-  #end
-#end

data/ext/rgrok.h

@@ -1,9 +0,0 @@
-#ifndef _RGROK_H_
-#define _RGROK_H_ 
-#include <ruby.h>
-#include <grok.h>
-
-extern VALUE rGrok_new(VALUE klass);
-extern VALUE rGrok_new_from_grok(grok_t *grok);
-
-#endif /* _RGROK_H_ */

data/ext/ruby_grok.c

@@ -1,257 +0,0 @@
-#include <ruby.h>
-#include <grok.h>
-#include "rgrok.h"
-#include "ruby_grokmatch.h"
-
-VALUE cGrok; /* Grok class object */
-
-/*
- * Document-class: Grok
- * Grok ruby bindings.
- *
- * For an intro to grok, see:
- * See http://code.google.com/p/semicomplete/wiki/Grok
- * and http://code.google.com/p/semicomplete/wiki/GrokRuby
- *
- * General usage of grok is as follows:
- *
- *    grok = Grok.new
- *    grok.add_patterns_from_file("/path/to/patterns")
- *    grok.add_pattern("WORD", "\b\w+\b")
- *    grok.compile("%{WORD} world!")
- *    m = grok.match("Hello world!")
- *    if m
- *      puts m.captures["WORD"]
- *     else
- *       puts "No match."
- *    fi
- *
- * Grok autodiscovery:
- *    grok = Grok.new
- *    grok.add_patterns_from_file("/path/to/patterns")
- *
- *    # Assuming you loaded the default pattern set
- *    grok.discover("2009-04-18")   
- *    #=> "\\Q\\E%{DATE_EU}\\Q\\E"
- *    grok.discover("Visit http://www.google.com/")   
- *    #=> "\\QVisit \\E%{URI}\\Q\\E"
- *
- */
-
-extern VALUE cGrokMatch;
-extern VALUE cGrokDiscover;
-extern void Init_GrokMatch();
-extern void Init_GrokDiscover();
-
-static VALUE rGrok_initialize(VALUE self) {
-  /* empty */
-  return Qnil;
-}
-
-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_new_from_grok(grok_t *grok) {
-  VALUE rgrok;
-  rgrok = Data_Wrap_Struct(cGrok, 0, rGrok_free, grok);
-  rb_obj_call_init(rgrok, 0, 0);
-  return rgrok;
-}
-
-/*
- * Compiles an expression.
- *
- * call-seq:
- *  grok.compile(pattern) 
- *
- */
-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 
-   * TODO(sissel): Really, just mark that we are using this string
-   * rather than strduping. */
-  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;
-}
-
-VALUE rGrok_get_logmask(VALUE self) {
-  grok_t *grok;
-  Data_Get_Struct(self, grok_t, grok);
-  return INT2FIX(grok->logmask);
-}
-
-VALUE rGrok_set_logmask(VALUE self, VALUE mask) {
-  grok_t *grok;
-  Data_Get_Struct(self, grok_t, grok);
-  grok->logmask = FIX2INT(mask);
-  return Qnil;
-}
-
-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);
-  rb_define_method(cGrok, "logmask=", rGrok_set_logmask, 1);
-  rb_define_method(cGrok, "logmask", rGrok_get_logmask, 0);
-
-  Init_GrokMatch();
-  Init_GrokDiscover();
-}

data/ext/ruby_grokdiscover.c

@@ -1,69 +0,0 @@
-#include "rgrok.h"
-#include <grok.h>
-
-VALUE cGrokDiscover;
-extern VALUE cGrok;
-
-static void rGrokDiscover_free(void *p);
-
-VALUE rGrokDiscover_new(VALUE klass, VALUE grok) {
-  VALUE rgd;
-  grok_discover_t *gdt = ALLOC(grok_discover_t); //grok_discover_new();
-  rgd = Data_Wrap_Struct(klass, 0, rGrokDiscover_free, gdt);
-
-  VALUE initargs[1] = { grok };
-  rb_obj_call_init(rgd, 1, initargs);
-  return (VALUE)rgd;
-}
-
-static void rGrokDiscover_free(void *p) {
-  grok_discover_t *gdt = p;
-  grok_discover_free(gdt);
-}
-
-VALUE rGrokDiscover_initialize(VALUE self, VALUE rb_grok) {
-  grok_discover_t *gdt;
-  grok_t *grok;
-  Data_Get_Struct(self, grok_discover_t, gdt);
-  Data_Get_Struct(rb_grok, grok_t, grok);
-
-  grok_discover_init(gdt, grok);
-  return Qnil;
-}
-
-
-VALUE rGrokDiscover_discover(VALUE self, VALUE input) {
-  char *cstr_discovery;
-  char *cstr_input;
-  long unused_input_len;
-  int discovery_len;
-  grok_discover_t *gdt;
-  grok_t *grok;
-
-  Data_Get_Struct(self, grok_discover_t, gdt);
-  cstr_input = rb_str2cstr(input, &unused_input_len);
-  grok_discover(gdt, cstr_input, &cstr_discovery, &discovery_len);
-  return rb_str_new(cstr_discovery, discovery_len);
-}
-
-VALUE rGrokDiscover_get_logmask(VALUE self) {
-  grok_discover_t *gdt;
-  Data_Get_Struct(self, grok_discover_t, gdt);
-  return INT2FIX(gdt->logmask);
-}
-
-VALUE rGrokDiscover_set_logmask(VALUE self, VALUE mask) {
-  grok_discover_t *gdt;
-  Data_Get_Struct(self, grok_discover_t, gdt);
-  gdt->logmask = FIX2INT(mask);
-  return Qnil;
-}
-
-void Init_GrokDiscover() {
-  cGrokDiscover = rb_define_class("GrokDiscover", rb_cObject);
-  rb_define_singleton_method(cGrokDiscover, "new", rGrokDiscover_new, 1);
-  rb_define_method(cGrokDiscover, "initialize", rGrokDiscover_initialize, 1);
-  rb_define_method(cGrokDiscover, "discover", rGrokDiscover_discover, 1);
-  rb_define_method(cGrokDiscover, "logmask=", rGrokDiscover_set_logmask, 1);
-  rb_define_method(cGrokDiscover, "logmask", rGrokDiscover_get_logmask, 0);
-}

data/ext/ruby_grokmatch.c

@@ -1,220 +0,0 @@
-#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

@@ -1,14 +0,0 @@
-#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_ */