rroonga 3.0.5 → 3.0.6

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

@@ -23,7 +23,7 @@ VALUE rb_cGrnPosting;
 
 VALUE
 rb_grn_posting_new (grn_posting *posting, grn_id term_id,
-		    VALUE rb_table, VALUE rb_lexicon)
+                    VALUE rb_table, VALUE rb_lexicon)
 {
     VALUE parameters;
 
@@ -46,7 +46,7 @@ rb_grn_posting_new (grn_posting *posting, grn_id term_id,
     rb_hash_aset(parameters, ID2SYM(rb_intern("lexicon")), rb_lexicon);
 
     return rb_funcall(rb_cGrnPosting, rb_intern("new"), 1,
-		      parameters);
+                      parameters);
 }
 
 void

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

@@ -26,7 +26,7 @@ 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");
+        rb_raise(rb_eTypeError, "not a groonga procedure");
     }
 
     return RVAL2GRNOBJECT(object, NULL);
@@ -34,7 +34,7 @@ rb_grn_procedure_from_ruby_object (VALUE object)
 
 VALUE
 rb_grn_procedure_to_ruby_object (grn_ctx *context, grn_obj *procedure,
-				 grn_bool owner)
+                                 grn_bool owner)
 {
     return GRNOBJECT2RVAL(rb_cGrnProcedure, context, procedure, owner);
 }

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

@@ -234,7 +234,7 @@ rb_grn_query_logger_s_get_path (VALUE klass)
 
     path = grn_default_query_logger_get_path();
     if (path) {
-	rb_path = rb_str_new2(path);
+        rb_path = rb_str_new2(path);
     }
     return rb_path;
 }

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

@@ -40,7 +40,7 @@ VALUE
 rb_grn_record_new_raw (VALUE table, VALUE rb_id, VALUE values)
 {
     return rb_funcall(rb_cGrnRecord, rb_intern("new"), 3,
-		      table, rb_id, values);
+                      table, rb_id, values);
 }
 
 void

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

