rroonga 3.0.5 → 3.0.6

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

@@ -82,10 +82,10 @@ grn_encoding
 rb_grn_encoding_from_ruby_object (VALUE object, grn_ctx *context)
 {
     if (NIL_P(object)) {
-	if (context)
-	    return context->encoding;
-	else
-	    return GRN_ENC_DEFAULT;
+        if (context)
+            return context->encoding;
+        else
+            return GRN_ENC_DEFAULT;
     }
 
     if (rb_grn_equal_option(object, "default")) {
@@ -93,14 +93,14 @@ rb_grn_encoding_from_ruby_object (VALUE object, grn_ctx *context)
     } else if (rb_grn_equal_option(object, "none")) {
         return GRN_ENC_NONE;
     } else if (rb_grn_equal_option(object, "euc_jp") ||
-	       rb_grn_equal_option(object, "euc-jp")) {
+               rb_grn_equal_option(object, "euc-jp")) {
         return GRN_ENC_EUC_JP;
     } else if (rb_grn_equal_option(object, "utf8") ||
-	       rb_grn_equal_option(object, "utf-8")) {
+               rb_grn_equal_option(object, "utf-8")) {
         return GRN_ENC_UTF8;
     } else if (rb_grn_equal_option(object, "sjis") ||
-	       rb_grn_equal_option(object, "shift_jis") ||
-	       rb_grn_equal_option(object, "shift-jis")) {
+               rb_grn_equal_option(object, "shift_jis") ||
+               rb_grn_equal_option(object, "shift-jis")) {
         return GRN_ENC_SJIS;
     } else if (rb_grn_equal_option(object, "latin1")) {
         return GRN_ENC_LATIN1;
@@ -120,29 +120,29 @@ rb_grn_encoding_to_ruby_object (grn_encoding encoding)
 
     switch (encoding) {
       case GRN_ENC_DEFAULT:
-	rb_encoding = RB_GRN_ENCODING_DEFAULT;
+        rb_encoding = RB_GRN_ENCODING_DEFAULT;
         break;
       case GRN_ENC_NONE:
-	rb_encoding = RB_GRN_ENCODING_NONE;
+        rb_encoding = RB_GRN_ENCODING_NONE;
         break;
       case GRN_ENC_EUC_JP:
-	rb_encoding = RB_GRN_ENCODING_EUC_JP;
+        rb_encoding = RB_GRN_ENCODING_EUC_JP;
         break;
       case GRN_ENC_UTF8:
-	rb_encoding = RB_GRN_ENCODING_UTF8;
+        rb_encoding = RB_GRN_ENCODING_UTF8;
         break;
       case GRN_ENC_SJIS:
-	rb_encoding = RB_GRN_ENCODING_SJIS;
+        rb_encoding = RB_GRN_ENCODING_SJIS;
         break;
       case GRN_ENC_LATIN1:
-	rb_encoding = RB_GRN_ENCODING_LATIN1;
+        rb_encoding = RB_GRN_ENCODING_LATIN1;
         break;
       case GRN_ENC_KOI8R:
-	rb_encoding = RB_GRN_ENCODING_KOI8R;
+        rb_encoding = RB_GRN_ENCODING_KOI8R;
         break;
       default:
-	rb_raise(rb_eArgError, "unknown encoding: %d", encoding);
-	break;
+        rb_raise(rb_eArgError, "unknown encoding: %d", encoding);
+        break;
     }
 
     return rb_encoding;
@@ -155,30 +155,30 @@ rb_grn_encoding_to_ruby_encoding (grn_encoding encoding)
     rb_encoding *rb_encoding;
 
     if (encoding == GRN_ENC_DEFAULT)
-	encoding = grn_get_default_encoding();
+        encoding = grn_get_default_encoding();
 
     switch (encoding) {
       case GRN_ENC_NONE:
-	rb_encoding = rb_ascii8bit_encoding();
+        rb_encoding = rb_ascii8bit_encoding();
         break;
       case GRN_ENC_EUC_JP:
-	rb_encoding = rb_enc_find("euc-jp");
+        rb_encoding = rb_enc_find("euc-jp");
         break;
       case GRN_ENC_UTF8:
-	rb_encoding = rb_utf8_encoding();
+        rb_encoding = rb_utf8_encoding();
         break;
       case GRN_ENC_SJIS:
-	rb_encoding = rb_enc_find("CP932");
+        rb_encoding = rb_enc_find("CP932");
         break;
       case GRN_ENC_LATIN1:
-	rb_encoding = rb_enc_find("ISO-8859-1");
+        rb_encoding = rb_enc_find("ISO-8859-1");
         break;
       case GRN_ENC_KOI8R:
-	rb_encoding = rb_enc_find("KOI8-R");
+        rb_encoding = rb_enc_find("KOI8-R");
         break;
       default:
-	rb_raise(rb_eArgError, "unknown encoding: %d", encoding);
-	break;
+        rb_raise(rb_eArgError, "unknown encoding: %d", encoding);
+        break;
     }
 
     return rb_encoding;
@@ -222,9 +222,9 @@ rb_grn_init_encoding (VALUE mGrn)
     mGrnEncoding = rb_define_module_under(mGrn, "Encoding");
 
     rb_define_singleton_method(mGrnEncoding, "default",
-			       rb_grn_encoding_s_get_default, 0);
+                               rb_grn_encoding_s_get_default, 0);
     rb_define_singleton_method(mGrnEncoding, "default=",
-			       rb_grn_encoding_s_set_default, 1);
+                               rb_grn_encoding_s_set_default, 1);
 
 #define DEFINE_ENCODING(name, value)                                    \
     RB_GRN_ENCODING_ ## name = RB_GRN_INTERN(value);                    \

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

