gonzui 1.2

data/data/gonzuirc.sample

@@ -0,0 +1,29 @@
+{
+  :access_log_file          => "access.log",
+  :base_mount_point         => "",
+  :cache_directory          => "gonzui.db/cache",
+#  :catalog_directory        => "catalog",
+  :daemon                   => false,
+  :db_cache_size            => 5242880,
+  :db_directory             => "gonzui.db",
+  :default_results_per_page => 10,
+#  :doc_directory            => "doc",
+  :encoding_preference      => ["iso-2022-jp", "euc-jp", "utf-8", "shift_jis", "cp932", "iso-8859-1", "ascii"],
+  :exclude_pattern          => /~$|\.bak$|CVS|\.svn|\.git/,
+  :gonzui_log_file          => "gonzui.log",
+  :group                    => "Administrators",
+  :http_port                => 46984,
+  :max_packages_per_page    => 100,
+  :max_pages                => 20,
+  :max_results_per_page     => 50,
+  :max_words                => 10,
+  :noindex_formats          => [],
+  :nresults_candidates      => [10, 20, 30, 50],
+  :pid_file                 => "gonzui.pid",
+  :quiet                    => false,
+  :site_title               => "gonzui",
+#  :temporary_directory      => "/tmp",
+  :user                     => "Administrator",
+  :utf8                     => true,
+  :verbose                  => false,
+}

data/ext/autopack/autopack.c

@@ -0,0 +1,88 @@
+/* -*- mode: C; indent-tabs-mode: nil; c-basic-offset: 2 c-style: "BSD" -*- */
+/*
+ * autopack.c - C functions for AutoPack module.
+ *
+ * Copyright (C) 2005 Satoru Takabayashi <satoru@namazu.org> 
+ *      All rights reserved.
+ *      This is free software with ABSOLUTELY NO WARRANTY.
+ * 
+ *  You can redistribute it and/or modify it under the terms of 
+ *  the GNU General Public License version 2.
+ */
+
+#include <ruby.h>
+
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+static VALUE
+rb_autopack_pack_fixnum(VALUE obj, VALUE value)
+{
+    int n;
+    unsigned char str[4];
+    if (TYPE(value) != T_FIXNUM) {
+        rb_raise(rb_eTypeError, "Fixnum expected");
+    }
+    n = FIX2INT(value);
+    str[0] = (n >> 24) & 0xff;
+    str[1] = (n >> 16) & 0xff;
+    str[2] = (n >>  8) & 0xff;
+    str[3] =  n        & 0xff;
+    return rb_str_new(str, 4);
+}
+
+static VALUE
+rb_autopack_pack_id2(VALUE obj, VALUE id1, VALUE id2)
+{
+    int n1, n2;
+    unsigned char str[8];
+    if (!(TYPE(id1) == T_FIXNUM && TYPE(id2) == T_FIXNUM)) {
+        rb_raise(rb_eTypeError, "Fixnum expected");
+    }
+    n1 = FIX2INT(id1);
+    n2 = FIX2INT(id2);
+    str[0] = (n1 >> 24) & 0xff;
+    str[1] = (n1 >> 16) & 0xff;
+    str[2] = (n1 >>  8) & 0xff;
+    str[3] =  n1        & 0xff;
+    str[4] = (n2 >> 24) & 0xff;
+    str[5] = (n2 >> 16) & 0xff;
+    str[6] = (n2 >>  8) & 0xff;
+    str[7] =  n2        & 0xff;
+    return rb_str_new(str, 8);
+}
+
+static VALUE
+rb_autopack_unpack_fixnum(VALUE obj, VALUE value)
+{
+    int n;
+    unsigned char *str;
+    if (TYPE(value) != T_STRING) {
+        rb_raise(rb_eTypeError, "String expected");
+    }
+    str = RSTRING_PTR(value);
+    n = (str[0] << 24) + (str[1] << 16) + (str[2] << 8) + str[3];
+    return INT2FIX(n);
+}
+
+void Init_autopack()
+{
+  VALUE mGonzui, mAutoPack;
+  mGonzui = rb_define_module("Gonzui");
+  mAutoPack = rb_define_module_under(mGonzui, "AutoPack");
+
+  rb_define_module_function(mAutoPack, "pack_id", 
+                            rb_autopack_pack_fixnum, 1);
+  rb_define_module_function(mAutoPack, "unpack_id", 
+                            rb_autopack_unpack_fixnum, 1);
+
+  rb_define_module_function(mAutoPack, "pack_fixnum", 
+                            rb_autopack_pack_fixnum, 1);
+  rb_define_module_function(mAutoPack, "unpack_fixnum", 
+                            rb_autopack_unpack_fixnum, 1);
+  rb_define_module_function(mAutoPack, "pack_id2", 
+                            rb_autopack_pack_id2, 2);
+}
+
+

