zoom 0.3.0

data/src/rbzoomquery.c

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2005 Laurent Sansonetti <lrz@chopine.be>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "rbzoom.h"
+
+/* Class: ZOOM::Query
+ * Search queries.
+ */
+static VALUE cZoomQuery;
+
+static VALUE
+rbz_query_make (ZOOM_query query)
+{
+    return query != NULL
+        ? Data_Wrap_Struct (cZoomQuery,
+                            NULL,
+                            ZOOM_query_destroy,
+                            query)
+        : Qnil;
+}
+
+ZOOM_query
+rbz_query_get (VALUE obj)
+{
+    ZOOM_query query;
+        
+    Data_Get_Struct (obj, struct ZOOM_query_p, query);
+    assert (query != NULL);
+
+    return query;
+}
+
+/*
+ * Class method: new_prefix(prefix)
+ * prefix: PQF notation.
+ *
+ * Creates a RPN query using the given PQF notation.
+ *
+ * Returns: a newly created ZOOM::Query object.
+ */
+static VALUE
+rbz_query_new_prefix (VALUE self, VALUE prefix)
+{
+    ZOOM_query query;
+
+    query = ZOOM_query_create ();
+    ZOOM_query_prefix (query, RVAL2CSTR (prefix)); 
+    
+    return rbz_query_make (query);
+}
+
+/*
+ * Class method: new_cql(prefix)
+ * prefix: CQL notation.
+ *
+ * Creates a CQL query using the given CQL notation.
+ *
+ * Returns: a newly created ZOOM::Query object.
+ */
+static VALUE
+rbz_query_new_cql (VALUE self, VALUE cql)
+{
+    ZOOM_query query;
+
+    query = ZOOM_query_create ();
+    ZOOM_query_cql (query, RVAL2CSTR (cql)); 
+    
+    return rbz_query_make (query);
+}
+
+/*
+ * Class method: new_sort_by(criteria)
+ * criteria: a sort criteria.
+ *
+ * Creates a sort query from the YAZ sorting notation.
+ *
+ * Returns: a newly created ZOOM::Query object.
+ */
+static VALUE
+rbz_query_new_sort_by (VALUE self, VALUE criteria)
+{
+    ZOOM_query query;
+
+    query = ZOOM_query_create ();
+    ZOOM_query_sortby (rbz_query_get (self), RVAL2CSTR (criteria)); 
+    
+    return rbz_query_make (query);
+}
+
+void
+Init_zoom_query (VALUE mZoom)
+{
+    VALUE c;
+
+    c = rb_define_class_under (mZoom, "Query", rb_cObject); 
+    rb_define_singleton_method (c, "new_prefix", rbz_query_new_prefix, 1);
+    rb_define_singleton_method (c, "new_cql", rbz_query_new_cql, 1);
+    rb_define_singleton_method (c, "new_sort_by", rbz_query_new_sort_by, 1);
+            
+    cZoomQuery = c;
+}

data/src/rbzoomrecord.c