@@ -103,7 +103,7 @@ rb_grn_rc_to_exception (grn_rc rc)
 
     switch (rc) {
       case GRN_SUCCESS:
-	return Qnil;
+        return Qnil;
         break;
       case GRN_END_OF_DATA:
         exception = eGrnEndOfData;
@@ -339,8 +339,8 @@ rb_grn_rc_to_message (grn_rc rc)
 
     switch (rc) {
       case GRN_SUCCESS:
-	return NULL;
-	break;
+        return NULL;
+        break;
       case GRN_END_OF_DATA:
         message = "end of data";
         break;
@@ -576,13 +576,13 @@ rb_grn_rc_check (grn_rc rc, VALUE related_object)
 
     exception = rb_grn_rc_to_exception(rc);
     if (NIL_P(exception))
-	return;
+        return;
     message = rb_grn_rc_to_message(rc);
 
     if (NIL_P(related_object))
-	rb_raise(exception, "%s", message);
+        rb_raise(exception, "%s", message);
     else
-	rb_raise(exception, "%s: %s", rb_grn_inspect(related_object),  message);
+        rb_raise(exception, "%s: %s", rb_grn_inspect(related_object),  message);
 }
 
 void
@@ -727,7 +727,7 @@ rb_grn_init_exception (VALUE mGrn)
      */
     eGrnResourceTemporarilyUnavailable =
         rb_define_class_under(mGrn, "ResourceTemporarilyUnavailable",
-			      rb_eGrnError);
+                              rb_eGrnError);
 
     /*
      * Document-class: Groonga::NotEnoughSpace
@@ -1198,7 +1198,7 @@ rb_grn_init_exception (VALUE mGrn)
      * 未サポートのコマンドバージョンを指定したときに発生する。
      */
     eGrnUnsupportedCommandVersion =
-	rb_define_class_under(mGrn, "UnsupportedCommandVersion", rb_eGrnError);
+        rb_define_class_under(mGrn, "UnsupportedCommandVersion", rb_eGrnError);
 
     /*
      * Document-class: Groonga::NormalizerError
@@ -1208,5 +1208,5 @@ rb_grn_init_exception (VALUE mGrn)
      * @since 2.1.0
      */
     eGrnNormalizerError =
-	rb_define_class_under(mGrn, "NormalizerError", rb_eGrnError);
+        rb_define_class_under(mGrn, "NormalizerError", rb_eGrnError);
 }

