rroonga 5.0.1-x64-mingw32 → 5.0.2-x64-mingw32

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Y2FiNGZiZmFmNDI5OWY3Y2Y4N2EwZmU3ZmIwYjk3MTQ2ZjAxYmI4Nw==
+    ODc5NWQzZWJjMDcwZTgxMTdjOTA2MzU0Y2I0NTZhNWY0NzQ4MzdmYg==
   data.tar.gz: !binary |-
-    NzlmYjRhOGU4YjY1NjAyMmFhNTQzNjBmNTI1MjYyMjc5MzI0MThkZA==
+    OWU1NGFkZWVjMjZiOTk2NGZlZTNmYjZmOWIzYmFjNmEzMTM5YTgxZA==
 SHA512:
   metadata.gz: !binary |-
-    YWM5NWZiZjQ2YjhiNTFiMzA5Y2VkZTFmMWFjN2E3YmVhOTVjOGEyODYwZWZh
-    MGI4YWE0ODQwNDI4M2IxNjdiZTRmM2YxZTg1ODFkMDYwOTdhNWI3Y2Q1MzQz
-    MGQyMTQ4NGI2MjUwNTlhMTI0Yjg0NWNkMzk0OTM1YTQ1OGI2ZjM=
+    MTdjNzY2NDlkMjM5MzYwNzg5YzYzOTVlNDU2YWFhZjFhMmQ5ZDNlYmU3ODBm
+    ODU5YzJjNjY1ZWQ2YTZkZTU5MzIxOTc0NzUyNzI3MmRkMzQzMTkzM2MwZDdl
+    NTBmZmQxMzhhMTNiNjNlOGVhNjViODM4MjQ5NWQyNGMyNTUzOGU=
   data.tar.gz: !binary |-
-    YWVlY2EzNGIwMTYxMjNmN2MwZTg0MTVjOWNjMmNjOGQ0ZDcwNGE0N2M5NjBk
-    NDRmYmM1ZTI0ODEwZTM2OGUzMTc2YWI0MmNlZjg1NDI0NmFmMjhmZjE3Mzlj
-    YzJmYWVkNTgyODE5ODkxOTE0MmZmZWU5ZTU5MDc1ZjlmZWFmMGE=
+    NDBhYTcwNTAwMTk2MTE3NWE5NDdjMDJlNTdkZGRhMmNiZDk2ZmU0ZTRkZjI1
+    N2RmOTI3YTYyOTFkZWIxMWYzNmQxNjQ1ODlmYmJiODI2OWVjOTliZTIzODIz
+    ODJmYWM2MjZhMjlmYmRhMWFmOGMzYzZjYTM2NWY2ZmQ0NDdhOWY=

data/README.md

@@ -40,7 +40,7 @@ contributed patches.)
 ## Dependencies
 
 * Ruby >= 1.9.3
-* Groonga >= 5.0.0
+* Groonga >= 5.0.2
 
 ## Install
 

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2013  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
@@ -32,6 +32,11 @@ VALUE cGrnLogger;
 VALUE mGrnLoggerFlags;
 VALUE cGrnCallbackLogger;
 
+static ID id_caller_locations;
+static ID id_path;
+static ID id_lineno;
+static ID id_label;
+
 static ID id_new;
 static ID id_parse;
 static ID id_log;
@@ -122,6 +127,96 @@ rb_grn_log_level_to_ruby_object (grn_log_level level)
     return rb_level;
 }
 
