groonga 0.0.6 → 0.0.7

data/ext/rb-grn-encoding.c

@@ -148,6 +148,43 @@ rb_grn_encoding_to_ruby_object (grn_encoding encoding)
     return rb_encoding;
 }
 
+#ifdef HAVE_RUBY_ENCODING_H
+rb_encoding *
+rb_grn_encoding_to_ruby_encoding (grn_encoding encoding)
+{
+    rb_encoding *rb_encoding;
+
+    if (encoding == GRN_ENC_DEFAULT)
+	encoding = grn_get_default_encoding();
+
+    switch (encoding) {
+      case GRN_ENC_NONE:
+	rb_encoding = rb_ascii8bit_encoding();
+        break;
+      case GRN_ENC_EUC_JP:
+	rb_encoding = rb_enc_find("euc-jp");
+        break;
+      case GRN_ENC_UTF8:
+	rb_encoding = rb_utf8_encoding();
+        break;
+      case GRN_ENC_SJIS:
+	rb_encoding = rb_enc_find("CP932");
+        break;
+      case GRN_ENC_LATIN1:
+	rb_encoding = rb_enc_find("ISO-8859-1");
+        break;
+      case GRN_ENC_KOI8R:
+	rb_encoding = rb_enc_find("KOI8-R");
+        break;
+      default:
+	rb_raise(rb_eArgError, "unknown encoding: %d", encoding);
+	break;
+    }
+
+    return rb_encoding;
+}
+#endif
+
 /*
  * call-seq:
  *   Groonga::Encoding.default -> エンコーディング

data/ext/rb-grn-expression.c

@@ -70,17 +70,14 @@ rb_grn_expression_initialize (int argc, VALUE *argv, VALUE self)
 {
     grn_ctx *context = NULL;
     grn_obj *expression;
-    VALUE options, rb_context, rb_name, rb_query, rb_table, rb_default_column;
-    char *name = NULL, *query = NULL;
-    unsigned name_size = 0, query_size = 0;
+    VALUE options, rb_context, rb_name;
+    char *name = NULL;
+    unsigned name_size = 0;
 
     rb_scan_args(argc, argv, "01", &options);
     rb_grn_scan_options(options,
                         "context", &rb_context,
                         "name", &rb_name,
-                        "query", &rb_query,
-                        "table", &rb_table,
-                        "default_column", &rb_default_column,
                         NULL);
 
     context = rb_grn_context_ensure(&rb_context);
@@ -90,23 +87,7 @@ rb_grn_expression_initialize (int argc, VALUE *argv, VALUE self)
 	name_size = RSTRING_LEN(rb_name);
     }
 
-    if (!NIL_P(rb_query)) {
-	query = StringValuePtr(rb_query);
-	query_size = RSTRING_LEN(rb_query);
-    }
-
-    if (query) {
-	grn_obj *table;
-	grn_obj *default_column = NULL;
-
-	table = RVAL2GRNOBJECT(rb_table, &context);
-	default_column = RVAL2GRNBULK(rb_default_column, context, default_column);
-	expression = grn_expr_create_from_str(context, name, name_size,
-					      query, query_size,
-					      table, default_column);
-    } else {
-	expression = grn_expr_create(context, name, name_size);
-    }
+    expression = grn_expr_create(context, name, name_size);
     rb_grn_object_assign(Qnil, self, rb_context, context, expression);
     rb_grn_context_check(context, self);
 
@@ -151,49 +132,52 @@ rb_grn_expression_define_variable (int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-rb_grn_expression_get_value (VALUE self, VALUE rb_offset)
-{
-    grn_ctx *context = NULL;
-    grn_obj *value, *expression;
-    int offset;
-
-    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
-                                  NULL, NULL,
-                                  NULL, NULL, NULL);
-
-    offset = NUM2INT(rb_offset);
-    value = grn_expr_get_value(context, expression, offset);
-    return GRNBULK2RVAL(context, value, self);
-}
-
-static VALUE
-rb_grn_expression_append_object (VALUE self, VALUE rb_object)
+rb_grn_expression_append_object (int argc, VALUE *argv, VALUE self)
 {
+    VALUE rb_object, rb_operation, rb_n_arguments;
     grn_ctx *context = NULL;
     grn_obj *expression, *object;
+    grn_operator operation = GRN_OP_PUSH;
+    int n_arguments = 1;
+
+    rb_scan_args(argc, argv, "12", &rb_object, &rb_operation, &rb_n_arguments);
+    if (!NIL_P(rb_operation))
+        operation = NUM2INT(rb_operation);
+    if (!NIL_P(rb_n_arguments))
+        n_arguments = NUM2INT(rb_n_arguments);
 
     rb_grn_expression_deconstruct(SELF(self), &expression, &context,
                                   NULL, NULL,
                                   NULL, NULL, NULL);
 
     object = RVAL2GRNOBJECT(rb_object, &context);
-    grn_expr_append_obj(context, expression, object);
+    grn_expr_append_obj(context, expression, object,
+                        operation, n_arguments);
     rb_grn_context_check(context, self);
     return self;
 }
 
 static VALUE
-rb_grn_expression_append_constant (VALUE self, VALUE rb_constant)
+rb_grn_expression_append_constant (int argc, VALUE *argv, VALUE self)
 {
+    VALUE rb_constant, rb_operator, rb_n_arguments;
     grn_ctx *context = NULL;
     grn_obj *expression, *constant = NULL;
+    grn_operator operator = GRN_OP_PUSH;
+    int n_arguments = 1;
+
+    rb_scan_args(argc, argv, "12", &rb_constant, &rb_operator, &rb_n_arguments);
+    if (!NIL_P(rb_operator))
+        operator = NUM2INT(rb_operator);
+    if (!NIL_P(rb_n_arguments))
+        n_arguments = NUM2INT(rb_n_arguments);
 
     rb_grn_expression_deconstruct(SELF(self), &expression, &context,
                                   NULL, NULL, NULL,
 				  NULL, NULL);
 
     RVAL2GRNOBJ(rb_constant, context, &constant);
-    grn_expr_append_const(context, expression, constant);
+    grn_expr_append_const(context, expression, constant, operator, n_arguments);
     grn_obj_close(context, constant);
     rb_grn_context_check(context, self);
     return self;
@@ -219,18 +203,94 @@ rb_grn_expression_append_operation (VALUE self, VALUE rb_operation,
     return Qnil;
 }
 
+static VALUE
+rb_grn_expression_parse (int argc, VALUE *argv, VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression, *default_column = NULL;
+    grn_operator default_operator = GRN_OP_AND;
+    grn_operator default_mode = GRN_OP_MATCH;
+    grn_rc rc;
+    char *query = NULL;
+    unsigned query_size = 0;
+    int parse_level = 0;
+    VALUE options, rb_query, rb_default_column, rb_default_operator;
+    VALUE rb_default_mode, rb_parser;
+    VALUE exception = Qnil;
+
+    rb_scan_args(argc, argv, "11", &rb_query, &options);
+    rb_grn_scan_options(options,
+                        "default_column", &rb_default_column,
+                        "default_operator", &rb_default_operator,
+                        "default_mode", &rb_default_mode,
+			"parser", &rb_parser,
+                        NULL);
+
+    query = StringValuePtr(rb_query);
+    query_size = RSTRING_LEN(rb_query);
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    default_column = RVAL2GRNBULK(rb_default_column, context, default_column);
+    if (!NIL_P(rb_default_mode))
+	default_mode = RVAL2GRNOPERATOR(rb_default_mode);
+    if (!NIL_P(rb_default_operator))
+	default_operator = RVAL2GRNOPERATOR(rb_default_operator);
+    if (NIL_P(rb_parser) ||
+	rb_grn_equal_option(rb_parser, "column") ||
+	rb_grn_equal_option(rb_parser, "column-query") ||
+	rb_grn_equal_option(rb_parser, "column_query")) {
+	parse_level = 0;
+    } else if (rb_grn_equal_option(rb_parser, "table") ||
+	       rb_grn_equal_option(rb_parser, "table-query") ||
+	       rb_grn_equal_option(rb_parser, "table_query")) {
+	parse_level = 2;
+    } else if (rb_grn_equal_option(rb_parser, "expression") ||
+	       rb_grn_equal_option(rb_parser, "language")) {
+	parse_level = 4;
+    } else {
+	rb_raise(rb_eArgError,
+		 "parser should be one of "
+		 "[nil, :column, :column_query, :table, :table_query, "
+		 ":expression, :language]: %s",
+		 rb_grn_inspect(rb_parser));
+    }
+
+    rc = grn_expr_parse(context, expression, query, query_size,
+			default_column, default_mode, default_operator,
+			parse_level);
+    if (rc != GRN_SUCCESS) {
+	VALUE related_object;
+
+	related_object = rb_ary_new3(2, self, rb_ary_new4(argc, argv));
+	exception = rb_grn_context_to_exception(context, related_object);
+    }
+    grn_obj_close(context, default_column);
+
+    if (!NIL_P(exception))
+	rb_exc_raise(exception);
+
+    return Qnil;
+}
+
 static VALUE
 rb_grn_expression_execute (VALUE self)
 {
     grn_ctx *context = NULL;
-    grn_obj *expression, *result;
+    grn_obj *expression;
+    grn_rc rc;
 
     rb_grn_expression_deconstruct(SELF(self), &expression, &context,
                                   NULL, NULL,
                                   NULL, NULL, NULL);
 
-    result = grn_expr_exec(context, expression);
-    return GRNOBJ2RVAL(Qnil, context, result, self);
+    rc = grn_expr_exec(context, expression, 0);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
 }
 
 static VALUE
@@ -284,6 +344,175 @@ rb_grn_expression_array_reference (VALUE self, VALUE rb_name_or_offset)
     return Qnil;
 }
 
+/* REMOVE ME */
+grn_rc grn_expr_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *expr);
+
+static VALUE
+rb_grn_expression_inspect (VALUE self)
+{
+    grn_rc rc;
+    grn_ctx *context = NULL;
+    grn_obj inspected;
+    grn_obj *expression;
+    VALUE rb_inspected;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    GRN_TEXT_INIT(&inspected, 0);
+    GRN_TEXT_PUTS(context, &inspected, "#<Groonga::Expression ");
+    rc = grn_expr_inspect(context, &inspected, expression);
+    GRN_TEXT_PUTS(context, &inspected, ">");
+    rb_inspected = rb_str_new(GRN_TEXT_VALUE(&inspected),
+			      GRN_TEXT_LEN(&inspected));
+    GRN_OBJ_FIN(context, &inspected);
+
+    return rb_inspected;
+}
+
+/*
+ * call-seq:
+ *   expression.snippet(tags, options) -> Groonga::Snippet
+ *
+ * _expression_からGroonga::Snippetを生成する。_tags_にはキー
+ * ワードの前後に挿入するタグの配列を以下のような形式で指定
+ * する。
+ *
+ *   [
+ *    ["キーワード前に挿入する文字列1", "キーワード後に挿入する文字列1"],
+ *    ["キーワード前に挿入する文字列2", "キーワード後に挿入する文字列2"],
+ *    ...,
+ *   ]
+ *
+ * もし、1つのスニペットの中に_tags_で指定したタグより多くの
+ * キーワードが含まれている場合は、以下のように、また、先頭
+ * のタグから順番に使われる。
+ *
+ *   expression.parse("Ruby groonga 検索")
+ *   tags = [["<tag1>", "</tag1>"], ["<tag2>", "</tag2>"]]
+ *   snippet = expression.snippet(tags)
+ *   p snippet.execute("Rubyでgroonga使って全文検索、高速検索。")
+ *     # => ["<tag1>Ruby</tag1>で<tag2>groonga</tag2>"
+ *     #     "使って全文<tag1>検索</tag1>、高速<tag2>検索</tag2>。"]
+ *
+ * _options_に指定可能な値は以下の通り。
+ *
+ * [+:normalize+]
+ *   キーワード文字列・スニペット元の文字列を正規化するかど
+ *   うか。省略した場合は+false+で正規化しない。
+ *
+ * [+:skip_leading_spaces+]
+ *   先頭の空白を無視するかどうか。省略した場合は+false+で無
+ *   視しない。
+ *
+ * [+:width+]
+ *   スニペット文字列の長さ。省略した場合は100文字。
+ *
+ * [+:max_results+]
+ *   生成するスニペットの最大数。省略した場合は3。
+ *
+ * [+:html_escape+]
+ *   スニペット内の+<+, +>+, +&+, +"+をHTMLエスケープするか
+ *   どうか。省略した場合は+false+で、HTMLエスケープしない。
+ */
+static VALUE
+rb_grn_expression_snippet (int argc, VALUE *argv, VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression;
+    grn_snip *snippet;
+    VALUE options;
+    VALUE rb_normalize, rb_skip_leading_spaces;
+    VALUE rb_width, rb_max_results, rb_tags;
+    VALUE rb_html_escape;
+    VALUE *rb_tag_values;
+    unsigned int i;
+    int flags = GRN_SNIP_COPY_TAG;
+    unsigned int width = 100;
+    unsigned int max_results = 3;
+    unsigned int n_tags = 0;
+    char **open_tags = NULL;
+    unsigned int *open_tag_lengths = NULL;
+    char **close_tags = NULL;
+    unsigned int *close_tag_lengths = NULL;
+    grn_snip_mapping *mapping = NULL;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    rb_scan_args(argc, argv, "11", &rb_tags, &options);
+
+    rb_grn_scan_options(options,
+                        "normalize", &rb_normalize,
+                        "skip_leading_spaces", &rb_skip_leading_spaces,
+                        "width", &rb_width,
+                        "max_results", &rb_max_results,
+                        "html_escape", &rb_html_escape,
+                        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));
+    }
+
+    if (TYPE(RARRAY_PTR(rb_tags)[0]) == T_STRING) {
+	rb_tags = rb_ary_new3(1, rb_tags);
+    }
+
+    rb_tag_values = RARRAY_PTR(rb_tags);
+    n_tags = RARRAY_LEN(rb_tags);
+    open_tags = ALLOCA_N(char *, n_tags);
+    open_tag_lengths = ALLOCA_N(unsigned int, n_tags);
+    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]);
+    }
+
+    if (RVAL2CBOOL(rb_normalize))
+        flags |= GRN_SNIP_NORMALIZE;
+    if (RVAL2CBOOL(rb_skip_leading_spaces))
+        flags |= GRN_SNIP_SKIP_LEADING_SPACES;
+
+    if (!NIL_P(rb_width))
+        width = NUM2UINT(rb_width);
+
+    if (!NIL_P(rb_max_results))
+        max_results = NUM2UINT(rb_max_results);
+
+    if (RVAL2CBOOL(rb_html_escape))
+        mapping = (grn_snip_mapping *)-1;
+
+    snippet = grn_expr_snip(context, expression, flags, width, max_results,
+			    n_tags,
+                            (const char **)open_tags, open_tag_lengths,
+                            (const char **)close_tags, close_tag_lengths,
+                            mapping);
+    rb_grn_context_check(context,
+			 rb_ary_new3(2, self, rb_ary_new4(argc, argv)));
+
+    return GRNSNIPPET2RVAL(context, snippet, RB_GRN_TRUE);
+}
+
 void
 rb_grn_init_expression (VALUE mGrn)
 {
@@ -295,20 +524,26 @@ rb_grn_init_expression (VALUE mGrn)
     rb_define_method(rb_cGrnExpression, "define_variable",
                      rb_grn_expression_define_variable, -1);
     rb_define_method(rb_cGrnExpression, "append_object",
-                     rb_grn_expression_append_object, 1);
+                     rb_grn_expression_append_object, -1);
     rb_define_method(rb_cGrnExpression, "append_constant",
-                     rb_grn_expression_append_constant, 1);
+                     rb_grn_expression_append_constant, -1);
     rb_define_method(rb_cGrnExpression, "append_operation",
                      rb_grn_expression_append_operation, 2);
 
+    rb_define_method(rb_cGrnExpression, "parse",
+                     rb_grn_expression_parse, -1);
+
     rb_define_method(rb_cGrnExpression, "execute",
                      rb_grn_expression_execute, 0);
     rb_define_method(rb_cGrnExpression, "compile",
                      rb_grn_expression_compile, 0);
 
-    rb_define_method(rb_cGrnExpression, "value",
-                     rb_grn_expression_get_value, 1);
-
     rb_define_method(rb_cGrnExpression, "[]",
                      rb_grn_expression_array_reference, 1);
+
+    rb_define_method(rb_cGrnExpression, "snippet",
+                     rb_grn_expression_snippet, -1);
+
+    rb_define_method(rb_cGrnExpression, "inspect",
+                     rb_grn_expression_inspect, 0);
 }