data/ext/groonga/rb-grn-expression-builder.c

@@ -25,14 +25,14 @@ VALUE
 rb_grn_record_expression_builder_new (VALUE table, VALUE name)
 {
     return rb_funcall(rb_cGrnRecordExpressionBuilder,
-		      rb_intern("new"), 2, table, name);
+                      rb_intern("new"), 2, table, name);
 }
 
 VALUE
 rb_grn_column_expression_builder_new (VALUE column, VALUE name, VALUE query)
 {
     return rb_funcall(rb_cGrnColumnExpressionBuilder,
-		      rb_intern("new"), 3, column, name, query);
+                      rb_intern("new"), 3, column, name, query);
 }
 
 static VALUE
@@ -51,18 +51,18 @@ VALUE
 rb_grn_record_expression_builder_build (VALUE self)
 {
     if (rb_block_given_p())
-	return rb_iterate(build, self, build_block, self);
+        return rb_iterate(build, self, build_block, self);
     else
-	return build(self);
+        return build(self);
 }
 
 VALUE
 rb_grn_column_expression_builder_build (VALUE self)
 {
     if (rb_block_given_p())
-	return rb_iterate(build, self, build_block, self);
+        return rb_iterate(build, self, build_block, self);
     else
-	return build(self);
+        return build(self);
 }
 
 void

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

@@ -31,10 +31,10 @@ VALUE rb_cGrnExpression;
 
 void
 rb_grn_expression_finalizer (grn_ctx *context, grn_obj *object,
-			     RbGrnExpression *rb_grn_expression)
+                             RbGrnExpression *rb_grn_expression)
 {
     if (context && rb_grn_expression->value)
-	grn_obj_unlink(context, rb_grn_expression->value);
+        grn_obj_unlink(context, rb_grn_expression->value);
 
     rb_grn_context_unregister_floating_object(RB_GRN_OBJECT(rb_grn_expression));
 
@@ -59,7 +59,7 @@ rb_grn_expression_deconstruct (RbGrnExpression *rb_grn_expression,
                                grn_ctx **context,
                                grn_id *domain_id,
                                grn_obj **domain,
-			       grn_obj **value,
+                               grn_obj **value,
                                grn_id *range_id,
                                grn_obj **range)
 {
@@ -67,11 +67,11 @@ rb_grn_expression_deconstruct (RbGrnExpression *rb_grn_expression,
 
     rb_grn_object = RB_GRN_OBJECT(rb_grn_expression);
     rb_grn_object_deconstruct(rb_grn_object, expression, context,
-			      domain_id, domain,
-			      range_id, range);
+                              domain_id, domain,
+                              range_id, range);
 
     if (value)
-	*value = rb_grn_expression->value;
+        *value = rb_grn_expression->value;
 }
 
 static VALUE
@@ -92,8 +92,8 @@ rb_grn_expression_initialize (int argc, VALUE *argv, VALUE self)
     context = rb_grn_context_ensure(&rb_context);
 
     if (!NIL_P(rb_name)) {
-	name = StringValuePtr(rb_name);
-	name_size = RSTRING_LEN(rb_name);
+        name = StringValuePtr(rb_name);
+        name_size = RSTRING_LEN(rb_name);
     }
 
     expression = grn_expr_create(context, name, name_size);
@@ -139,23 +139,23 @@ rb_grn_expression_define_variable (int argc, VALUE *argv, VALUE self)
                                   NULL, NULL, NULL);
 
     rb_grn_scan_options(options,
-			"name", &rb_name,
-			"domain", &rb_domain,
+                        "name", &rb_name,
+                        "domain", &rb_domain,
                         "reference", &rb_reference,
-			NULL);
+                        NULL);
 
     if (!NIL_P(rb_name)) {
-	name = StringValuePtr(rb_name);
-	name_size = RSTRING_LEN(rb_name);
+        name = StringValuePtr(rb_name);
+        name_size = RSTRING_LEN(rb_name);
     }
 
     variable = grn_expr_add_var(context, expression, name, name_size);
     rb_variable = GRNVARIABLE2RVAL(context, variable);
 
     if (RVAL2CBOOL(rb_obj_is_kind_of(rb_domain, rb_cGrnTable))) {
-	grn_id domain_id;
-	domain_id = NUM2UINT(rb_funcall(rb_domain, rb_intern("id"), 0));
-	GRN_RECORD_INIT(variable, 0, domain_id);
+        grn_id domain_id;
+        domain_id = NUM2UINT(rb_funcall(rb_domain, rb_intern("id"), 0));
+        GRN_RECORD_INIT(variable, 0, domain_id);
     } else if (!NIL_P(rb_reference) && RVAL2CBOOL(rb_reference)) {
         GRN_PTR_INIT(variable, 0, GRN_DB_OBJECT);
     }