+/*
+ * Logs a message.
+ *
+ * @overload log(message, options={})
+ *   @param message [String] The log message.
+ *   @param options [::Hash]
+ *   @option options :context [Groonga::Context] (Groonga::Context.default)
+ *     The context for the message.
+ *   @option options :level [nil, :none, :emergency, :alert, :critical,
+ *     :error, :warning, :notice, :info, :debug, :dump] (:notice)
+ *     The level for the message.
+ *
+ *     `nil` equals to `:notice`.
+ *   @option options :file [nil, String] (nil)
+ *     The file name where the message is occurred.
+ *
+ *     If all of `:file`, `:line` and `:function` are nil, these
+ *     values are guessed from `Kernel.#caller_locations` result.
+ *   @option options :line [nil, Integer] (nil)
+ *     The line number where the message is occurred.
+ *   @option options :function [nil, String] (nil)
+ *     The function or related name such as method name where the
+ *     message is occurred.
+ *   @return [void]
+ *
+ * @since 5.0.2
+ */
+static VALUE
+rb_grn_logger_s_log (int argc, VALUE *argv, VALUE klass)
+{
+    VALUE rb_message;
+    const char *message;
+    VALUE rb_context = Qnil;
+    grn_ctx *context;
+    VALUE rb_level;
+    grn_log_level level = GRN_LOG_DEFAULT_LEVEL;
+    VALUE rb_file;
+    const char *file = NULL;
+    VALUE rb_line;
+    int line;
+    VALUE rb_function;
+    const char *function = NULL;
+    VALUE rb_options;
+
+    rb_scan_args(argc, argv, "11", &rb_message, &rb_options);
+
+    message = StringValueCStr(rb_message);
+
+    rb_grn_scan_options(rb_options,
+                        "context",  &rb_context,
+                        "level",    &rb_level,
+                        "file",     &rb_file,
+                        "line",     &rb_line,
+                        "function", &rb_function,
+                        NULL);
+
+    context = rb_grn_context_ensure(&rb_context);
+
+    if (!NIL_P(rb_level)) {
+        level = RVAL2GRNLOGLEVEL(rb_level);
+    }
+
+    if (NIL_P(rb_file) && NIL_P(rb_line) && NIL_P(rb_function)) {
+        VALUE rb_locations;
+        VALUE rb_location;
+        rb_locations = rb_funcall(rb_cObject,
+                                  id_caller_locations,
+                                  2,
+                                  INT2NUM(1), INT2NUM(1));
+        rb_location = RARRAY_PTR(rb_locations)[0];
+        rb_file = rb_funcall(rb_location, id_path, 0);
+        rb_line = rb_funcall(rb_location, id_lineno, 0);
+        rb_function = rb_funcall(rb_location, id_label, 0);
+    }
+
+    if (!NIL_P(rb_file)) {
+        file = StringValueCStr(rb_file);
+    }
+    if (!NIL_P(rb_line)) {
+        line = NUM2INT(rb_line);
+    }
+    if (!NIL_P(rb_function)) {
+        function = StringValueCStr(rb_function);
+    }
+
+    grn_logger_put(context, level, file, line, function, "%s", message);
+
+    return Qnil;
+}
+
 static void
 rb_grn_logger_reset_with_error_check (VALUE klass, grn_ctx *context)
 {
@@ -344,7 +439,7 @@ rb_grn_logger_s_reopen (VALUE klass)
 }
 
 /*
- * Gets the current log path that is used the default logger.
+ * Gets the current log path that is used by the default logger.
  *
  * @overload path
  *   @return [String or nil] The current log path
@@ -365,7 +460,7 @@ rb_grn_logger_s_get_path (VALUE klass)
 }
 
 /*
- * Sets the log path that is used the default logger. If you're using
+ * Sets the log path that is used by the default logger. If you're using
  * custom logger by {.register}, the log path isn't used. Because it
  * is for the default logger.
  *
@@ -411,9 +506,64 @@ rb_grn_logger_s_set_path (VALUE klass, VALUE rb_path)
     return Qnil;
 }
 
+/*
+ * Gets the current rotate threshold size that is used by the default
+ * logger.
+ *
+ * If the size is larger than 0, log rotate feature is enabled in the
+ * default logger.
+ *
+ * @overload threshold
+ *   @return [Integer] The current rotate threshold size
+ *
+ * @since 5.0.2
+ */
+static VALUE
+rb_grn_logger_s_get_rotate_threshold_size (VALUE klass)
+{
+    return OFFT2NUM(grn_default_logger_get_rotate_threshold_size());
+}
+
+/*
+ * Sets the rotate threshold size that is used by the default
+ * logger. If you're using custom logger by {.register}, the rotate
+ * threshold size isn't used. Because it is for the default logger.
+ *
+ * If you specify `0` as size, log rotation by the default logger is
+ * disabled.
+ *
+ * The default rotate threshold size is 0. It means that log rotation
+ * is disabled by default.
+ *
+ * @example Changes the rotate threshold size for the default logger
+ *   Groonga::Logger.rotate_threshold_size = 1 * 1024 * 1024 # 1MiB
+ *
+ * @example Disables log ration by the default logger
+ *   Groonga::Logger.rotate_threshold_size = 0
+ *
+ * @overload rotate_threshold_size=(size)
+ *   @param size [Integer] The log path for the default logger.
+ *     If nil is specified, log rotate by the default logger is disabled.
+ *   @return void
+ *
+ * @since 5.0.2
+ */
+static VALUE
+rb_grn_logger_s_set_rotate_threshold_size (VALUE klass, VALUE rb_size)
+{
+    grn_default_logger_set_rotate_threshold_size(NUM2OFFT(rb_size));
+
+    return Qnil;
+}
+
 void
 rb_grn_init_logger (VALUE mGrn)
 {
+    id_caller_locations = rb_intern("caller_locations");
+    id_path             = rb_intern("path");
+    id_lineno           = rb_intern("lineno");
+    id_label            = rb_intern("label");
+
     id_new    = rb_intern("new");
     id_parse  = rb_intern("parse");
     id_log    = rb_intern("log");
@@ -429,6 +579,8 @@ rb_grn_init_logger (VALUE mGrn)
     cGrnLogger = rb_define_class_under(mGrn, "Logger", rb_cObject);
 
     rb_cv_set(cGrnLogger, "@@current_logger", Qnil);
+    rb_define_singleton_method(cGrnLogger, "log",
+                               rb_grn_logger_s_log, -1);
     rb_define_singleton_method(cGrnLogger, "register",
                                rb_grn_logger_s_register, -1);
     rb_define_singleton_method(cGrnLogger, "unregister",
@@ -439,6 +591,10 @@ rb_grn_init_logger (VALUE mGrn)
                                rb_grn_logger_s_get_path, 0);
     rb_define_singleton_method(cGrnLogger, "path=",
                                rb_grn_logger_s_set_path, 1);
+    rb_define_singleton_method(cGrnLogger, "rotate_threshold_size",
+                               rb_grn_logger_s_get_rotate_threshold_size, 0);
+    rb_define_singleton_method(cGrnLogger, "rotate_threshold_size=",
+                               rb_grn_logger_s_set_rotate_threshold_size, 1);
     rb_set_end_proc(rb_grn_logger_reset, cGrnLogger);
 
     mGrnLoggerFlags = rb_define_module_under(cGrnLogger, "Flags");

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2011  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2011-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
@@ -191,6 +191,20 @@ rb_grn_plugin_s_suffix (VALUE klass)
     return rb_str_new_cstr(grn_plugin_get_suffix());
 }
 
