rroonga 3.0.5-x86-mingw32 → 3.0.6-x86-mingw32

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

@@ -37,7 +37,7 @@ grn_obj *
 rb_grn_database_from_ruby_object (VALUE object)
 {
     if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnDatabase))) {
-	rb_raise(rb_eTypeError, "not a groonga database");
+        rb_raise(rb_eTypeError, "not a groonga database");
     }
 
     return RVAL2GRNOBJECT(object, NULL);
@@ -45,7 +45,7 @@ rb_grn_database_from_ruby_object (VALUE object)
 
 VALUE
 rb_grn_database_to_ruby_object (grn_ctx *context, grn_obj *database,
-				grn_bool owner)
+                                grn_bool owner)
 {
     return GRNOBJECT2RVAL(rb_cGrnDatabase, context, database, owner);
 }
@@ -57,12 +57,12 @@ rb_grn_database_mark_existing_ruby_object (grn_ctx *context, grn_obj *database)
     grn_id id;
 
     cursor = grn_table_cursor_open(context, database, NULL, 0, NULL, 0,
-				   0, -1, GRN_CURSOR_ASCENDING);
+                                   0, -1, GRN_CURSOR_ASCENDING);
     if (!cursor)
-	return;
+        return;
 
     while ((id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) {
-	rb_grn_context_mark_grn_id(context, id);
+        rb_grn_context_mark_grn_id(context, id);
     }
     grn_table_cursor_close(context, cursor);
 }
@@ -75,12 +75,12 @@ rb_grn_database_mark (void *data)
     grn_obj *database;
 
     if (!rb_grn_database)
-	return;
+        return;
 
     context = rb_grn_database->context;
     database = rb_grn_database->object;
     if (!context || !database)
-	return;
+        return;
 
     rb_grn_database_mark_existing_ruby_object(context, database);
 }
@@ -89,35 +89,35 @@ static VALUE
 rb_grn_database_alloc (VALUE klass)
 {
     return Data_Wrap_Struct(klass, rb_grn_database_mark, rb_grn_object_free,
-			    NULL);
+                            NULL);
 }
 
 static void
 rb_grn_database_deconstruct (RbGrnObject *rb_grn_database,
-			     grn_obj **database,
-			     grn_ctx **context,
-			     grn_id *domain_id,
-			     grn_obj **domain,
-			     grn_id *range_id,
-			     grn_obj **range)
+                             grn_obj **database,
+                             grn_ctx **context,
+                             grn_id *domain_id,
+                             grn_obj **domain,
+                             grn_id *range_id,
+                             grn_obj **range)
 {
     rb_grn_object_deconstruct(rb_grn_database, database, context,
-			      domain_id, domain,
-			      range_id, range);
+                              domain_id, domain,
+                              range_id, range);
 }
 
 void
 rb_grn_database_finalizer (grn_ctx *context,
-			   RbGrnContext *rb_grn_context,
-			   grn_obj *column,
-			   RbGrnObject *rb_grn_database)
+                           RbGrnContext *rb_grn_context,
+                           grn_obj *column,
+                           RbGrnObject *rb_grn_database)
 {
     if (rb_grn_context) {
-	rb_grn_context_close_floating_objects(rb_grn_context);
+        rb_grn_context_close_floating_objects(rb_grn_context);
     }
 
     if (!(context->flags & GRN_CTX_PER_DB)) {
-	grn_ctx_use(context, NULL);
+        grn_ctx_use(context, NULL);
     }
 }
 
@@ -134,7 +134,7 @@ rb_grn_database_close (VALUE self)
 
     rb_context = rb_iv_get(self, "@context");
     if (!NIL_P(rb_context))
-	rb_iv_set(rb_context, "database", Qnil);
+        rb_iv_set(rb_context, "database", Qnil);
 
     return rb_grn_object_close(self);
 }
@@ -184,9 +184,9 @@ rb_grn_database_s_create (int argc, VALUE *argv, VALUE klass)
 
     rb_grn_scan_options(options,
                         "path", &rb_path,
-			"context", &rb_context,
+                        "context", &rb_context,
                         "builtin_type_names", &builtin_type_names,
-			NULL);
+                        NULL);
 
     if (!NIL_P(rb_path))
         path = StringValuePtr(rb_path);
@@ -197,7 +197,7 @@ rb_grn_database_s_create (int argc, VALUE *argv, VALUE klass)
 
     old_database = grn_ctx_db(context);
     if (old_database)