data/ext/autopack/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('gonzui/autopack')

data/ext/delta/delta.c

@@ -0,0 +1,147 @@
+/* -*- mode: C; indent-tabs-mode: nil; c-basic-offset: 2 c-style: "BSD" -*- */
+/*
+ * delta.c - byte-oriented delta compression implementation
+ *
+ * Copyright (C) 2005 Satoru Takabayashi <satoru@namazu.org> 
+ * Copyright (C) 2005 Keisuke Nishida <knishida@open-cobol.org>
+ *      All rights reserved.
+ *      This is free software with ABSOLUTELY NO WARRANTY.
+ * 
+ *  You can redistribute it and/or modify it under the terms of 
+ *  the GNU General Public License version 2.
+ */
+
+#include <ruby.h>
+#include <assert.h>
+
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(str) (RARRAY(str)->ptr)
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(str) (RARRAY(str)->len)
+#endif
+
+typedef void (*CodeFunc)(VALUE *p, int i, int *prev);
+
+static inline void
+decode(VALUE *p, int i, int *prev)
+{
+  int this;
+  if (TYPE(p[i]) != T_FIXNUM) {
+    rb_raise(rb_eTypeError, "wrong argument type (fixnum required)");
+  }
+  this = FIX2INT(p[i]);
+  p[i] = INT2FIX(this + *prev);
+  *prev = FIX2INT(p[i]);
+}
+
+static inline void
+encode(VALUE *p, int i, int *prev)
+{
+  int this;
+  if (TYPE(p[i]) != T_FIXNUM) {
+    rb_raise(rb_eTypeError, "wrong argument type (fixnum required)");
+  }
+
+  this = FIX2INT(p[i]);
+  p[i] = INT2FIX(this - *prev);
+  if (FIX2INT(p[i]) < 0) {
+    rb_raise(rb_eArgError, "Encode failed: value becomes minus");
+  }
+  *prev = this;
+}
+
+static VALUE
+rb_delta_code_tuples(VALUE obj, VALUE list, 
+                     VALUE delta_size, VALUE unit_size, CodeFunc code)
+{
+  enum { PREV_MAX = 128 };
+  int i, j;
+  int dsize;
+  int usize;
+  long len;
+  int prev[PREV_MAX];
+  VALUE *p;
+
+  if (!(TYPE(list) == T_ARRAY && TYPE(delta_size) == T_FIXNUM &&
+        TYPE(unit_size) == T_FIXNUM && FIX2INT(delta_size) < PREV_MAX ))
+  {
+    rb_raise(rb_eTypeError, "wrong argument type");
+  }
+
+  dsize = FIX2INT(delta_size);
+  usize = FIX2INT(unit_size);
+  len = RARRAY_LEN(list);
+  if (!(len % usize == 0 && dsize <= usize)) {
+    rb_raise(rb_eArgError, "wrong argument size");
+  }
+  p = RARRAY_PTR(list); 
+  memset(prev, 0, sizeof(int) * dsize);
+  for (i = 0; i < len; i += usize) {
+    for (j = 0; j < dsize; j++) {
+      code(p, i + j, prev + j);
+    }
+  }
+  return list;
+}
+
+static VALUE
+rb_delta_decode_tuples(VALUE obj, VALUE list, 
+                       VALUE delta_size, VALUE unit_size)
+{
+  return rb_delta_code_tuples(obj, list, delta_size, unit_size, decode);
+}
+
+static VALUE
+rb_delta_encode_tuples(VALUE obj, VALUE list, 
+                       VALUE delta_size, VALUE unit_size)
+{
+  return rb_delta_code_tuples(obj, list, delta_size, unit_size, encode);
+}
+
+static VALUE
+rb_delta_code_fixnums(VALUE obj, VALUE list, CodeFunc code)
+{
+  int i;
+  long len;
+  VALUE *p; 
+  int prev = 0;
+  if (TYPE(list) != T_ARRAY) {
+    rb_raise(rb_eTypeError, "wrong argument type");
+  }
+  p = RARRAY_PTR(list);
+  len = RARRAY_LEN(list);
+  for (i = 0; i < len; i++) {
+    code(p, i, &prev);
+  }
+  return list;
+}
+
+static VALUE
+rb_delta_decode_fixnums(VALUE obj, VALUE list)
+{
+  rb_delta_code_fixnums(obj, list, decode);
+}
+
+static VALUE
+rb_delta_encode_fixnums(VALUE obj, VALUE list)
+{
+  rb_delta_code_fixnums(obj, list, encode);
+}
+
+void Init_delta()
+{
+  VALUE mGonzui, mDelta;
+  mGonzui = rb_define_module("Gonzui");
+  mDelta = rb_define_module_under(mGonzui, "DeltaDumper");
+  rb_define_module_function(mDelta, "encode_tuples", 
+                            rb_delta_encode_tuples, 3);
+  rb_define_module_function(mDelta, "decode_tuples", 
+                            rb_delta_decode_tuples, 3);
+  rb_define_module_function(mDelta, "encode_fixnums", 
+                            rb_delta_encode_fixnums, 1);
+  rb_define_module_function(mDelta, "decode_fixnums",
+                            rb_delta_decode_fixnums, 1);
+}
+
+