+/*
+ * Returns the plugin file suffix written in Ruby. It returns ".rb".
+ *
+ * @overload ruby_suffix
+ *   @return [String]
+ *
+ * @since 5.0.2
+ */
+static VALUE
+rb_grn_plugin_s_ruby_suffix (VALUE klass)
+{
+    return rb_str_new_cstr(grn_plugin_get_ruby_suffix());
+}
+
 void
 rb_grn_init_plugin (VALUE mGrn)
 {
@@ -205,4 +219,6 @@ rb_grn_init_plugin (VALUE mGrn)
                                rb_grn_plugin_s_system_plugins_dir, 0);
     rb_define_singleton_method(cGrnPlugin, "suffix",
                                rb_grn_plugin_s_suffix, 0);
+    rb_define_singleton_method(cGrnPlugin, "ruby_suffix",
+                               rb_grn_plugin_s_ruby_suffix, 0);
 }

data/ext/groonga/rb-grn-query-logger.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2012-2013  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2012-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
@@ -45,6 +45,72 @@ rb_grn_query_log_flags_to_ruby_object (unsigned int flags)
     return UINT2NUM(flags);
 }
 
+/*
+ * Logs a message.
+ *
+ * @overload log(message, options={})
+ *   @param message [String] The log message.
+ *   @param options [::Hash]
+ *   @option options :context [Groonga::Context] (Groonga::Context.default)
+ *     The context for the message.
+ *   @option options :flags [nil, Integer, String] (0)
+ *     The flags for the message.
+ *
+ *     The flags are passed to query logger. You can custom query
+ *     logger behavior by the flags. For example, you can omit elapsed
+ *     time by passing `Groonga::QueryLogger::COMMAND` flag or
+ *     `Groonga::QueryLogger::DESTINATION`.
+ *
+ *     If `:flags` value is `String`, parsed by
+ *     {Groonga::QueryLogger.parse}.
+ *
+ *     `nil` equals to `0`.
+ *   @option options :mark [String] ("")
+ *     The mark for the message.
+ *
+ *     Normally, a character is used as a mark such as `":"`, `"<"` and `">"`.
+ *   @return [void]
+ *
+ * @since 5.0.2
+ */
+static VALUE
+rb_grn_query_logger_s_log (int argc, VALUE *argv, VALUE klass)
+{
+    VALUE rb_message;
+    const char *message;
+    VALUE rb_context = Qnil;
+    grn_ctx *context;
+    VALUE rb_flags;
+    unsigned int flags = GRN_QUERY_LOG_NONE;
+    VALUE rb_mark;
+    const char *mark = "";
+    VALUE rb_options;
+
+    rb_scan_args(argc, argv, "11", &rb_message, &rb_options);
+
+    message = StringValueCStr(rb_message);
+
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        "flags",   &rb_flags,
+                        "mark",    &rb_mark,
+                        NULL);
+
+    context = rb_grn_context_ensure(&rb_context);
+
+    if (!NIL_P(rb_flags)) {
+        flags = rb_funcall(mGrnQueryLoggerFlags, id_parse, 2,
+                           rb_flags, UINT2NUM(flags));
+    }
+    if (!NIL_P(rb_mark)) {
+        mark = StringValueCStr(rb_mark);
+    }
+
+    grn_query_logger_put(context, flags, mark, "%s", message);
+
+    return Qnil;
+}
+
 static void
 rb_grn_query_logger_log (grn_ctx *ctx, unsigned int flag,
                          const char *timestamp, const char *info,
@@ -100,7 +166,7 @@ rb_grn_query_logger_fin (grn_ctx *ctx, void *user_data)
  *     @option options [Symbol, String, Integer or nil] :flags (:default)
  *       Flags describe what query log should be logged.
  *
- *       If @flags@ is String, it is parsed by {QueryLogger::Flags.parse}.
+ *       If `flags` is String, it is parsed by {QueryLogger::Flags.parse}.
  *
  *   @return void
  *
@@ -164,7 +230,7 @@ rb_grn_query_logger_s_register (int argc, VALUE *argv, VALUE klass)
     }
     if (!NIL_P(rb_flags)) {
         flags = rb_funcall(mGrnQueryLoggerFlags, id_parse, 2,
-                           UINT2NUM(flags), rb_flags);
+                           rb_flags, UINT2NUM(flags));
     }
 
     rb_grn_query_logger.flags     = flags;