@@ -228,7 +228,7 @@ rb_grn_expression_append_constant (int argc, VALUE *argv, VALUE self)
 
     rb_grn_expression_deconstruct(SELF(self), &expression, &context,
                                   NULL, NULL, NULL,
-				  NULL, NULL);
+                                  NULL, NULL);
 
     RVAL2GRNOBJ(rb_constant, context, &constant);
     grn_expr_append_const(context, expression, constant, operator, n_arguments);
@@ -236,7 +236,7 @@ rb_grn_expression_append_constant (int argc, VALUE *argv, VALUE self)
     exception = rb_grn_context_to_exception(context, self);
     grn_obj_unlink(context, constant);
     if (!NIL_P(exception))
-	rb_exc_raise(exception);
+        rb_exc_raise(exception);
 
     return self;
 }
@@ -248,7 +248,7 @@ rb_grn_expression_append_constant (int argc, VALUE *argv, VALUE self)
  */
 static VALUE
 rb_grn_expression_append_operation (VALUE self, VALUE rb_operation,
-				    VALUE rb_n_arguments)
+                                    VALUE rb_n_arguments)
 {
     grn_ctx *context = NULL;
     grn_obj *expression;
@@ -355,11 +355,11 @@ rb_grn_expression_parse (int argc, VALUE *argv, VALUE self)
                         "default_column", &rb_default_column,
                         "default_operator", &rb_default_operator,
                         "default_mode", &rb_default_mode,
-			"syntax", &rb_syntax,
-			"allow_pragma", &rb_allow_pragma,
-			"allow_column", &rb_allow_column,
-			"allow_update", &rb_allow_update,
-			"allow_leading_not", &rb_allow_leading_not,
+                        "syntax", &rb_syntax,
+                        "allow_pragma", &rb_allow_pragma,
+                        "allow_column", &rb_allow_column,
+                        "allow_update", &rb_allow_update,
+                        "allow_leading_not", &rb_allow_leading_not,
                         NULL);
 
     query = StringValuePtr(rb_query);
@@ -370,79 +370,79 @@ rb_grn_expression_parse (int argc, VALUE *argv, VALUE self)
                                   NULL, NULL, NULL);
 
     if (NIL_P(rb_default_column)) {
-	default_column = NULL;
+        default_column = NULL;
     } else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_default_column, rb_cGrnObject))) {
-	default_column = RVAL2GRNOBJECT(rb_default_column, &context);
+        default_column = RVAL2GRNOBJECT(rb_default_column, &context);
     } else {
-	default_column = RVAL2GRNBULK(rb_default_column, context, NULL);
-	default_column_is_created = GRN_TRUE;
+        default_column = RVAL2GRNBULK(rb_default_column, context, NULL);
+        default_column_is_created = GRN_TRUE;
     }
 
     if (!NIL_P(rb_default_mode))
-	default_mode = RVAL2GRNOPERATOR(rb_default_mode);
+        default_mode = RVAL2GRNOPERATOR(rb_default_mode);
     if (!NIL_P(rb_default_operator))