@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2005 Laurent Sansonetti <lrz@chopine.be>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "rbzoom.h"
+
+/* Class: ZOOM::Record
+ * A record object is a retrieval record on the client side - created from 
+ * result sets.
+ */
+static VALUE cZoomRecord;
+
+VALUE
+rbz_record_make (ZOOM_record record)
+{
+    return record != NULL
+        ? Data_Wrap_Struct (cZoomRecord,
+                            NULL,
+                            ZOOM_record_destroy,
+                            record)
+        : Qnil;
+}
+
+static ZOOM_record
+rbz_record_get (VALUE obj)
+{
+    ZOOM_record record;
+        
+    Data_Get_Struct (obj, struct ZOOM_record_p, record);
+    assert (record != NULL);
+
+    return record;
+}
+
+static char _type [128];
+
+static const char *
+rbz_record_type (const char *form, int argc, VALUE *argv)
+{
+    VALUE charset_from;
+    VALUE charset_to;
+
+    if (argc == 0)
+        return form;
+
+    rb_scan_args (argc, argv, "11", &charset_from, &charset_to);
+   
+    memset (_type, 0, sizeof _type);
+    
+    if (NIL_P (charset_to))
+        snprintf (_type, sizeof _type, "%s; charset=%s", form, 
+                  RVAL2CSTR (charset_from));
+    else
+        snprintf (_type, sizeof _type, "%s; charset=%s,%s", form, 
+                  RVAL2CSTR (charset_from), RVAL2CSTR (charset_to));
+
+    return _type;
+}
+
+/*
+ * Method: database(charset_from=nil, charset_to=nil)
+ * charset_from: the name of the charset to convert from (optional).
+ * charset_to: the name of the charset to convert to (optional).
+ *
+ * Returns: the database name of the record.
+ */
+static VALUE
+rbz_record_database (int argc, VALUE *argv, VALUE self)
+{
+    return CSTR2RVAL (ZOOM_record_get (rbz_record_get (self),
+                                       rbz_record_type ("database", argc, argv),
+                                       NULL));    
+}
+
+/*
+ * Method: syntax(charset_from=nil, charset_to=nil)
+ * charset_from: the name of the charset to convert from (optional).
+ * charset_to: the name of the charset to convert to (optional).
+ *
+ * Returns: the symbolic transfer syntax name of the record.
+ */
+static VALUE
+rbz_record_syntax (int argc, VALUE *argv, VALUE self)
+{
+    return CSTR2RVAL (ZOOM_record_get (rbz_record_get (self),
+                                       rbz_record_type ("syntax", argc, argv),
+                                       NULL));    
+}
+
+/*
+ * Method: render(charset_from=nil, charset_to=nil)
+ * charset_from: the name of the charset to convert from (optional).
+ * charset_to: the name of the charset to convert to (optional).
+ *
+ * Returns: a display friendly description of the record.
+ */
+static VALUE
+rbz_record_render (int argc, VALUE *argv, VALUE self)
+{
+    return CSTR2RVAL (ZOOM_record_get (rbz_record_get (self),
+                                       rbz_record_type ("render", argc, argv),
+                                       NULL));    
+}
+
+/*
+ * Method: xml(charset_from=nil, charset_to=nil)
+ * charset_from: the name of the charset to convert from (optional).
+ * charset_to: the name of the charset to convert to (optional).
+ *
+ * Returns an XML description of the record.  SRW/SRU and Z39.50 records with 
+ * transfer syntax XML are returned verbatim.  MARC records are returned in 
+ * MARCXML (converted from ISO2709 to MARCXML by YAZ). GRS-1 and OPAC records are 
+ * not supported for this form. 
+ * 
+ * Returns: an XML description of the record.
+ */
+static VALUE
+rbz_record_xml (int argc, VALUE *argv, VALUE self)
+{
+    return CSTR2RVAL (ZOOM_record_get (rbz_record_get (self),
+                                       rbz_record_type ("xml", argc, argv),
+                                       NULL));    
+}
+
+/*
+ * Method: raw(charset_from=nil, charset_to=nil)
+ * charset_from: the name of the charset to convert from (optional).
+ * charset_to: the name of the charset to convert to (optional).
+ * 
+ * Does not change the leader on character conversion.
+ *
+ * MARC records are returned in ISO2709.
+ * GRS-1 and OPAC records are not supported for this form. 
+ * 
+ * Returns: an ISO2709 record.
+ */
+
+static VALUE
+rbz_record_raw (int argc, VALUE *argv, VALUE self)
+{
+    return CSTR2RVAL (ZOOM_record_get (rbz_record_get (self),
+                                       rbz_record_type ("raw", argc, argv),
+                                       NULL));    
+}
+
+void
+Init_zoom_record (VALUE mZoom)
+{
+    VALUE c;
+    
+    c = rb_define_class_under (mZoom, "Record", rb_cObject); 
+    rb_undef_method (CLASS_OF (c), "new");
+
+    rb_define_method (c, "database", rbz_record_database, -1);
+    rb_define_method (c, "syntax", rbz_record_syntax, -1);
+    rb_define_method (c, "render", rbz_record_render, -1);
+    rb_define_alias (c, "to_s", "render");
+    rb_define_method (c, "xml", rbz_record_xml, -1);
+    rb_define_method (c, "raw", rbz_record_raw, -1);
+    
+    cZoomRecord = c;
+}

data/src/rbzoomresultset.c

