rroonga 5.0.4-x86-mingw32 → 5.0.5-x86-mingw32

data/ext/groonga/rb-grn-object.c

@@ -1,7 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
   Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
-  Copyright (C) 2014  Masafumi Yokoyama <myokoym@gmail.com>
+  Copyright (C) 2014-2015  Masafumi Yokoyama <yokoyama@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
@@ -1604,6 +1604,32 @@ rb_grn_object_selector_procedure_p (VALUE self)
     return CBOOL2RVAL(selector_procedure_p);
 }
 
+/*
+ * Checks whether the object is selector only procedure or not.
+ *
+ * @overload selector_only_procedure?
+ *   @return [Boolean] `true` if the object is selector only procedure,
+ *     `false` otherwise.
+ *
+ * @since 5.0.5
+ */
+static VALUE
+rb_grn_object_selector_only_procedure_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *object;
+    grn_bool selector_only_procedure_p = GRN_FALSE;
+
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+                              NULL, NULL, NULL, NULL);
+
+    if (context && object) {
+        selector_only_procedure_p = grn_obj_is_selector_only_proc(context, object);
+    }
+
+    return CBOOL2RVAL(selector_only_procedure_p);
+}
+
 /*
  * Checks whether the object is scorer procedure or not.
  *
@@ -1671,6 +1697,8 @@ rb_grn_init_object (VALUE mGrn)
                      rb_grn_object_function_procedure_p, 0);
     rb_define_method(rb_cGrnObject, "selector_procedure?",
                      rb_grn_object_selector_procedure_p, 0);
+    rb_define_method(rb_cGrnObject, "selector_only_procedure?",
+                     rb_grn_object_selector_only_procedure_p, 0);
     rb_define_method(rb_cGrnObject, "scorer_procedure?",
                      rb_grn_object_scorer_procedure_p, 0);
 }

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

@@ -565,17 +565,10 @@ rb_grn_patricia_trie_open_grn_prefix_cursor (int argc, VALUE *argv, VALUE self,
     } else if (rb_grn_equal_option(rb_order_by, "id")) {
         flags |= GRN_CURSOR_BY_ID;
     } else if (rb_grn_equal_option(rb_order_by, "key")) {
-        if (table->header.type != GRN_TABLE_PAT_KEY) {
-            rb_raise(rb_eArgError,
-                     "order_by => :key is available "
-                     "only for Groonga::PatriciaTrie: %s",
-                     rb_grn_inspect(self));
-        }
         flags |= GRN_CURSOR_BY_KEY;
     } else {
         rb_raise(rb_eArgError,
-                 "order_by should be one of [:id%s]: %s",
-                 table->header.type == GRN_TABLE_PAT_KEY ? ", :key" : "",
+                 "order_by should be one of [:id, :key]: %s",
                  rb_grn_inspect(rb_order_by));
     }
 

data/ext/groonga/rb-grn-table-cursor.c

@@ -107,11 +107,16 @@ rb_grn_table_cursor_order_by_to_flag (unsigned char table_type,
     } else if (rb_grn_equal_option(rb_order_by, "id")) {
         flag |= GRN_CURSOR_BY_ID;
     } else if (rb_grn_equal_option(rb_order_by, "key")) {
-        if (table_type != GRN_TABLE_PAT_KEY) {
+        switch (table_type) {
+        case GRN_TABLE_PAT_KEY:
+        case GRN_TABLE_DAT_KEY:
+            break;
+        default:
             rb_raise(rb_eArgError,
-                     "order_by => :key is available "
-                     "only for Groonga::PatriciaTrie: %s",
+                     "order_by => :key is available only for "
+                     "Groonga::PatriciaTrie and Groonga::DoubleArrayTrie: %s",
                      rb_grn_inspect(rb_table));
+            break;
         }
         flag |= GRN_CURSOR_BY_KEY;
     } else {

data/ext/groonga/rb-grn-table.c

@@ -819,11 +819,16 @@ rb_grn_table_open_grn_cursor (int argc, VALUE *argv, VALUE self,
  *     +:desc+ または +:descending+ を指定すると降順にレコードを
  *     取り出す。
  *   @option options :order_by
- *     +:id+ を指定するとID順にレコードを取り出す。（Arrayと
- *     Hashのデフォルト）
- *     +:key+ 指定するとキー順にレコードを取り出す。ただし、
- *     Groonga::PatriciaTrieにしか使えない。（PatriciaTrieのデ
- *     フォルト）
+ *
+ *     `:id` means that the cursor returns the next record by ID
+ *     order. It's the default for `Groonga::Array` and
+ *     `Groonga::Hash`.
+ *
+ *     `:key` means that the cursor returns the next record by key
+ *     order.  You can use it only for `Groonga::PatriciaTrie` and
+ *     `Groonga::DoubleArrayTrie`. It's the default for
+ *     `Groonga::PatriciaTrie` and `Groonga::DoubleArrayTrie`.
+ *
  *   @option options :greater_than
  *     +true+ を指定すると +:min+ で指定した値に一致した [ +key+ ] を
  *     範囲に含まない。

data/ext/groonga/rb-grn-thread.c

@@ -0,0 +1,160 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2015  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "rb-grn.h"
+
+static ID id_call;
+
+/*
+ * Document-class: Groonga::Thread
+ *
+ * It's a namespace for thread related features.
+ */
+
+/*
+ * @overload limit()
+ *
+ *   @return [Integer] the max number of threads. `0` means that
+ *     thread isn't supported.
+ *
+ * @since 5.0.5
+ */
+static VALUE
+rb_grn_thread_s_get_limit (VALUE self)
+{
+    uint32_t limit;
+
+    limit = grn_thread_get_limit();
+
+    return UINT2NUM(limit);
+}
+
+/*
+ * @overload limit=(new_limit)
+ *
+ *   Sets the max number of threads.
+ *
+ *   @param new_limit [Integer] The new max number of threads.
+ *
+ *   @return [void]
+ *
+ * @since 5.0.5
+ */
+static VALUE
+rb_grn_thread_s_set_limit (VALUE self, VALUE rb_new_limit)
+{
+    uint32_t new_limit;
+
+    new_limit = NUM2UINT(rb_new_limit);
+    grn_thread_set_limit(new_limit);
+
+    return Qnil;
+}
+
+static uint32_t
+rb_grn_thread_get_limit_func (void *data)
+{
+    VALUE callable = (VALUE)data;
+    VALUE rb_limit;
+
+    rb_limit = rb_funcall(callable, id_call, 0);
+
+    return NUM2UINT(rb_limit);
+}
+
+/*
+ * @overload limit_getter=(getter)
+ *
+ *   Sets a callable object that returns the max number of threads.
+ *
+ *   @param getter [#call] Callable object that returns the max number
+ *     of threads.
+ *
+ *   @return [void]
+ *
+ * @since 5.0.5
+ */
+static VALUE
+rb_grn_thread_s_set_limit_getter (VALUE self, VALUE rb_getter)
+{
+    rb_iv_set(self, "@limit_getter", rb_getter);
+
+    if (NIL_P(rb_getter)) {
+        grn_thread_set_get_limit_func(NULL, NULL);
+    } else {
+        grn_thread_set_get_limit_func(rb_grn_thread_get_limit_func,
+                                      (void *)rb_getter);
+    }
+
+    return Qnil;
+}
+
+static void
+rb_grn_thread_set_limit_func (uint32_t new_limit, void *data)
+{
+    VALUE callable = (VALUE)data;
+
+    rb_funcall(callable, id_call, 1, UINT2NUM(new_limit));
+}
+
+/*
+ * @overload limit_setter=(setter)
+ *
+ *   Sets a callable object that sets the max number of threads.
+ *
+ *   @param setter [#call] Callable object that sets the max number
+ *     of threads.
+ *
+ *   @return [void]
+ *
+ * @since 5.0.5
+ */
+static VALUE
+rb_grn_thread_s_set_limit_setter (VALUE self, VALUE rb_setter)
+{
+    rb_iv_set(self, "@limit_setter", rb_setter);
+
+    if (NIL_P(rb_setter)) {
+        grn_thread_set_set_limit_func(NULL, NULL);
+    } else {
+        grn_thread_set_set_limit_func(rb_grn_thread_set_limit_func,
+                                      (void *)rb_setter);
+    }
+
+    return Qnil;
+}
+
+void
+rb_grn_init_thread (VALUE mGrn)
+{
+    VALUE rb_mGrnThread;
+
+    CONST_ID(id_call, "call");
+
+    rb_mGrnThread = rb_define_module_under(mGrn, "Thread");
+
+    rb_define_singleton_method(rb_mGrnThread, "limit",
+                               rb_grn_thread_s_get_limit, 0);
+    rb_define_singleton_method(rb_mGrnThread, "limit=",
+                               rb_grn_thread_s_set_limit, 1);
+
+    rb_define_singleton_method(rb_mGrnThread, "limit_getter=",
+                               rb_grn_thread_s_set_limit_getter, 1);
+    rb_define_singleton_method(rb_mGrnThread, "limit_setter=",
+                               rb_grn_thread_s_set_limit_setter, 1);
+}