-	grn_obj_unlink(context, old_database);
+        grn_obj_unlink(context, old_database);
     reset_floating_objects(rb_context);
     database = grn_db_create(context, path, &create_args);
     rb_grn_context_check(context, rb_ary_new4(argc, argv));
@@ -205,12 +205,12 @@ rb_grn_database_s_create (int argc, VALUE *argv, VALUE klass)
     rb_database = GRNOBJECT2RVAL(klass, context, database, owner);
     rb_iv_set(rb_database, "@context", rb_context);
     if (!NIL_P(rb_context))
-	rb_iv_set(rb_context, "database", rb_database);
+        rb_iv_set(rb_context, "database", rb_database);
     rb_grn_context_check(context, rb_ary_new4(argc, argv));
 
     if (rb_block_given_p())
         return rb_ensure(rb_yield, rb_database,
-			 rb_grn_database_close, rb_database);
+                         rb_grn_database_close, rb_database);
     else
         return rb_database;
 }
@@ -246,14 +246,14 @@ rb_grn_database_initialize (int argc, VALUE *argv, VALUE self)
 
     path = StringValuePtr(rb_path);
     rb_grn_scan_options(options,
-			"context", &rb_context,
-			NULL);
+                        "context", &rb_context,
+                        NULL);
 
     context = rb_grn_context_ensure(&rb_context);
 
     old_database = grn_ctx_db(context);
     if (old_database)
-	grn_obj_unlink(context, old_database);
+        grn_obj_unlink(context, old_database);
     reset_floating_objects(rb_context);
     database = grn_db_open(context, path);
     rb_grn_object_assign(Qnil, self, rb_context, context, database);
@@ -261,7 +261,7 @@ rb_grn_database_initialize (int argc, VALUE *argv, VALUE self)
 
     rb_iv_set(self, "@context", rb_context);
     if (!NIL_P(rb_context))
-	rb_iv_set(rb_context, "database", self);
+        rb_iv_set(rb_context, "database", self);
 
     return Qnil;
 }
@@ -355,45 +355,45 @@ rb_grn_database_each (int argc, VALUE *argv, VALUE self)
     RETURN_ENUMERATOR(self, argc, argv);
 
     rb_grn_database_deconstruct(SELF(self), &database, &context,
-				NULL, NULL, NULL, NULL);
+                                NULL, NULL, NULL, NULL);
 
     rb_scan_args(argc, argv, "01", &rb_options);
 
     rb_grn_scan_options(rb_options,
-			"order", &rb_order,
-			"order_by", &rb_order_by,
-			"ignore_missing_object", &rb_ignore_missing_object,
-			NULL);
+                        "order", &rb_order,
+                        "order_by", &rb_order_by,
+                        "ignore_missing_object", &rb_ignore_missing_object,
+                        NULL);
 
     flags |= rb_grn_table_cursor_order_to_flag(rb_order);
     flags |= rb_grn_table_cursor_order_by_to_flag(GRN_TABLE_PAT_KEY,
-						  self,
-						  rb_order_by);
+                                                  self,
+                                                  rb_order_by);
 
     cursor = grn_table_cursor_open(context, database, NULL, 0, NULL, 0,
-				   0, -1,
-				   flags);
+                                   0, -1,
+                                   flags);
     rb_cursor = GRNTABLECURSOR2RVAL(Qnil, context, cursor);
     rb_iv_set(self, "cursor", rb_cursor);
     while ((id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) {
-	grn_obj *object;
-
-	object = grn_ctx_at(context, id);
-	if (!object && RTEST(rb_ignore_missing_object)) {
-	    context->rc = GRN_SUCCESS;
-	    continue;
-	}
-
-	exception = rb_grn_context_to_exception(context, self);
-	if (!NIL_P(exception)) {
-	    rb_grn_object_close(rb_cursor);
-	    rb_iv_set(self, "cursor", Qnil);
-	    rb_exc_raise(exception);
-	}
-
-	if (object) {
-	    rb_yield(GRNOBJECT2RVAL(Qnil, context, object, GRN_FALSE));
-	}
+        grn_obj *object;
+
+        object = grn_ctx_at(context, id);
+        if (!object && RTEST(rb_ignore_missing_object)) {
+            context->rc = GRN_SUCCESS;
+            continue;
+        }
+
+        exception = rb_grn_context_to_exception(context, self);
+        if (!NIL_P(exception)) {
+            rb_grn_object_close(rb_cursor);
+            rb_iv_set(self, "cursor", Qnil);
+            rb_exc_raise(exception);
+        }
+
+        if (object) {
+            rb_yield(GRNOBJECT2RVAL(Qnil, context, object, GRN_FALSE));
+        }
     }
     rb_grn_object_close(rb_cursor);
     rb_iv_set(self, "cursor", Qnil);
@@ -414,7 +414,7 @@ rb_grn_database_unlock (VALUE self)
     grn_rc rc;
 
     rb_grn_database_deconstruct(SELF(self), &database, &context,
-				NULL, NULL, NULL, NULL);
+                                NULL, NULL, NULL, NULL);
 
     rc = grn_obj_unlock(context, database, GRN_ID_NIL);
     rb_grn_context_check(context, self);