-	default_operator = RVAL2GRNOPERATOR(rb_default_operator);
+        default_operator = RVAL2GRNOPERATOR(rb_default_operator);
 
     if (NIL_P(rb_syntax) ||
-	rb_grn_equal_option(rb_syntax, "query")) {
-	flags = GRN_EXPR_SYNTAX_QUERY;
+        rb_grn_equal_option(rb_syntax, "query")) {
+        flags = GRN_EXPR_SYNTAX_QUERY;
     } else if (rb_grn_equal_option(rb_syntax, "script")) {
-	flags = GRN_EXPR_SYNTAX_SCRIPT;
+        flags = GRN_EXPR_SYNTAX_SCRIPT;
     } else {
-	rb_raise(rb_eArgError,
-		 "syntax should be one of "
-		 "[nil, :query, :script]: %s",
-		 rb_grn_inspect(rb_syntax));
+        rb_raise(rb_eArgError,
+                 "syntax should be one of "
+                 "[nil, :query, :script]: %s",
+                 rb_grn_inspect(rb_syntax));
     }
 
     if (NIL_P(rb_allow_pragma)) {
-	if (!(flags & GRN_EXPR_SYNTAX_SCRIPT))
-	    flags |= GRN_EXPR_ALLOW_PRAGMA;
+        if (!(flags & GRN_EXPR_SYNTAX_SCRIPT))
+            flags |= GRN_EXPR_ALLOW_PRAGMA;
     } else {
-	if ((flags & GRN_EXPR_SYNTAX_SCRIPT))
-	    rb_raise(rb_eArgError,
-		     ":allow_pragma isn't allowed in script syntax");
-	if (RVAL2CBOOL(rb_allow_pragma))
-	    flags |= GRN_EXPR_ALLOW_PRAGMA;
+        if ((flags & GRN_EXPR_SYNTAX_SCRIPT))
+            rb_raise(rb_eArgError,
+                     ":allow_pragma isn't allowed in script syntax");
+        if (RVAL2CBOOL(rb_allow_pragma))
+            flags |= GRN_EXPR_ALLOW_PRAGMA;
     }
 
     if (NIL_P(rb_allow_column)) {
-	if (!(flags & GRN_EXPR_SYNTAX_SCRIPT))
-	    flags |= GRN_EXPR_ALLOW_COLUMN;
+        if (!(flags & GRN_EXPR_SYNTAX_SCRIPT))
+            flags |= GRN_EXPR_ALLOW_COLUMN;
     } else {
-	if ((flags & GRN_EXPR_SYNTAX_SCRIPT))
-	    rb_raise(rb_eArgError,
-		     ":allow_column isn't allowed in script syntax");
-	if (RVAL2CBOOL(rb_allow_column))
-	    flags |= GRN_EXPR_ALLOW_COLUMN;
+        if ((flags & GRN_EXPR_SYNTAX_SCRIPT))
+            rb_raise(rb_eArgError,
+                     ":allow_column isn't allowed in script syntax");
+        if (RVAL2CBOOL(rb_allow_column))
+            flags |= GRN_EXPR_ALLOW_COLUMN;
     }
 
     if (NIL_P(rb_allow_update)) {
-	flags |= GRN_EXPR_ALLOW_UPDATE;
+        flags |= GRN_EXPR_ALLOW_UPDATE;
     } else {
-	if (RVAL2CBOOL(rb_allow_update))
-	    flags |= GRN_EXPR_ALLOW_UPDATE;
+        if (RVAL2CBOOL(rb_allow_update))
+            flags |= GRN_EXPR_ALLOW_UPDATE;
     }
 
     if (!NIL_P(rb_allow_leading_not)) {
-	if (RVAL2CBOOL(rb_allow_leading_not))
-	    flags |= GRN_EXPR_ALLOW_LEADING_NOT;
+        if (RVAL2CBOOL(rb_allow_leading_not))
+            flags |= GRN_EXPR_ALLOW_LEADING_NOT;
     }
 
     rc = grn_expr_parse(context, expression, query, query_size,
-			default_column, default_mode, default_operator,
-			flags);
+                        default_column, default_mode, default_operator,
+                        flags);
     if (rc != GRN_SUCCESS) {
-	VALUE related_object;
+        VALUE related_object;
 
-	related_object = rb_ary_new3(2, self, rb_ary_new4(argc, argv));
-	exception = rb_grn_context_to_exception(context, related_object);
+        related_object = rb_ary_new3(2, self, rb_ary_new4(argc, argv));
+        exception = rb_grn_context_to_exception(context, related_object);
     }
     if (default_column_is_created)