data/ext/groonga/rb-grn-windows-event-logger.c

@@ -0,0 +1,79 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2015  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "rb-grn.h"
+
+/*
+ * Document-class: Groonga::WindowsEventLogger
+ *
+ * It's a module for using Windows Event Log as log output.
+ */
+
+/*
+ * @overload register(event_source_name, options={})
+ *
+ *   Registers Windows Event Log based logger that uses
+ *   `event_source_name` as event source name.
+ *
+ *   @param event_source_name [String] The event source name.
+ *   @param options [::Hash]
+ *   @option options :context [Groonga::Context] (Groonga::Context.default)
+ *     The context to be set logger.
+ *
+ *   @return [void]
+ *
+ *   @since 5.0.5
+ */
+static VALUE
+rb_grn_windows_event_logger_s_register (int argc,
+                                        VALUE *argv,
+                                        VALUE klass)
+{
+    VALUE rb_event_source_name;
+    VALUE rb_options;
+    VALUE rb_context;
+    const char *event_source_name;
+    grn_ctx *context;
+    grn_rc rc;
+
+    rb_scan_args(argc, argv, "11", &rb_event_source_name, &rb_options);
+    rb_event_source_name = rb_grn_convert_to_string(rb_event_source_name);
+    event_source_name = StringValueCStr(rb_event_source_name);
+
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        NULL);
+    context = rb_grn_context_ensure(&rb_context);
+
+    rc = grn_windows_event_logger_set(context, event_source_name);
+    rb_grn_context_check(context, rb_event_source_name);
+    rb_grn_rc_check(rc, rb_event_source_name);
+
+    return Qnil;
+}
+
+void
+rb_grn_init_windows_event_logger (VALUE mGrn)
+{
+    VALUE mGrnWindowsEventLogger;
+
+    mGrnWindowsEventLogger = rb_define_module_under(mGrn, "WindowsEventLogger");
+
+    rb_define_singleton_method(mGrnWindowsEventLogger, "register",
+                               rb_grn_windows_event_logger_s_register, -1);
+}