@@ -451,23 +451,23 @@ rb_grn_database_lock (int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "01",  &options);
 
     rb_grn_database_deconstruct(SELF(self), &database, &context,
-				NULL, NULL, NULL, NULL);
+                                NULL, NULL, NULL, NULL);
 
     rb_grn_scan_options(options,
-			"timeout", &rb_timeout,
-			NULL);
+                        "timeout", &rb_timeout,
+                        NULL);
 
     if (!NIL_P(rb_timeout))
-	timeout = NUM2UINT(rb_timeout);
+        timeout = NUM2UINT(rb_timeout);
 
     rc = grn_obj_lock(context, database, GRN_ID_NIL, timeout);
     rb_grn_context_check(context, self);
     rb_grn_rc_check(rc, self);
 
     if (rb_block_given_p()) {
-	return rb_ensure(rb_yield, Qnil, rb_grn_database_unlock, self);
+        return rb_ensure(rb_yield, Qnil, rb_grn_database_unlock, self);
     } else {
-	return Qnil;
+        return Qnil;
     }
 }
 
@@ -483,7 +483,7 @@ rb_grn_database_clear_lock (VALUE self)
     grn_obj *database;
 
     rb_grn_database_deconstruct(SELF(self), &database, &context,
-				NULL, NULL, NULL, NULL);
+                                NULL, NULL, NULL, NULL);
 
     grn_obj_clear_lock(context, database);
 
@@ -502,7 +502,7 @@ rb_grn_database_is_locked (VALUE self)
     grn_obj *database;
 
     rb_grn_database_deconstruct(SELF(self), &database, &context,
-				NULL, NULL, NULL, NULL);
+                                NULL, NULL, NULL, NULL);
 
     return CBOOL2RVAL(grn_obj_is_locked(context, database));
 }
@@ -519,7 +519,7 @@ rb_grn_database_touch (VALUE self)
     grn_obj *database;
 
     rb_grn_database_deconstruct(SELF(self), &database, &context,
-				NULL, NULL, NULL, NULL);
+                                NULL, NULL, NULL, NULL);
 
     grn_db_touch(context, database);
     return Qnil;
@@ -548,14 +548,14 @@ rb_grn_database_defrag (int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "01", &options);
     rb_grn_scan_options(options,
-			"threshold", &rb_threshold,
-			NULL);
+                        "threshold", &rb_threshold,
+                        NULL);
     if (!NIL_P(rb_threshold)) {
-	threshold = NUM2INT(rb_threshold);
+        threshold = NUM2INT(rb_threshold);
     }
 
     rb_grn_database_deconstruct(SELF(self), &database, &context,
-				NULL, NULL, NULL, NULL);
+                                NULL, NULL, NULL, NULL);
     n_segments = grn_obj_defrag(context, database, threshold);
     rb_grn_context_check(context, self);
 
@@ -572,23 +572,23 @@ rb_grn_init_database (VALUE mGrn)
     rb_include_module(rb_cGrnDatabase, rb_mGrnEncodingSupport);
 
     rb_define_singleton_method(rb_cGrnDatabase, "create",
-			       rb_grn_database_s_create, -1);
+                               rb_grn_database_s_create, -1);
     rb_define_singleton_method(rb_cGrnDatabase, "open",
-			       rb_grn_database_s_open, -1);
+                               rb_grn_database_s_open, -1);
 
     rb_define_method(rb_cGrnDatabase, "initialize",
-		     rb_grn_database_initialize, -1);
+                     rb_grn_database_initialize, -1);
 
     rb_define_method(rb_cGrnDatabase, "each",
-		     rb_grn_database_each, -1);
+                     rb_grn_database_each, -1);
 
     rb_define_method(rb_cGrnDatabase, "close",
-		     rb_grn_database_close, 0);
+                     rb_grn_database_close, 0);
 
     rb_define_method(rb_cGrnDatabase, "lock", rb_grn_database_lock, -1);
     rb_define_method(rb_cGrnDatabase, "unlock", rb_grn_database_unlock, 0);
     rb_define_method(rb_cGrnDatabase, "clear_lock",
-		     rb_grn_database_clear_lock, 0);
+                     rb_grn_database_clear_lock, 0);
     rb_define_method(rb_cGrnDatabase, "locked?", rb_grn_database_is_locked, 0);
 
     rb_define_method(rb_cGrnDatabase, "touch", rb_grn_database_touch, 0);