-	grn_obj_unlink(context, default_column);
+        grn_obj_unlink(context, default_column);
 
     if (!NIL_P(exception))
-	rb_exc_raise(exception);
+        rb_exc_raise(exception);
 
     return Qnil;
 }
@@ -564,8 +564,8 @@ rb_grn_expression_inspect (VALUE self)
 #endif
     GRN_TEXT_PUTS(context, &inspected, ">");
     rb_inspected = rb_grn_context_rb_string_new(context,
-						GRN_TEXT_VALUE(&inspected),
-						GRN_TEXT_LEN(&inspected));
+                                                GRN_TEXT_VALUE(&inspected),
+                                                GRN_TEXT_LEN(&inspected));
     GRN_OBJ_FIN(context, &inspected);
 
     return rb_inspected;
@@ -657,15 +657,15 @@ rb_grn_expression_snippet (int argc, VALUE *argv, VALUE self)
                         NULL);
 
     if (TYPE(rb_tags) != T_ARRAY) {
-	rb_raise(rb_eArgError,
-		 "tags should be "
-		 "[\"open_tag\", \"close_tag\"] or "
-		 "[[\"open_tag1\", \"close_tag1\"], ...]: %s",
-		 rb_grn_inspect(rb_tags));
+        rb_raise(rb_eArgError,
+                 "tags should be "
+                 "[\"open_tag\", \"close_tag\"] or "
+                 "[[\"open_tag1\", \"close_tag1\"], ...]: %s",
+                 rb_grn_inspect(rb_tags));
     }
 
     if (TYPE(RARRAY_PTR(rb_tags)[0]) == T_STRING) {
-	rb_tags = rb_ary_new3(1, rb_tags);
+        rb_tags = rb_ary_new3(1, rb_tags);
     }
 
     rb_tag_values = RARRAY_PTR(rb_tags);
@@ -675,21 +675,21 @@ rb_grn_expression_snippet (int argc, VALUE *argv, VALUE self)
     close_tags = ALLOCA_N(char *, n_tags);
     close_tag_lengths = ALLOCA_N(unsigned int, n_tags);
     for (i = 0; i < n_tags; i++) {
-	VALUE *tag_pair;
-
-	if (TYPE(rb_tag_values[i]) != T_ARRAY ||
-	    RARRAY_LEN(rb_tag_values[i]) != 2) {
-	    rb_raise(rb_eArgError,
-		     "tags should be "
-		     "[\"open_tag\", \"close_tag\"] or"
-		     "[[\"open_tag1\", \"close_tag1\"], ...]: %s",
-		     rb_grn_inspect(rb_tags));
-	}
-	tag_pair = RARRAY_PTR(rb_tag_values[i]);
-	open_tags[i] = StringValuePtr(tag_pair[0]);
-	open_tag_lengths[i] = RSTRING_LEN(tag_pair[0]);
-	close_tags[i] = StringValuePtr(tag_pair[1]);
-	close_tag_lengths[i] = RSTRING_LEN(tag_pair[1]);
+        VALUE *tag_pair;
+
+        if (TYPE(rb_tag_values[i]) != T_ARRAY ||
+            RARRAY_LEN(rb_tag_values[i]) != 2) {
+            rb_raise(rb_eArgError,
+                     "tags should be "
+                     "[\"open_tag\", \"close_tag\"] or"
+                     "[[\"open_tag1\", \"close_tag1\"], ...]: %s",
+                     rb_grn_inspect(rb_tags));
+        }
+        tag_pair = RARRAY_PTR(rb_tag_values[i]);
+        open_tags[i] = StringValuePtr(tag_pair[0]);
+        open_tag_lengths[i] = RSTRING_LEN(tag_pair[0]);
+        close_tags[i] = StringValuePtr(tag_pair[1]);
+        close_tag_lengths[i] = RSTRING_LEN(tag_pair[1]);
     }
 
     if (RVAL2CBOOL(rb_normalize))