data/ext/groonga/rb-grn.h

@@ -101,7 +101,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 5
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 4
+#define RB_GRN_MICRO_VERSION 5
 
 #define RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS 32
 
@@ -349,9 +349,11 @@ void           rb_grn_init_expression               (VALUE mGrn);
 void           rb_grn_init_expression_builder       (VALUE mGrn);
 void           rb_grn_init_logger                   (VALUE mGrn);
 void           rb_grn_init_query_logger             (VALUE mGrn);
+void           rb_grn_init_windows_event_logger     (VALUE mGrn);
 void           rb_grn_init_snippet                  (VALUE mGrn);
 void           rb_grn_init_plugin                   (VALUE mGrn);
 void           rb_grn_init_normalizer               (VALUE mGrn);
+void           rb_grn_init_thread                   (VALUE mGrn);
 
 VALUE          rb_grn_rc_to_exception               (grn_rc rc);
 const char    *rb_grn_rc_to_message                 (grn_rc rc);

data/ext/groonga/rb-groonga.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2015  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
@@ -187,7 +187,9 @@ Init_groonga (void)
     rb_grn_init_expression_builder(mGrn);
     rb_grn_init_logger(mGrn);
     rb_grn_init_query_logger(mGrn);
+    rb_grn_init_windows_event_logger(mGrn);
     rb_grn_init_snippet(mGrn);
     rb_grn_init_plugin(mGrn);
     rb_grn_init_normalizer(mGrn);
+    rb_grn_init_thread(mGrn);
 }

data/lib/groonga/dumper.rb

@@ -704,7 +704,12 @@ module Groonga
     end
 
     def dump_records(columns)
-      @table.each(:order_by => @options[:order_by]) do |record|
+      order_by = @options[:order_by]
+      case @table
+      when Groonga::Array, Groonga::Hash
+        order_by = nil if order_by == :key
+      end
+      @table.each(:order_by => order_by) do |record|
         write(",\n")
         values = columns.collect do |column|
           resolve_value(record, column, column[record.id])

data/rroonga-build.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 #
+# Copyright (C) 2009-2015  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2015  Masafumi Yokoyama <yokoyama@clear-code.com>
-# Copyright (C) 2009-2014  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
@@ -20,15 +20,15 @@ module RroongaBuild
   module RequiredGroongaVersion
     MAJOR = 5
     MINOR = 0
-    MICRO = 5
+    MICRO = 7
     VERSION = [MAJOR, MINOR, MICRO]
-    RELEASED_DATE = Time.utc(2015, 6, 29)
+    RELEASED_DATE = Time.utc(2015, 8, 31)
   end
 
   module LatestGroongaVersion
     MAJOR = 5
     MINOR = 0
-    MICRO = 5
+    MICRO = 7
     VERSION = [MAJOR, MINOR, MICRO]
   end