data/ext/groonga/rb-grn-double-array-trie.c

@@ -183,66 +183,66 @@ rb_grn_double_array_trie_s_create (int argc, VALUE *argv, VALUE klass)
     rb_scan_args(argc, argv, "01", &options);
 
     rb_grn_scan_options(options,
-			"context", &rb_context,
-			"name", &rb_name,
+                        "context", &rb_context,
+                        "name", &rb_name,
                         "path", &rb_path,
-			"persistent", &rb_persistent,
-			"key_normalize", &rb_key_normalize,
-			"key_with_sis", &rb_key_with_sis,
-			"key_type", &rb_key_type,
-			"value_type", &rb_value_type,
-			"default_tokenizer", &rb_default_tokenizer,
-			"sub_records", &rb_sub_records,
-			"normalizer", &rb_normalizer,
-			NULL);
+                        "persistent", &rb_persistent,
+                        "key_normalize", &rb_key_normalize,
+                        "key_with_sis", &rb_key_with_sis,
+                        "key_type", &rb_key_type,
+                        "value_type", &rb_value_type,
+                        "default_tokenizer", &rb_default_tokenizer,
+                        "sub_records", &rb_sub_records,
+                        "normalizer", &rb_normalizer,
+                        NULL);
 
     context = rb_grn_context_ensure(&rb_context);
 
     if (!NIL_P(rb_name)) {
         name = StringValuePtr(rb_name);
-	name_size = RSTRING_LEN(rb_name);
-	flags |= GRN_OBJ_PERSISTENT;
+        name_size = RSTRING_LEN(rb_name);
+        flags |= GRN_OBJ_PERSISTENT;
     }
 
     if (!NIL_P(rb_path)) {
         path = StringValueCStr(rb_path);
-	flags |= GRN_OBJ_PERSISTENT;
+        flags |= GRN_OBJ_PERSISTENT;
     }
 
     if (RVAL2CBOOL(rb_persistent))
-	flags |= GRN_OBJ_PERSISTENT;
+        flags |= GRN_OBJ_PERSISTENT;
 
     if (RVAL2CBOOL(rb_key_normalize))
-	flags |= GRN_OBJ_KEY_NORMALIZE;
+        flags |= GRN_OBJ_KEY_NORMALIZE;
 
     if (RVAL2CBOOL(rb_key_with_sis))
-	flags |= GRN_OBJ_KEY_WITH_SIS;
+        flags |= GRN_OBJ_KEY_WITH_SIS;
 
     if (NIL_P(rb_key_type)) {
-	key_type = grn_ctx_at(context, GRN_DB_SHORT_TEXT);
+        key_type = grn_ctx_at(context, GRN_DB_SHORT_TEXT);
     } else {
-	key_type = RVAL2GRNOBJECT(rb_key_type, &context);
+        key_type = RVAL2GRNOBJECT(rb_key_type, &context);
     }
 
     if (!NIL_P(rb_value_type))
-	value_type = RVAL2GRNOBJECT(rb_value_type, &context);
+        value_type = RVAL2GRNOBJECT(rb_value_type, &context);
 
     if (RVAL2CBOOL(rb_sub_records))
-	flags |= GRN_OBJ_WITH_SUBREC;
+        flags |= GRN_OBJ_WITH_SUBREC;
 
     table = grn_table_create(context, name, name_size, path,
-			     flags, key_type, value_type);
+                             flags, key_type, value_type);
     if (!table)
-	rb_grn_context_check(context, rb_ary_new4(argc, argv));
+        rb_grn_context_check(context, rb_ary_new4(argc, argv));
     rb_table = GRNOBJECT2RVAL(klass, context, table, GRN_TRUE);
 
     if (!NIL_P(rb_default_tokenizer))
-	rb_funcall(rb_table, rb_intern("default_tokenizer="), 1,
-		   rb_default_tokenizer);
+        rb_funcall(rb_table, rb_intern("default_tokenizer="), 1,
+                   rb_default_tokenizer);
 
     if (!NIL_P(rb_normalizer))