@@ -30,28 +30,28 @@ VALUE rb_cGrnSnippet;
 
 void
 rb_grn_snippet_finalizer (grn_ctx *context, grn_obj *object,
-			  RbGrnSnippet *rb_grn_snippet)
+                          RbGrnSnippet *rb_grn_snippet)
 {
     rb_grn_context_unregister_floating_object(RB_GRN_OBJECT(rb_grn_snippet));
 }
 
 void
 rb_grn_snippet_bind (RbGrnSnippet *rb_grn_snippet,
-		     grn_ctx *context, grn_obj *snippet)
+                     grn_ctx *context, grn_obj *snippet)
 {
 }
 
 void
 rb_grn_snippet_deconstruct (RbGrnSnippet *rb_grn_snippet,
-			    grn_obj **snippet,
-			    grn_ctx **context)
+                            grn_obj **snippet,
+                            grn_ctx **context)
 {
     RbGrnObject *rb_grn_object;
 
     rb_grn_object = RB_GRN_OBJECT(rb_grn_snippet);
     rb_grn_object_deconstruct(rb_grn_object, snippet, context,
-			      NULL, NULL,
-			      NULL, NULL);
+                              NULL, NULL,
+                              NULL, NULL);
 }
 
 /*
@@ -112,10 +112,10 @@ rb_grn_snippet_initialize (int argc, VALUE *argv, VALUE self)
 
     context = rb_grn_context_ensure(&rb_context);
     if (!grn_ctx_db(context)) {
-	rb_raise(rb_eArgError,
-		 "Groonga::Context should be associated with a database by "
-		 "Groonga::Database#open or #create: %s",
-		 rb_grn_inspect(rb_context));
+        rb_raise(rb_eArgError,
+                 "Groonga::Context should be associated with a database by "
+                 "Groonga::Database#open or #create: %s",
+                 rb_grn_inspect(rb_context));
     }
 
     if (RVAL2CBOOL(rb_normalize))
@@ -234,9 +234,9 @@ rb_grn_snippet_execute (VALUE self, VALUE rb_string)
     rb_grn_snippet_deconstruct(SELF(self), &snippet, &context);
 
     if (TYPE(rb_string) != T_STRING) {
-	rb_raise(rb_eGrnInvalidArgument,
-		 "snippet text must be String: <%s>",
-		 rb_grn_inspect(rb_string));
+        rb_raise(rb_eGrnInvalidArgument,
+                 "snippet text must be String: <%s>",
+                 rb_grn_inspect(rb_string));
     }
 
 #ifdef HAVE_RUBY_ENCODING_H
@@ -257,7 +257,7 @@ rb_grn_snippet_execute (VALUE self, VALUE rb_string)
         unsigned result_length;
 
         rc = grn_snip_get_result(context, (grn_snip *)snippet,
-				 i, result, &result_length);
+                                 i, result, &result_length);
         rb_grn_rc_check(rc, self);
         rb_result = rb_grn_context_rb_string_new(context, result, result_length);
         rb_ary_push(rb_results, rb_result);

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

@@ -44,13 +44,13 @@ rb_grn_table_cursor_get_key (VALUE self)
     grn_table_cursor *cursor;
 
     rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
-				    NULL, NULL, NULL, NULL);
+                                    NULL, NULL, NULL, NULL);
     if (context && cursor) {
         void *key;
         int key_size;
-	grn_obj *table;
+        grn_obj *table;
 
-	table = grn_table_cursor_table(context, cursor);
+        table = grn_table_cursor_table(context, cursor);
         key_size = grn_table_cursor_get_key(context, cursor, &key);
         rb_key = GRNKEY2RVAL(context, key, key_size, table, self);
     }
@@ -62,7 +62,7 @@ void
 rb_grn_init_table_cursor_key_support (VALUE mGrn)
 {
     rb_mGrnTableCursorKeySupport =
-	rb_define_module_under(rb_cGrnTableCursor, "KeySupport");
+        rb_define_module_under(rb_cGrnTableCursor, "KeySupport");
 
     rb_define_method(rb_mGrnTableCursorKeySupport, "key",
                      rb_grn_table_cursor_get_key, 0);

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

@@ -35,38 +35,38 @@ rb_grn_table_cursor_from_ruby_object (VALUE object, grn_ctx **context)
     grn_table_cursor *table_cursor;
 
     if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnTableCursor))) {
-	rb_raise(rb_eTypeError, "not a groonga table cursor");
+        rb_raise(rb_eTypeError, "not a groonga table cursor");
     }
 
     rb_grn_table_cursor_deconstruct(SELF(object), &table_cursor, NULL,
-				    NULL, NULL,
-				    NULL, NULL);
+                                    NULL, NULL,
+                                    NULL, NULL);
     return table_cursor;
 }
 
 VALUE
 rb_grn_table_cursor_to_ruby_object (VALUE klass, grn_ctx *context,
-				    grn_table_cursor *cursor,
-				    grn_bool owner)
+                                    grn_table_cursor *cursor,
+                                    grn_bool owner)
 {
     return GRNOBJECT2RVAL(klass, context, cursor, owner);
 }
 
 void
 rb_grn_table_cursor_deconstruct (RbGrnTableCursor *rb_grn_table_cursor,
-				 grn_table_cursor **cursor,
-				 grn_ctx **context,
-				 grn_id *domain_id,
-				 grn_obj **domain,
-				 grn_id *range_id,
-				 grn_obj **range)
+                                 grn_table_cursor **cursor,
+                                 grn_ctx **context,
+                                 grn_id *domain_id,
+                                 grn_obj **domain,
+                                 grn_id *range_id,
+                                 grn_obj **range)
 {
     RbGrnObject *rb_grn_object;
 
     rb_grn_object = RB_GRN_OBJECT(rb_grn_table_cursor);
     rb_grn_object_deconstruct(rb_grn_object, cursor, context,
-			      domain_id, domain,
-			      range_id, range);
+                              domain_id, domain,
+                              range_id, range);
 }
 
 int
@@ -75,17 +75,17 @@ rb_grn_table_cursor_order_to_flag (VALUE rb_order)
     int flag = 0;
 
     if (NIL_P(rb_order) ||
-	rb_grn_equal_option(rb_order, "asc") ||
-	rb_grn_equal_option(rb_order, "ascending")) {
-	flag |= GRN_CURSOR_ASCENDING;
+        rb_grn_equal_option(rb_order, "asc") ||
+        rb_grn_equal_option(rb_order, "ascending")) {
+        flag |= GRN_CURSOR_ASCENDING;
     } else if (rb_grn_equal_option(rb_order, "desc") ||
-	       rb_grn_equal_option(rb_order, "descending")) {
-	flag |= GRN_CURSOR_DESCENDING;
+               rb_grn_equal_option(rb_order, "descending")) {
+        flag |= GRN_CURSOR_DESCENDING;
     } else {
-	rb_raise(rb_eArgError,
-		 "order should be one of "
-		 "[:asc, :ascending, :desc, :descending]: %s",
-		 rb_grn_inspect(rb_order));
+        rb_raise(rb_eArgError,
+                 "order should be one of "
+                 "[:asc, :ascending, :desc, :descending]: %s",
+                 rb_grn_inspect(rb_order));
     }
 
     return flag;
@@ -93,32 +93,32 @@ rb_grn_table_cursor_order_to_flag (VALUE rb_order)
 
 int
 rb_grn_table_cursor_order_by_to_flag (unsigned char table_type,
-				      VALUE rb_table,
-				      VALUE rb_order_by)
+                                      VALUE rb_table,
+                                      VALUE rb_order_by)
 {
     int flag = 0;
 
     if (NIL_P(rb_order_by)) {
-	if (table_type == GRN_TABLE_PAT_KEY) {
-	    flag |= GRN_CURSOR_BY_KEY;
-	} else {
-	    flag |= GRN_CURSOR_BY_ID;
-	}
+        if (table_type == GRN_TABLE_PAT_KEY) {
+            flag |= GRN_CURSOR_BY_KEY;
+        } else {
+            flag |= GRN_CURSOR_BY_ID;
+        }
     } else if (rb_grn_equal_option(rb_order_by, "id")) {
-	flag |= GRN_CURSOR_BY_ID;
+        flag |= GRN_CURSOR_BY_ID;
     } else if (rb_grn_equal_option(rb_order_by, "key")) {
-	if (table_type != GRN_TABLE_PAT_KEY) {
-	    rb_raise(rb_eArgError,
-		     "order_by => :key is available "
-		     "only for Groonga::PatriciaTrie: %s",
-		     rb_grn_inspect(rb_table));
-	}
-	flag |= GRN_CURSOR_BY_KEY;
+        if (table_type != GRN_TABLE_PAT_KEY) {
+            rb_raise(rb_eArgError,
+                     "order_by => :key is available "
+                     "only for Groonga::PatriciaTrie: %s",
+                     rb_grn_inspect(rb_table));
+        }
+        flag |= GRN_CURSOR_BY_KEY;
     } else {
-	rb_raise(rb_eArgError,
-		 "order_by should be one of [:id%s]: %s",
-		 table_type == GRN_TABLE_PAT_KEY ? ", :key" : "",
-		 rb_grn_inspect(rb_order_by));
+        rb_raise(rb_eArgError,
+                 "order_by should be one of [:id%s]: %s",
+                 table_type == GRN_TABLE_PAT_KEY ? ", :key" : "",
+                 rb_grn_inspect(rb_order_by));
     }
 
     return flag;
@@ -138,7 +138,7 @@ rb_grn_table_cursor_get_value (VALUE self)
     VALUE rb_value = Qnil;
 
     rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
-				    NULL, NULL, NULL, NULL);
+                                    NULL, NULL, NULL, NULL);
     if (context && cursor) {
         int n;
         void *value;
@@ -163,14 +163,14 @@ rb_grn_table_cursor_set_value (VALUE self, VALUE value)
     grn_table_cursor *cursor;
 
     rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
-				    NULL, NULL, NULL, NULL);
+                                    NULL, NULL, NULL, NULL);
     if (context && cursor) {
         grn_rc rc;
 
         rc = grn_table_cursor_set_value(context,
                                         cursor,
                                         StringValuePtr(value),
-					GRN_OBJ_SET);
+                                        GRN_OBJ_SET);
         rb_grn_rc_check(rc, self);
     }
 
@@ -189,7 +189,7 @@ rb_grn_table_cursor_delete (VALUE self)
     grn_table_cursor *cursor;
 
     rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
-				    NULL, NULL, NULL, NULL);
+                                    NULL, NULL, NULL, NULL);
     if (context && cursor) {
         grn_rc rc;
 
@@ -214,14 +214,14 @@ rb_grn_table_cursor_next (VALUE self)
     grn_table_cursor *cursor;
 
     rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
-				    NULL, NULL, NULL, NULL);
+                                    NULL, NULL, NULL, NULL);
     if (context && cursor) {
         grn_id record_id;
 
         record_id = grn_table_cursor_next(context, cursor);
         if (record_id != GRN_ID_NIL) /* FIXME: use grn_table_cursor_table */
             rb_record = rb_grn_record_new(rb_iv_get(self, "@table"),
-					  record_id, Qnil);
+                                          record_id, Qnil);
     }
 
     return rb_record;
@@ -243,13 +243,13 @@ rb_grn_table_cursor_each (VALUE self)
     RETURN_ENUMERATOR(self, 0, NULL);
 
     rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
-				    NULL, NULL, NULL, NULL);
+                                    NULL, NULL, NULL, NULL);
 
     if (context && cursor) {
-	while ((record_id = grn_table_cursor_next(context, cursor))) {
-	    rb_yield(rb_grn_record_new(rb_iv_get(self, "@table"),
-				       record_id, Qnil));
-	}
+        while ((record_id = grn_table_cursor_next(context, cursor))) {
+            rb_yield(rb_grn_record_new(rb_iv_get(self, "@table"),
+                                       record_id, Qnil));
+        }
     }
 
     return Qnil;