@@ -287,6 +353,58 @@ rb_grn_query_logger_s_set_path (VALUE klass, VALUE rb_path)
     return Qnil;
 }
 
+/*
+ * Gets the current rotate threshold size that is used by the default
+ * query logger.
+ *
+ * If the size is larger than 0, log rotate feature is enabled in the
+ * default query logger.
+ *
+ * @overload threshold
+ *   @return [Integer] The current rotate threshold size
+ *
+ * @since 5.0.2
+ */
+static VALUE
+rb_grn_query_logger_s_get_rotate_threshold_size (VALUE klass)
+{
+    return OFFT2NUM(grn_default_query_logger_get_rotate_threshold_size());
+}
+
+/*
+ * Sets the rotate threshold size that is used by the default query
+ * logger. If you're using custom query logger by {.register}, the
+ * rotate threshold size isn't used. Because it is for the default
+ * query logger.
+ *
+ * If you specify `0` as size, log rotation by the default query
+ * logger is disabled.
+ *
+ * The default rotate threshold size is 0. It means that log rotation
+ * is disabled by default.
+ *
+ * @example Changes the rotate threshold size for the default query logger
+ *   Groonga::QueryLogger.rotate_threshold_size = 1 * 1024 * 1024 # 1MiB
+ *
+ * @example Disables log ration by the default query logger
+ *   Groonga::QueryLogger.rotate_threshold_size = 0
+ *
+ * @overload rotate_threshold_size=(size)
+ *   @param size [Integer] The log path for the default query logger.
+ *     If nil is specified, log rotate by the default query logger is
+ *     disabled.
+ *   @return void
+ *
+ * @since 5.0.2
+ */
+static VALUE
+rb_grn_query_logger_s_set_rotate_threshold_size (VALUE klass, VALUE rb_size)
+{
+    grn_default_query_logger_set_rotate_threshold_size(NUM2OFFT(rb_size));
+
+    return Qnil;
+}
+
 void
 rb_grn_init_query_logger (VALUE mGrn)
 {
@@ -305,6 +423,8 @@ rb_grn_init_query_logger (VALUE mGrn)
     cGrnQueryLogger = rb_define_class_under(mGrn, "QueryLogger", rb_cObject);
 
     rb_cv_set(cGrnQueryLogger, "@@current_logger", Qnil);
+    rb_define_singleton_method(cGrnQueryLogger, "log",
+                               rb_grn_query_logger_s_log, -1);
     rb_define_singleton_method(cGrnQueryLogger, "register",
                                rb_grn_query_logger_s_register, -1);
     rb_define_singleton_method(cGrnQueryLogger, "unregister",
@@ -315,6 +435,12 @@ rb_grn_init_query_logger (VALUE mGrn)
                                rb_grn_query_logger_s_get_path, 0);
     rb_define_singleton_method(cGrnQueryLogger, "path=",
                                rb_grn_query_logger_s_set_path, 1);
+    rb_define_singleton_method(cGrnQueryLogger, "rotate_threshold_size",
+                               rb_grn_query_logger_s_get_rotate_threshold_size,
+                               0);
+    rb_define_singleton_method(cGrnQueryLogger, "rotate_threshold_size=",
+                               rb_grn_query_logger_s_set_rotate_threshold_size,
+                               1);
 
     mGrnQueryLoggerFlags = rb_define_module_under(cGrnQueryLogger, "Flags");
 #define DEFINE_FLAG(NAME)                                       \