data/ext/delta/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+dir_config("delta")
+
+create_makefile("gonzui/delta")

data/ext/texttokenizer/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+dir_config("texttokenizer")
+
+create_makefile("gonzui/texttokenizer")

data/ext/texttokenizer/texttokenizer.c

@@ -0,0 +1,93 @@
+/* -*- mode: C; indent-tabs-mode: nil; c-basic-offset: 2 c-style: "BSD" -*- */
+/* 
+ * texttokenizer.c - a simple text tokenizer
+ *
+ * Copyright (C) 2005 Satoru Takabayashi <satoru@namazu.org> 
+ * Copyright (C) 2005 Keisuke Nishida <knishida@open-cobol.org>
+ *     All rights reserved.
+ *     This is free software with ABSOLUTELY NO WARRANTY.
+ * 
+ * You can redistribute it and/or modify it under the terms of 
+ * the GNU General Public License version 2.
+ *
+ *
+ */
+
+#include <assert.h>
+#include <ruby.h>
+
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+static inline int utf8len(const unsigned char *s, const unsigned char *eot)
+{
+  int len = 0;
+  if (*s < 0x80) {
+    len = 1;
+  } else if ((s + 1 < eot) && (*s & 0xe0) == 0xc0) {
+    len = 2;
+  } else if ((s + 2 < eot) && (*s & 0xf0) == 0xe0) {
+    len = 3;
+  } else if ((s + 3 < eot) && (*s & 0xf8) == 0xf0) {
+    len = 4;
+  } else if ((s + 4 < eot) && (*s & 0xfc) == 0xf8) {
+    len = 5;
+  } else if ((s + 5 < eot) && (*s & 0xfe) == 0xfc) {
+    len = 6;
+  } else {
+    rb_raise(rb_eArgError, "invalid UTF-8 character");
+  }
+  return len;
+}
+
+static inline unsigned char *
+skip(unsigned char *s, unsigned char *eot)
+{
+  for (; s < eot; s++)
+    if (isalnum(*s) || *s >= 0x80)
+      break;
+  return s;
+}
+
+/*
+ * Iterate over each word.
+ * word:  [a-zA-Z0-9]+ or single multi-byte UTF-8 character
+ */
+static VALUE texttokenizer_each_word(VALUE obj, VALUE text)
+{
+  VALUE str;
+  unsigned char *s, *beg, *eot;
+
+  str = rb_obj_as_string(text);
+  beg = RSTRING_PTR(str);
+  eot = beg + RSTRING_LEN(str);
+  s = skip(beg, eot);
+
+  while (s < eot) {
+    unsigned char *b = s;
+    if (*s >= 0x80) {
+      s += utf8len(s, eot);
+    } else {
+      for (; s < eot; s++)
+        if (!((isalnum(*s) || *s == '_')))
+          break;
+    }
+    rb_yield_values(2, rb_str_new(b, s - b), INT2FIX(b - beg));
+    s = skip(s, eot);
+  }
+  return Qnil;
+}
+
+void Init_texttokenizer()
+{
+  VALUE mGonzui, mTextTokenizer;
+  mGonzui = rb_define_module("Gonzui");
+  mTextTokenizer = rb_define_module_under(mGonzui, "TextTokenizer");
+
+  rb_define_module_function(mTextTokenizer, "each_word",
+                            texttokenizer_each_word, 1);
+}