-	rb_funcall(rb_table, rb_intern("normalizer="), 1,
-		   rb_normalizer);
+        rb_funcall(rb_table, rb_intern("normalizer="), 1,
+                   rb_normalizer);
 
     if (rb_block_given_p())
         return rb_ensure(rb_yield, rb_table, rb_grn_object_close, rb_table);
@@ -308,35 +308,35 @@ rb_grn_double_array_trie_search (int argc, VALUE *argv, VALUE self)
     VALUE rb_key, options, rb_result, rb_operator, rb_type;
 
     rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
-					 &key, &domain_id, &domain,
-					 NULL, NULL, NULL,
-					 NULL);
+                                         &key, &domain_id, &domain,
+                                         NULL, NULL, NULL,
+                                         NULL);
 
     rb_scan_args(argc, argv, "11", &rb_key, &options);
 
     RVAL2GRNKEY(rb_key, context, key, domain_id, domain, self);
 
     rb_grn_scan_options(options,
-			"result", &rb_result,
-			"operator", &rb_operator,
-			"type", &rb_type,
-			NULL);
+                        "result", &rb_result,
+                        "operator", &rb_operator,
+                        "type", &rb_type,
+                        NULL);
 
     if (NIL_P(rb_result)) {
-	result = grn_table_create(context, NULL, 0, NULL,
-				  GRN_OBJ_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
-				  table, 0);
-	rb_grn_context_check(context, self);
-	rb_result = GRNOBJECT2RVAL(Qnil, context, result, GRN_TRUE);
+        result = grn_table_create(context, NULL, 0, NULL,
+                                  GRN_OBJ_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+                                  table, 0);
+        rb_grn_context_check(context, self);
+        rb_result = GRNOBJECT2RVAL(Qnil, context, result, GRN_TRUE);
     } else {
-	result = RVAL2GRNOBJECT(rb_result, &context);
+        result = RVAL2GRNOBJECT(rb_result, &context);
     }
 
     operator = RVAL2GRNOPERATOR(rb_operator);
 
     rc = grn_obj_search(context, table, key,
-			result, operator,
-			search_options_is_set ? &search_options : NULL);
+                        result, operator,
+                        search_options_is_set ? &search_options : NULL);
     rb_grn_rc_check(rc, self);
 
     return rb_result;
@@ -357,81 +357,81 @@ rb_grn_double_array_trie_open_grn_prefix_cursor (int argc, VALUE *argv,
     VALUE rb_greater_than, rb_less_than, rb_offset, rb_limit;
 
     rb_grn_table_deconstruct((RbGrnTable *)SELF(self), &table, context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rb_scan_args(argc, argv, "11", &rb_prefix, &options);
 
     rb_grn_scan_options(options,
-			"key_bytes", &rb_key_bytes,
+                        "key_bytes", &rb_key_bytes,
                         "key_bites", &rb_key_bits,
                         "offset", &rb_offset,
                         "limit", &rb_limit,
-			"order", &rb_order,
-			"order_by", &rb_order_by,
-			"greater_than", &rb_greater_than,
-			"less_than", &rb_less_than,
-			NULL);
+                        "order", &rb_order,
+                        "order_by", &rb_order_by,
+                        "greater_than", &rb_greater_than,
+                        "less_than", &rb_less_than,
+                        NULL);
 
     prefix = StringValuePtr(rb_prefix);
     if (!NIL_P(rb_key_bytes) && !NIL_P(rb_key_bits)) {
-	rb_raise(rb_eArgError,
-		 "should not specify both :key_bytes and :key_bits once: %s",
-		 rb_grn_inspect(rb_ary_new4(argc, argv)));
+        rb_raise(rb_eArgError,
+                 "should not specify both :key_bytes and :key_bits once: %s",
+                 rb_grn_inspect(rb_ary_new4(argc, argv)));
     } else if (!NIL_P(rb_key_bytes)) {
-	prefix_size = NUM2UINT(rb_key_bytes);
+        prefix_size = NUM2UINT(rb_key_bytes);
     } else if (!NIL_P(rb_key_bits)) {
-	prefix_size = NUM2UINT(rb_key_bits);
-	flags |= GRN_CURSOR_SIZE_BY_BIT;
+        prefix_size = NUM2UINT(rb_key_bits);
+        flags |= GRN_CURSOR_SIZE_BY_BIT;
     } else {
-	prefix_size = RSTRING_LEN(rb_prefix);
+        prefix_size = RSTRING_LEN(rb_prefix);
     }
     if (!NIL_P(rb_offset))
-	offset = NUM2INT(rb_offset);
+        offset = NUM2INT(rb_offset);
     if (!NIL_P(rb_limit))
-	limit = NUM2INT(rb_limit);
+        limit = NUM2INT(rb_limit);
 
     if (NIL_P(rb_order)) {
     } else if (rb_grn_equal_option(rb_order, "asc") ||
-	       rb_grn_equal_option(rb_order, "ascending")) {
-	flags |= GRN_CURSOR_ASCENDING;
+               rb_grn_equal_option(rb_order, "ascending")) {
+        flags |= GRN_CURSOR_ASCENDING;
     } else if (rb_grn_equal_option(rb_order, "desc") ||
-	       rb_grn_equal_option(rb_order, "descending")) {
-	flags |= GRN_CURSOR_DESCENDING;
+               rb_grn_equal_option(rb_order, "descending")) {
+        flags |= 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));
     }
     if (NIL_P(rb_order_by)) {
     } else if (rb_grn_equal_option(rb_order_by, "id")) {
-	flags |= GRN_CURSOR_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::DoubleArrayTrie: %s",
-		     rb_grn_inspect(self));
-	}
-	flags |= GRN_CURSOR_BY_KEY;
+        if (table->header.type != GRN_TABLE_PAT_KEY) {
+            rb_raise(rb_eArgError,
+                     "order_by => :key is available "
+                     "only for Groonga::DoubleArrayTrie: %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" : "",
-		 rb_grn_inspect(rb_order_by));
+        rb_raise(rb_eArgError,
+                 "order_by should be one of [:id%s]: %s",
+                 table->header.type == GRN_TABLE_PAT_KEY ? ", :key" : "",
+                 rb_grn_inspect(rb_order_by));
     }
 
     if (RVAL2CBOOL(rb_greater_than))
