groonga 0.0.1

data/ext/rb-grn-patricia-trie-cursor.c

@@ -0,0 +1,30 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "rb-grn.h"
+
+VALUE rb_cGrnPatriciaTrieCursor;
+
+void
+rb_grn_init_patricia_trie_cursor (VALUE mGrn)
+{
+    rb_cGrnPatriciaTrieCursor =
+        rb_define_class_under(mGrn, "PatriciaTrieCursor", rb_cGrnTableCursor);
+
+    rb_include_module(rb_cGrnHashCursor, rb_mGrnTableCursorKeySupport);
+}

data/ext/rb-grn-patricia-trie.c

@@ -0,0 +1,40 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "rb-grn.h"
+
+#define SELF(object) (RVAL2GRNTABLE(object))
+
+VALUE rb_cGrnPatriciaTrie;
+
+static VALUE
+rb_grn_patricia_trie_s_create (int argc, VALUE *argv, VALUE self)
+{
+    return rb_grn_table_s_create(argc, argv, self, GRN_TABLE_PAT_KEY);
+}
+
+void
+rb_grn_init_patricia_trie (VALUE mGrn)
+{
+    rb_cGrnPatriciaTrie =
+	rb_define_class_under(mGrn, "PatriciaTrie", rb_cGrnTable);
+
+    rb_include_module(rb_cGrnPatriciaTrie, rb_mGrnTableKeySupport);
+    rb_define_singleton_method(rb_cGrnPatriciaTrie, "create",
+			       rb_grn_patricia_trie_s_create, -1);
+}

data/ext/rb-grn-procedure.c

@@ -0,0 +1,52 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "rb-grn.h"
+
+#define SELF(object) (RVAL2GRNPROCEDURE(object))
+
+VALUE rb_cGrnProcedure;
+
+grn_obj *
+rb_grn_procedure_from_ruby_object (VALUE object)
+{
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnProcedure))) {
+	rb_raise(rb_eTypeError, "not a groonga procedure");
+    }
+
+    return RVAL2GRNOBJECT(object, NULL);
+}
+
+VALUE
+rb_grn_procedure_to_ruby_object (grn_ctx *context, grn_obj *procedure,
+				 rb_grn_boolean owner)
+{
+    return GRNOBJECT2RVAL(rb_cGrnProcedure, context, procedure, owner);
+}
+
+void
+rb_grn_init_procedure (VALUE mGrn)
+{
+    rb_cGrnProcedure = rb_define_class_under(mGrn, "Procedure", rb_cGrnObject);
+
+    rb_define_const(rb_cGrnProcedure, "DELIMIT", INT2NUM(GRN_DB_DELIMIT));
+    rb_define_const(rb_cGrnProcedure, "UNIGRAM", INT2NUM(GRN_DB_UNIGRAM));
+    rb_define_const(rb_cGrnProcedure, "BIGRAM", INT2NUM(GRN_DB_BIGRAM));
+    rb_define_const(rb_cGrnProcedure, "TRIGRAM", INT2NUM(GRN_DB_TRIGRAM));
+    rb_define_const(rb_cGrnProcedure, "MECAB", INT2NUM(GRN_DB_MECAB));
+}

data/ext/rb-grn-query.c