data/ext/xmlformatter/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+dir_config("xmlformatter")
+
+create_makefile("gonzui/webapp/xmlformatter")

data/ext/xmlformatter/xmlformatter.c

@@ -0,0 +1,207 @@
+/* -*- mode: C; indent-tabs-mode: nil; c-basic-offset: 2 c-style: "BSD" -*- */
+/* 
+ * xmlformatter.c - a simple class for generating XML texts
+ *
+ * Copyright (C) 2004-2005 Keisuke Nishida <knishida@open-cobol.org>
+ *     All rights reserved.
+ *     This is free software with ABSOLUTELY NO WARRANTY.
+ * 
+ * You can redistribute it and/or modify it under the terms of 
+ * the GNU General Public License version 2.
+ */
+
+#include <ruby.h>
+#include <st.h>
+
+#define BLOCK_SIZE	(128 * 1024)	/* 128 KB */
+
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(str) (RARRAY(str)->ptr)
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(str) (RARRAY(str)->len)
+#endif
+
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+typedef struct gonzui_xmlformatter {
+  char *data;
+  size_t size;
+  size_t max_size;
+} gonzui_xmlformatter_t;
+
+static gonzui_xmlformatter_t *xmlformatter_new(void)
+{
+  gonzui_xmlformatter_t *xf = malloc(sizeof(gonzui_xmlformatter_t));
+  memset(xf, 0, sizeof(gonzui_xmlformatter_t));
+  xf->max_size = BLOCK_SIZE;
+  xf->size = 0;
+  xf->data = malloc(xf->max_size);
+  return xf;
+}
+
+static void xmlformatter_write(gonzui_xmlformatter_t *xf, char *data)
+{
+  long size = strlen(data);
+  if (xf->size + size > xf->max_size) {
+    xf->max_size += BLOCK_SIZE;
+    xf->data = realloc(xf->data, xf->max_size);
+  }
+  memcpy(xf->data + xf->size, data, size);
+  xf->size += size;
+}
+
+static void xmlformatter_write_obj(gonzui_xmlformatter_t *xf, VALUE obj)
+{
+  char *p;
+  char *data;
+  size_t size;
+  if (SYMBOL_P(obj)) {
+    data = rb_id2name(SYM2ID(obj));
+    size = strlen(data);
+  } else {
+    VALUE s = rb_obj_as_string(obj);
+    data = RSTRING_PTR(s);
+    size = RSTRING_LEN(s);
+  }
+  if (xf->size + size * 6 > xf->max_size) {
+    xf->max_size += BLOCK_SIZE;
+    xf->data = realloc(xf->data, xf->max_size);
+  }
+  for (p = data; *p; p++) {
+    int c = *p;
+    if (c == '<') {
+      memcpy(xf->data + xf->size, "&lt;", 4);
+      xf->size += 4;
+    } else if (c == '>') {
+      memcpy(xf->data + xf->size, "&gt;", 4);
+      xf->size += 4;
+    } else if (c == '&') {
+      memcpy(xf->data + xf->size, "&amp;", 5);
+      xf->size += 5;
+    } else if (c == '"') {
+      memcpy(xf->data + xf->size, "&quot;", 6);
+      xf->size += 6;
+    } else {
+      xf->data[xf->size++] = c;
+    }
+  }
+}
+
+static void xmlformatter_free(gonzui_xmlformatter_t *xf)
+{
+  if (xf == NULL)
+    return;
+  free(xf->data);
+  free(xf);
+}
+
+static VALUE xmlformatter_s_allocate(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, NULL, xmlformatter_free, NULL);
+}
+
+static VALUE xmlformatter_initialize(VALUE self)
+{
+  gonzui_xmlformatter_t *xf;
+  Data_Get_Struct(self, gonzui_xmlformatter_t, xf);
+  if (xf)
+    rb_raise(rb_eArgError, "called twice");
+
+  DATA_PTR(self) = xmlformatter_new();
+  return self;
+}
+
+static VALUE xmlformatter_add_xml_declaration(VALUE self)
+{
+  gonzui_xmlformatter_t *xf;
+  Data_Get_Struct(self, gonzui_xmlformatter_t, xf);
+  if (xf)
+    xmlformatter_write(xf, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+  return Qnil;
+}
+
+static VALUE xmlformatter_add_doctype(VALUE self)
+{
+  gonzui_xmlformatter_t *xf;
+  Data_Get_Struct(self, gonzui_xmlformatter_t, xf);
+  if (xf)
+    xmlformatter_write(xf, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"\n"
+		       "    \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n");
+  return Qnil;
+}
+
+static int format_hash(VALUE key, VALUE val, gonzui_xmlformatter_t *xf)
+{
+  xmlformatter_write(xf, " ");
+  xmlformatter_write_obj(xf, key);
+  xmlformatter_write(xf, "=\"");
+  xmlformatter_write_obj(xf, val);
+  xmlformatter_write(xf, "\"");
+  return ST_CONTINUE;
+}
+
+static void format(gonzui_xmlformatter_t *xf, VALUE xml)
+{
+  if (rb_type(xml) == T_ARRAY) {
+    /* array */
+    long i = 0;
+    long len = RARRAY_LEN(xml);
+    VALUE *a = RARRAY_PTR(xml);
+    VALUE tag;
+
+    if (len == 0)
+      rb_raise(rb_eArgError, "too short");
+
+    /* start tag */
+    tag = a[i++];
+    xmlformatter_write(xf, "<");
+    xmlformatter_write_obj(xf, tag);
+
+    /* attributes */
+    if (i < len && rb_type(a[i]) == T_HASH)
+      st_foreach(RHASH(a[i++])->tbl, format_hash, (st_data_t)xf);
+
+    /* body, end tag */
+    if (i >= len) {
+      xmlformatter_write(xf, "\n/>");
+    } else {
+      xmlformatter_write(xf, "\n>");
+      for (; i < len; i++)
+	format(xf, a[i]);
+      xmlformatter_write(xf, "</");
+      xmlformatter_write_obj(xf, tag);
+      xmlformatter_write(xf, "\n>");
+    }
+  } else {
+    /* other nobject */
+    xmlformatter_write_obj(xf, xml);
+  }
+}
+
+static VALUE xmlformatter_format(VALUE self, VALUE xml)
+{
+  gonzui_xmlformatter_t *xf;
+  Data_Get_Struct(self, gonzui_xmlformatter_t, xf);
+  if (xf == NULL)
+    return Qnil;
+  Check_Type(xml, T_ARRAY);
+  format(xf, xml);
+  return rb_str_new(xf->data, xf->size);
+}
+
+void Init_xmlformatter()
+{
+  VALUE Gonzui = rb_define_module("Gonzui");
+  VALUE XMLFormatter = rb_define_class_under(Gonzui, "XMLFormatter", rb_cData);
+  rb_define_alloc_func(XMLFormatter, xmlformatter_s_allocate);
+  rb_define_method(XMLFormatter, "initialize", xmlformatter_initialize, 0);
+  rb_define_method(XMLFormatter, "add_xml_declaration", xmlformatter_add_xml_declaration, 0);
+  rb_define_method(XMLFormatter, "add_doctype", xmlformatter_add_doctype, 0);
+  rb_define_method(XMLFormatter, "format", xmlformatter_format, 1);
+}