@@ -707,7 +707,7 @@ rb_grn_expression_snippet (int argc, VALUE *argv, VALUE self)
         mapping = (grn_snip_mapping *)-1;
 
     snippet = grn_expr_snip(context, expression, flags, width, max_results,
-			    n_tags,
+                            n_tags,
                             (const char **)open_tags, open_tag_lengths,
                             (const char **)close_tags, close_tag_lengths,
                             mapping);

data/ext/groonga/rb-grn-fix-size-column.c

@@ -44,8 +44,8 @@ rb_grn_fix_size_column_array_reference (VALUE self, VALUE rb_id)
     grn_obj *value;
 
     rb_grn_column_deconstruct(SELF(self), &fix_size_column, &context,
-			      NULL, NULL,
-			      &value, NULL, &range);
+                              NULL, NULL,
+                              &value, NULL, &range);
 
     id = NUM2UINT(rb_id);
     GRN_BULK_REWIND(value);
@@ -74,8 +74,8 @@ rb_grn_fix_size_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
     grn_id id;
 
     rb_grn_column_deconstruct(SELF(self), &column, &context,
-			      &domain_id, &domain,
-			      &value, &range_id, &range);
+                              &domain_id, &domain,
+                              &value, &range_id, &range);
 
     id = NUM2UINT(rb_id);
     RVAL2GRNVALUE(rb_value, context, value, range_id, range);
@@ -100,12 +100,12 @@ rb_grn_fix_size_column_integer_set (int argc, VALUE *argv, VALUE self, int flags
     rb_scan_args(argc, argv, "11", &rb_id, &rb_delta);
 
     rb_grn_column_deconstruct(SELF(self), &column, &context,
-			      NULL, NULL,
-			      &value, NULL, NULL);
+                              NULL, NULL,
+                              &value, NULL, NULL);
 
     id = NUM2UINT(rb_id);
     if (NIL_P(rb_delta))
-	rb_delta = INT2NUM(1);
+        rb_delta = INT2NUM(1);
 
     GRN_BULK_REWIND(value);
     RVAL2GRNBULK(rb_delta, context, value);
@@ -145,15 +145,15 @@ void
 rb_grn_init_fix_size_column (VALUE mGrn)
 {
     rb_cGrnFixSizeColumn =
-	rb_define_class_under(mGrn, "FixSizeColumn", rb_cGrnColumn);
+        rb_define_class_under(mGrn, "FixSizeColumn", rb_cGrnColumn);
 
     rb_define_method(rb_cGrnFixSizeColumn, "[]",
-		     rb_grn_fix_size_column_array_reference, 1);
+                     rb_grn_fix_size_column_array_reference, 1);
     rb_define_method(rb_cGrnFixSizeColumn, "[]=",
-		     rb_grn_fix_size_column_array_set, 2);
+                     rb_grn_fix_size_column_array_set, 2);
 
     rb_define_method(rb_cGrnFixSizeColumn, "increment!",
-		     rb_grn_fix_size_column_increment, -1);
+                     rb_grn_fix_size_column_increment, -1);
     rb_define_method(rb_cGrnFixSizeColumn, "decrement!",
-		     rb_grn_fix_size_column_decrement, -1);
+                     rb_grn_fix_size_column_decrement, -1);
 }

data/ext/groonga/rb-grn-geo-point.c

@@ -37,14 +37,14 @@ VALUE
 rb_grn_tokyo_geo_point_new_raw (VALUE latitude, VALUE longitude)
 {
     return rb_funcall(rb_cGrnTokyoGeoPoint, rb_intern("new"), 2,
-		      latitude, longitude);
+                      latitude, longitude);
 }
 
 VALUE
 rb_grn_wgs84_geo_point_new_raw (VALUE latitude, VALUE longitude)
 {
     return rb_funcall(rb_cGrnWGS84GeoPoint, rb_intern("new"), 2,
-		      latitude, longitude);
+                      latitude, longitude);
 }
 
 void