@@ -0,0 +1,207 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "rb-grn.h"
+
+#define SELF(object) (rb_rb_grn_query_from_ruby_object(object))
+
+typedef struct _RbGrnQuery RbGrnQuery;
+struct _RbGrnQuery
+{
+    grn_ctx *context;
+    grn_query *query;
+    rb_grn_boolean owner;
+};
+
+VALUE rb_cGrnQuery;
+
+static RbGrnQuery *
+rb_rb_grn_query_from_ruby_object (VALUE object)
+{
+    RbGrnQuery *rb_grn_query;
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnQuery))) {
+	rb_raise(rb_eTypeError, "not a groonga query");
+    }
+
+    Data_Get_Struct(object, RbGrnQuery, rb_grn_query);
+    if (!rb_grn_query)
+	rb_raise(rb_eGrnError, "groonga query is NULL");
+
+    return rb_grn_query;
+}
+
+grn_query *
+rb_grn_query_from_ruby_object (VALUE object)
+{
+    if (NIL_P(object))
+        return NULL;
+
+    return SELF(object)->query;
+}
+
+static void
+rb_rb_grn_query_free (void *object)
+{
+    RbGrnQuery *rb_grn_query = object;
+
+    if (rb_grn_query->context && rb_grn_query->query && rb_grn_query->owner)
+	/* grn_query_close(rb_grn_query->context, rb_grn_query->query) */;
+
+    xfree(object);
+}
+
+VALUE
+rb_grn_query_to_ruby_object (grn_ctx *context, grn_query *query)
+{
+    RbGrnQuery *rb_grn_query;
+
+    if (!query)
+        return Qnil;
+
+    rb_grn_query = ALLOC(RbGrnQuery);
+    rb_grn_query->context = context;
+    rb_grn_query->query = query;
+    rb_grn_query->owner = RB_GRN_FALSE;
+
+    return Data_Wrap_Struct(rb_cGrnQuery, NULL,
+                            rb_rb_grn_query_free, rb_grn_query);
+}
+
+static VALUE
+rb_grn_query_alloc (VALUE klass)
+{
+    return Data_Wrap_Struct(klass, NULL, rb_rb_grn_query_free, NULL);
+}
+
+grn_sel_operator
+rb_grn_select_operator_from_ruby_object (VALUE rb_operator)
+{
+    grn_sel_operator operator = GRN_SEL_OR;
+
+    if (NIL_P(rb_operator) ||
+        rb_grn_equal_option(rb_operator, "or") ||
+        rb_grn_equal_option(rb_operator, "||")) {
+        operator = GRN_SEL_OR;
+    } else if (rb_grn_equal_option(rb_operator, "and") ||
+               rb_grn_equal_option(rb_operator, "+") ||
+               rb_grn_equal_option(rb_operator, "&&")) {
+        operator = GRN_SEL_AND;
+    } else if (rb_grn_equal_option(rb_operator, "but") ||
+               rb_grn_equal_option(rb_operator, "not") ||
+               rb_grn_equal_option(rb_operator, "-")) {
+        operator = GRN_SEL_BUT;
+    } else if (rb_grn_equal_option(rb_operator, "adjust") ||
+               rb_grn_equal_option(rb_operator, ">")) {
+        operator = GRN_SEL_ADJUST;
+    } else {
+        rb_raise(rb_eArgError,
+                 "operator should be one of "
+                 "[:or, :||, :and, :+, :&&, :but, :not, :-, :adjust, :>]: <%s>",
+                 rb_grn_inspect(rb_operator));
+    }
+
+    return operator;
+}
+
+static VALUE
+rb_grn_query_initialize (int argc, VALUE *argv, VALUE self)
+{
+    RbGrnQuery *rb_grn_query;
+    grn_ctx *context = NULL;
+    grn_query *query;
+    char *query_string;
+    unsigned int query_string_length;
+    grn_sel_operator default_operator;
+    int max_expressions = RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS;
+    VALUE rb_query_string, options, rb_context, rb_default_operator;
+    VALUE rb_max_expressions;
+
+    rb_scan_args(argc, argv, "11", &rb_query_string, &options);
+
+    query_string = StringValuePtr(rb_query_string);
+    query_string_length = RSTRING_LEN(rb_query_string);
+
+    rb_grn_scan_options(options,
+                        "context", &rb_context,
+                        "default_operator", &rb_default_operator,
+                        "max_expressions", &rb_max_expressions,
+                        NULL);
+
+    context = rb_grn_context_ensure(rb_context);
+
+    default_operator = RVAL2GRNSELECTOPERATOR(rb_default_operator);
+
+    if (!NIL_P(rb_max_expressions))
+        max_expressions = NUM2INT(rb_max_expressions);
+
+    query = grn_query_open(context, query_string, query_string_length,
+                           default_operator, max_expressions);
+    rb_grn_context_check(context, rb_ary_new4(argc, argv));
+
+    rb_grn_query = ALLOC(RbGrnQuery);
+    DATA_PTR(self) = rb_grn_query;
+    rb_grn_query->context = context;
+    rb_grn_query->query = query;
+    rb_grn_query->owner = RB_GRN_TRUE;
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_query_close (VALUE self)
+{
+    RbGrnQuery *rb_grn_query;
+
+    rb_grn_query = SELF(self);
+    if (rb_grn_query->context && rb_grn_query->query) {
+        grn_rc rc;
+
+        rc = grn_query_close(rb_grn_query->context, rb_grn_query->query);
+        rb_grn_query->context = NULL;
+        rb_grn_query->query = NULL;
+        rb_grn_rc_check(rc, self);
+    }
+    return Qnil;
+}
+
+static VALUE
+rb_grn_query_closed_p (VALUE self)
+{
+    RbGrnQuery *rb_grn_query;
+
+    rb_grn_query = SELF(self);
+    if (rb_grn_query->context && rb_grn_query->query)
+        return Qfalse;
+    else
+        return Qtrue;
+}
+
+void
+rb_grn_init_query (VALUE mGrn)
+{
+    rb_cGrnQuery = rb_define_class_under(mGrn, "Query", rb_cObject);
+    rb_define_alloc_func(rb_cGrnQuery, rb_grn_query_alloc);
+
+    rb_define_method(rb_cGrnQuery, "initialize",
+                     rb_grn_query_initialize, -1);
+    rb_define_method(rb_cGrnQuery, "close",
+                     rb_grn_query_close, 0);
+    rb_define_method(rb_cGrnQuery, "closed?",
+                     rb_grn_query_closed_p, 0);
+}

data/ext/rb-grn-record.c

@@ -0,0 +1,33 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "rb-grn.h"
+
+VALUE rb_cGrnRecord;
+
+VALUE
+rb_grn_record_new (VALUE table, grn_id id)
+{
+    return rb_funcall(rb_cGrnRecord, rb_intern("new"), 2, table, UINT2NUM(id));
+}
+
+void
+rb_grn_init_record (VALUE mGrn)
+{
+    rb_cGrnRecord = rb_const_get(mGrn, rb_intern("Record"));
+}

data/ext/rb-grn-snippet.c

@@ -0,0 +1,274 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "rb-grn.h"
+
+#ifdef HAVE_RUBY_ENCODING_H
+#  include <ruby/encoding.h>
+#endif
+
+#define SELF(object) (rb_rb_grn_snippet_from_ruby_object(object))
+
+typedef struct _RbGrnSnippet RbGrnSnippet;
+struct _RbGrnSnippet
+{
+    grn_ctx *context;
+    grn_snip *snippet;
+    rb_grn_boolean owner;
+};
+
+VALUE rb_cGrnSnippet;
+
+static RbGrnSnippet *
+rb_rb_grn_snippet_from_ruby_object (VALUE object)
+{
+    RbGrnSnippet *rb_grn_snippet;
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnSnippet))) {
+	rb_raise(rb_eTypeError, "not a groonga snippet");
+    }
+
+    Data_Get_Struct(object, RbGrnSnippet, rb_grn_snippet);
+    if (!rb_grn_snippet)
+	rb_raise(rb_eGrnError, "groonga snippet is NULL");
+
+    return rb_grn_snippet;
+}
+
+grn_snip *
+rb_grn_snippet_from_ruby_object (VALUE object)
+{
+    if (NIL_P(object))
+        return NULL;
+
+    return SELF(object)->snippet;
+}
+
+static void
+rb_rb_grn_snippet_free (void *object)
+{
+    RbGrnSnippet *rb_grn_snippet = object;
+
+    if (rb_grn_snippet->context && rb_grn_snippet->snippet &&
+	rb_grn_snippet->owner)
+        grn_snip_close(rb_grn_snippet->context,
+                       rb_grn_snippet->snippet);
+
+    xfree(object);
+}
+
+VALUE
+rb_grn_snippet_to_ruby_object (grn_ctx *context, grn_snip *snippet)
+{
+    RbGrnSnippet *rb_grn_snippet;
+
+    if (!snippet)
+        return Qnil;
+
+    rb_grn_snippet = ALLOC(RbGrnSnippet);
+    rb_grn_snippet->context = context;
+    rb_grn_snippet->snippet = snippet;
+    rb_grn_snippet->owner = RB_GRN_FALSE;
+
+    return Data_Wrap_Struct(rb_cGrnSnippet, NULL,
+                            rb_rb_grn_snippet_free, rb_grn_snippet);
+}
+
+static VALUE
+rb_grn_snippet_alloc (VALUE klass)
+{
+    return Data_Wrap_Struct(klass, NULL, rb_rb_grn_snippet_free, NULL);
+}
+
+static VALUE
+rb_grn_snippet_initialize (int argc, VALUE *argv, VALUE self)
+{
+    RbGrnSnippet *rb_grn_snippet;
+    grn_ctx *context = NULL;
+    grn_snip *snippet = NULL;
+    VALUE options;
+    VALUE rb_context, rb_normalize, rb_skip_leading_spaces;
+    VALUE rb_width, rb_max_results, rb_default_open_tag, rb_default_close_tag;
+    VALUE rb_html_escape;
+    int flags = GRN_SNIP_COPY_TAG;
+    unsigned int width = 100;
+    unsigned int max_results = 3;
+    char *default_open_tag = NULL;
+    unsigned int default_open_tag_length = 0;
+    char *default_close_tag = NULL;
+    unsigned int default_close_tag_length = 0;
+    grn_snip_mapping *mapping = NULL;
+
+    rb_scan_args(argc, argv, "01", &options);
+
+    rb_grn_scan_options(options,
+                        "context", &rb_context,
+                        "normalize", &rb_normalize,
+                        "skip_leading_spaces", &rb_skip_leading_spaces,
+                        "width", &rb_width,
+                        "max_results", &rb_max_results,
+                        "default_open_tag", &rb_default_open_tag,
+                        "default_close_tag", &rb_default_close_tag,
+                        "html_escape", &rb_html_escape,
+                        NULL);
+
+    context = rb_grn_context_ensure(rb_context);
+
+    if (RVAL2CBOOL(rb_normalize))
+        flags |= GRN_SNIP_NORMALIZE;
+    if (RVAL2CBOOL(rb_skip_leading_spaces))
+        flags |= GRN_SNIP_SKIP_LEADING_SPACES;
+
+    if (!NIL_P(rb_width))
+        width = NUM2UINT(rb_width);
+
+    if (!NIL_P(rb_max_results))
+        max_results = NUM2UINT(rb_max_results);
+
+    if (!NIL_P(rb_default_open_tag)) {
+        default_open_tag = StringValuePtr(rb_default_open_tag);
+        default_open_tag_length = RSTRING_LEN(rb_default_open_tag);
+    }
+
+    if (!NIL_P(rb_default_close_tag)) {
+        default_close_tag = StringValuePtr(rb_default_close_tag);
+        default_close_tag_length = RSTRING_LEN(rb_default_close_tag);
+    }
+
+    if (RVAL2CBOOL(rb_html_escape))
+        mapping = (grn_snip_mapping *)-1;
+
+    snippet = grn_snip_open(context, flags, width, max_results,
+                            default_open_tag, default_open_tag_length,
+                            default_close_tag, default_close_tag_length,
+                            mapping);
+    rb_grn_context_check(context, rb_ary_new4(argc, argv));
+
+    rb_grn_snippet = ALLOC(RbGrnSnippet);
+    DATA_PTR(self) = rb_grn_snippet;
+    rb_grn_snippet->context = context;
+    rb_grn_snippet->snippet = snippet;
+    rb_grn_snippet->owner = RB_GRN_TRUE;
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_snippet_add_keyword (int argc, VALUE *argv, VALUE self)
+{
+    RbGrnSnippet *rb_grn_snippet;
+    grn_rc rc;
+    VALUE rb_keyword, options;
+    VALUE rb_open_tag, rb_close_tag;
+    char *keyword, *open_tag = NULL, *close_tag = NULL;
+    unsigned int keyword_length, open_tag_length = 0, close_tag_length = 0;
+
+    rb_scan_args(argc, argv, "11", &rb_keyword, &options);
+
+    rb_grn_snippet = SELF(self);
+
+    keyword = StringValuePtr(rb_keyword);
+    keyword_length = RSTRING_LEN(rb_keyword);
+
+    rb_grn_scan_options(options,
+                        "open_tag", &rb_open_tag,
+                        "close_tag", &rb_close_tag,
+                        NULL);
+
+    if (!NIL_P(rb_open_tag)) {
+        open_tag = StringValuePtr(rb_open_tag);
+        open_tag_length = RSTRING_LEN(rb_open_tag);
+    }
+
+    if (!NIL_P(rb_close_tag)) {
+        close_tag = StringValuePtr(rb_close_tag);
+        close_tag_length = RSTRING_LEN(rb_close_tag);
+    }
+
+    rc = grn_snip_add_cond(rb_grn_snippet->context,
+                           rb_grn_snippet->snippet,
+                           keyword, keyword_length,
+                           open_tag, open_tag_length,
+                           close_tag, close_tag_length);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_snippet_execute (VALUE self, VALUE rb_string)
+{
+    RbGrnSnippet *rb_grn_snippet;
+    grn_rc rc;
+    grn_ctx *context;
+    grn_snip *snippet;
+    char *string;
+    unsigned int string_length;
+    unsigned int i, n_results, max_tagged_length;
+    VALUE rb_results;
+    char *result;
+#ifdef HAVE_RUBY_ENCODING_H
+    rb_encoding *encoding;
+#endif
+
+    rb_grn_snippet = SELF(self);
+    context = rb_grn_snippet->context;
+    snippet = rb_grn_snippet->snippet;
+
+    string = StringValuePtr(rb_string);
+    string_length = RSTRING_LEN(rb_string);
+#ifdef HAVE_RUBY_ENCODING_H
+    encoding = rb_enc_get(rb_string);
+#endif
+
+    rc = grn_snip_exec(context, snippet, string, string_length,
+                       &n_results, &max_tagged_length);
+    rb_grn_rc_check(rc, self);
+
+    rb_results = rb_ary_new2(n_results);
+    result = ALLOCA_N(char, max_tagged_length);
+    for (i = 0; i < n_results; i++) {
+        VALUE rb_result;
+        unsigned result_length;
+
+        rc = grn_snip_get_result(context, snippet, i, result, &result_length);
+        rb_grn_rc_check(rc, self);
+#ifdef HAVE_RUBY_ENCODING_H
+        rb_result = rb_enc_str_new(result, result_length, encoding);
+#else
+        rb_result = rb_str_new(result, result_length);
+#endif
+        rb_ary_push(rb_results, rb_result);
+    }
+
+    return rb_results;
+}
+
+void
+rb_grn_init_snippet (VALUE mGrn)
+{
+    rb_cGrnSnippet = rb_define_class_under(mGrn, "Snippet", rb_cObject);
+    rb_define_alloc_func(rb_cGrnSnippet, rb_grn_snippet_alloc);
+
+    rb_define_method(rb_cGrnSnippet, "initialize",
+                     rb_grn_snippet_initialize, -1);
+    rb_define_method(rb_cGrnSnippet, "add_keyword",
+                     rb_grn_snippet_add_keyword, -1);
+    rb_define_method(rb_cGrnSnippet, "execute",
+                     rb_grn_snippet_execute, 1);
+}