-	flags |= GRN_CURSOR_GT;
+        flags |= GRN_CURSOR_GT;
     if (RVAL2CBOOL(rb_less_than))
-	flags |= GRN_CURSOR_LT;
+        flags |= GRN_CURSOR_LT;
 
     cursor = grn_table_cursor_open(*context, table,
-				   prefix, prefix_size,
-				   NULL, 0,
-				   offset, limit, flags);
+                                   prefix, prefix_size,
+                                   NULL, 0,
+                                   offset, limit, flags);
     rb_grn_context_check(*context, self);
 
     return cursor;
@@ -486,28 +486,28 @@ rb_grn_double_array_trie_open_prefix_cursor (int argc, VALUE *argv, VALUE self)
     VALUE rb_cursor;
 
     cursor = rb_grn_double_array_trie_open_grn_prefix_cursor(argc, argv,
-							 self, &context);
+                                                         self, &context);
     rb_cursor = GRNTABLECURSOR2RVAL(Qnil, context, cursor);
     rb_iv_set(rb_cursor, "@table", self); /* FIXME: cursor should mark table */
     if (rb_block_given_p())
-	return rb_ensure(rb_yield, rb_cursor, rb_grn_object_close, rb_cursor);
+        return rb_ensure(rb_yield, rb_cursor, rb_grn_object_close, rb_cursor);
     else
-	return rb_cursor;
+        return rb_cursor;
 }
 
 void
 rb_grn_init_double_array_trie (VALUE mGrn)
 {
     rb_cGrnDoubleArrayTrie =
-	rb_define_class_under(mGrn, "DoubleArrayTrie", rb_cGrnTable);
+        rb_define_class_under(mGrn, "DoubleArrayTrie", rb_cGrnTable);
 
     rb_include_module(rb_cGrnDoubleArrayTrie, rb_mGrnTableKeySupport);
     rb_define_singleton_method(rb_cGrnDoubleArrayTrie, "create",
-			       rb_grn_double_array_trie_s_create, -1);
+                               rb_grn_double_array_trie_s_create, -1);
 
     rb_define_method(rb_cGrnDoubleArrayTrie, "search",
-		     rb_grn_double_array_trie_search, -1);
+                     rb_grn_double_array_trie_search, -1);
 
     rb_define_method(rb_cGrnDoubleArrayTrie, "open_prefix_cursor",
-		     rb_grn_double_array_trie_open_prefix_cursor, -1);
+                     rb_grn_double_array_trie_open_prefix_cursor, -1);
 }