@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2005 Laurent Sansonetti <lrz@chopine.be>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "rbzoom.h"
+
+/* Class: ZOOM::ResultSet
+ * The result set object is a container for records returned from a target.
+ */
+static VALUE cZoomResultSet;
+
+VALUE
+rbz_resultset_make (ZOOM_resultset resultset)
+{
+    return resultset != NULL
+        ? Data_Wrap_Struct (cZoomResultSet,
+                            NULL,
+                            ZOOM_resultset_destroy,
+                            resultset)
+        : Qnil;
+}
+
+static ZOOM_resultset
+rbz_resultset_get (VALUE obj)
+{
+    ZOOM_resultset resultset;
+        
+    Data_Get_Struct (obj, struct ZOOM_resultset_p, resultset);
+    assert (resultset != NULL);
+
+    return resultset;
+}
+
+/*
+ * Method: set_option(key, value)
+ * key: the name of the option, as a string.
+ * value: the value of this option (as a string, integer or boolean).
+ *
+ * Sets an option on the result set.
+ * 
+ * Returns: self.
+ */
+static VALUE
+rbz_resultset_set_option (VALUE self, VALUE key, VALUE val)
+{
+    ZOOM_resultset_option_set (rbz_resultset_get (self),
+                               RVAL2CSTR (key),
+                               RVAL2CSTR (rb_obj_as_string (val)));
+    
+    return self;
+}
+
+/*
+ * Method: get_option(key)
+ * key: the name of the option, as a string.
+ *
+ * Gets the value of a result set's option.
+ * 
+ * Returns: the value of the given option, as a string, integer or boolean.
+ */
+static VALUE
+rbz_resultset_get_option (VALUE self, VALUE key)
+{
+    const char *value;
+ 
+    value = ZOOM_resultset_option_get (rbz_resultset_get (self),
+                                       RVAL2CSTR (key));
+
+    return zoom_option_value_to_ruby_value (value);
+}
+
+/* Method: size
+ * Returns: the number of hits.
+ */
+static VALUE
+rbz_resultset_size (VALUE self)
+{
+    return INT2NUM (ZOOM_resultset_size (rbz_resultset_get (self)));
+}
+
+/*
+ * Method: [](key)
+ * key: either an integer, a range or an interval of 2 integers.
+ *
+ * Retrieves one or many records from the result set, according to the given
+ * key.
+ *
+ * 	# Gets the first record.
+ * 	rset[0]
+ * 	# Gets the first, second and third records.
+ * 	rset[1..3]
+ * 	# Gets three records starting from the second one.
+ * 	rset[2, 3]
+ *
+ * Returns: one or many references to ZOOM::Record objects.
+ */
+static VALUE
+rbz_resultset_index (int argc, VALUE *argv, VALUE self)
+{
+    ZOOM_record record;
+    VALUE ary;
+    size_t begin;
+    size_t count;
+    size_t i;
+    
+    if (argc == 1) {
+        VALUE arg = argv [0];
+
+        if (TYPE (arg) == T_FIXNUM || TYPE (arg) == T_BIGNUM) {
+            record = ZOOM_resultset_record (rbz_resultset_get (self),
+                                            NUM2LONG (arg));
+            return record != NULL
+                ? rbz_record_make (ZOOM_record_clone (record))
+                : Qnil;
+        }
+       
+        if (CLASS_OF (arg) == rb_cRange) {
+            begin = NUM2LONG (rb_funcall (arg, rb_intern ("begin"), 0));
+            count = NUM2LONG (rb_funcall (arg, rb_intern ("end"), 0));
+            count -= begin;
+        }
+        else
+            rb_raise (rb_eArgError, 
+                      "Invalid argument of type %s (not Numeric or Range)",
+                      rb_class2name (CLASS_OF (arg)));
+    }
+    else {
+        VALUE rb_begin;
+        VALUE rb_count;
+        
+        rb_scan_args (argc, argv, "2", &rb_begin, &rb_count);
+        
+        begin = NUM2LONG (rb_begin);
+        count = NUM2LONG (rb_count);
+    }
+        
+    ary = rb_ary_new ();
+    if (count == 0)
+        return ary;
+
+    for (i = 0; i < count; i++) {
+        record = ZOOM_resultset_record (rbz_resultset_get (self),
+                                        begin + i);
+        if (record != NULL)
+            rb_ary_push (ary, rbz_record_make (ZOOM_record_clone (record)));
+    }
+    return ary;
+}
+
+/*
+ * Method: records
+ *
+ * Lists the records inside the result set.
+ *
+ * Returns: an array of ZOOM::Record objects.
+ */
+static VALUE
+rbz_resultset_records (VALUE self)
+{
+    VALUE argv [2];
+
+    argv [0] = INT2FIX (0);
+    argv [1] = rbz_resultset_size (self);
+    
+    return rbz_resultset_index (2, argv, self);
+}
+
+/*
+ * Method: each_record { |record| ... }
+ *
+ * Parses the records inside the result set and call the given block for each
+ * record, passing a reference to a ZOOM::Record object as parameter.
+ *
+ * Returns: self.
+ */
+static VALUE
+rbz_resultset_each_record (VALUE self)
+{
+    rb_ary_each (rbz_resultset_records (self));
+    return self;
+}
+
+void
+Init_zoom_resultset (VALUE mZoom)
+{
+    VALUE c;
+    
+    c = rb_define_class_under (mZoom, "ResultSet", rb_cObject); 
+    rb_undef_method (CLASS_OF (c), "new");
+    rb_define_method (c, "set_option", rbz_resultset_set_option, 2);
+    rb_define_method (c, "get_option", rbz_resultset_get_option, 1);
+    
+    define_zoom_option (c, "start");
+    define_zoom_option (c, "count");
+    define_zoom_option (c, "presentChunk");
+    define_zoom_option (c, "elementSetName");
+    define_zoom_option (c, "preferredRecordSyntax");
+    define_zoom_option (c, "schema");
+    define_zoom_option (c, "setname");
+    
+    rb_define_method (c, "size", rbz_resultset_size, 0);
+    rb_define_alias (c, "length", "size");
+    rb_define_method (c, "records", rbz_resultset_records, 0);
+    rb_define_method (c, "each_record", rbz_resultset_each_record, 0);
+    rb_define_method (c, "[]", rbz_resultset_index, -1);
+    
+    cZoomResultSet = c;
+}