ruby-xml-smart 0.1.11-i486-linux

data/rbxs_dom.c

@@ -0,0 +1,483 @@
+#include "rbxs_dom.h"
+#include "rbxs_domelement.h"
+#include "rbxs_domnodeset.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+/* -- */
+// ***********************************************************************************
+// GC
+// ***********************************************************************************
+void rbxs_dom_free(rbxs_dom *prbxs_dom) {
+  if (prbxs_dom != NULL) {
+    xmlFreeDoc(prbxs_dom->doc);
+    xmlCleanupParser();
+    free(prbxs_dom);
+  }
+}
+
+void rbxs_dom_mark(rbxs_dom *prbxs_dom) {
+  if (prbxs_dom == NULL) return;
+  if (!NIL_P(prbxs_dom->changeHandlers)) rb_gc_mark(prbxs_dom->changeHandlers);
+  if (!NIL_P(prbxs_dom->namespaces)) rb_gc_mark(prbxs_dom->namespaces);
+}
+
+//***********************************************************************************
+// Methods
+//***********************************************************************************
+/* ++ */
+static int nslist_each(VALUE key, VALUE value, xmlXPathContextPtr arg) {
+  if (xmlXPathRegisterNs(arg,(unsigned char *)StringValuePtr(key),(unsigned char *)StringValuePtr(value)) != 0) {
+    xmlXPathFreeContext(arg);
+    rb_raise(rb_eRuntimeError, "Couldn't add namespace");
+  }
+  return ST_CONTINUE;
+}
+
+static int nslistset_each(VALUE key, VALUE value) {
+  Check_Type(key, T_STRING);
+  Check_Type(value, T_STRING);
+  return ST_CONTINUE;
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_inspect(VALUE self) 
+{
+  VALUE *argv;
+
+  argv = ALLOCA_N(VALUE, 3);
+  argv[0] = rb_str_new2("#<%s:0x%x>");
+  argv[1] = CLASS_OF(self);
+  argv[2] = rb_obj_id(self);
+  return(rb_f_sprintf(3, argv));
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_to_s(VALUE self)
+{
+  rbxs_dom *prbxs_dom;
+  xmlChar *result;
+  VALUE ret;
+  int len;
+
+  Data_Get_Struct(self, rbxs_dom, prbxs_dom);
+  if (prbxs_dom->doc == NULL) {
+    return(Qnil);
+  } else if (prbxs_dom->doc->encoding != NULL) {
+    xmlDocDumpFormatMemoryEnc(prbxs_dom->doc, &result, &len, (char *)prbxs_dom->doc->encoding, 1);
+  } else {
+    xmlDocDumpFormatMemory(prbxs_dom->doc, &result, &len, 1);
+  }
+
+  ret = rb_str_new2((char *)result);
+  xmlFree(result);
+  return(ret);
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_root_set(VALUE self, VALUE element)
+{
+  rbxs_dom *prbxs_dom;
+  rbxs_domelement *prbxs_domelement;
+  xmlNodePtr root,newnode;
+
+  if (rb_obj_is_kind_of(element, cSmartDomElement)) {
+    Data_Get_Struct(self, rbxs_dom, prbxs_dom);
+    Data_Get_Struct(element, rbxs_domelement, prbxs_domelement);
+    newnode = xmlCopyNode(prbxs_domelement->node,1); // 1 == deep
+    root = xmlDocGetRootElement(prbxs_dom->doc);
+    xmlUnlinkNode(root);
+    xmlFreeNode  (root);
+    root = xmlDocSetRootElement(prbxs_dom->doc,newnode);
+    if (root) {
+      VALUE ret = rbxs_domelement_new(cSmartDomElement, self, root);  
+      rbxs_dom_change_handlers_execute(prbxs_dom,RBXS_DOM_SIGNAL_CHANGE,ret);
+      return(ret);
+    }  
+  } else
+    rb_raise(rb_eArgError, "takes an element as argument");
+  return(Qnil);
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_encode_entities_set(VALUE self, VALUE value)
+{
+  rbxs_dom *prbxs_dom;
+  Data_Get_Struct(self, rbxs_dom, prbxs_dom);
+  switch (TYPE(value)) {
+    case T_FALSE:
+      prbxs_dom->encodeEntities = 0;
+      return Qfalse; 
+    case T_TRUE:
+      prbxs_dom->encodeEntities = 1;
+      return Qtrue; 
+    default:
+     rb_raise(rb_eArgError, "can be set to TRUE or FALSE");
+  }  
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_encode_entities_q(VALUE self)
+{
+  rbxs_dom *prbxs_dom;
+  Data_Get_Struct(self, rbxs_dom, prbxs_dom);
+  if (prbxs_dom->encodeEntities == 0) 
+    return(Qfalse);  
+  else
+    return(Qtrue);
+}
+  
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_root(VALUE self)
+{
+  rbxs_dom *prbxs_dom;
+  xmlNodePtr root;
+
+  Data_Get_Struct(self, rbxs_dom, prbxs_dom);
+  root = xmlDocGetRootElement(prbxs_dom->doc);
+  if (root) 
+    return(rbxs_domelement_new(cSmartDomElement, self, root));  
+  else
+    return(Qnil);
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_save_as(VALUE self, VALUE file)
+{
+  Check_Type(file, T_FILE);
+  rb_io_write(file,rbxs_dom_to_s(self));
+  return(Qtrue);
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_find(int argc, VALUE *argv, VALUE self)
+{
+  rbxs_dom           *prbxs_dom;
+  xmlXPathContextPtr  ctxt;
+  xmlXPathObjectPtr   obj;
+  xmlNodePtr          root;
+  VALUE               set;
+  
+  if (argc > 2 || argc < 1)
+    rb_raise(rb_eArgError, "wrong number of arguments (need 1 or 2)");
+  Check_Type(argv[0], T_STRING);
+
+  Data_Get_Struct(self, rbxs_dom, prbxs_dom);
+
+  ctxt = xmlXPathNewContext(prbxs_dom->doc);
+  if(ctxt == NULL)
+    rb_raise(rb_eRuntimeError, "Couldn't create XPath context");
+  root = xmlDocGetRootElement(prbxs_dom->doc);
+  ctxt->node = root->parent;
+
+  if (argc == 2) {
+    Check_Type(argv[1], T_HASH);
+    if (!RHASH_EMPTY_P(argv[1]))
+      rb_hash_foreach(argv[1], nslist_each, (st_data_t)ctxt);
+  }
+  if (!RHASH_EMPTY_P(prbxs_dom->namespaces))
+    rb_hash_foreach(prbxs_dom->namespaces, nslist_each, (st_data_t)ctxt);
+
+  obj = xmlXPathEvalExpression((unsigned char *)StringValuePtr(argv[0]), ctxt);
+  ctxt->node = NULL;
+  if(obj == NULL) {
+    xmlXPathFreeContext(ctxt);
+    rb_raise(rb_eRuntimeError, "Error in xpath");
+  }
+  switch (obj->type) {
+    case XPATH_NODESET:
+      set = rbxs_domnodeset_new(cSmartDomNodeSet,self,obj);
+      break;
+    case XPATH_BOOLEAN:
+      set = obj->boolval > 0 ? Qtrue : Qfalse; 
+      xmlXPathFreeObject(obj);
+      break;
+    case XPATH_NUMBER:
+      set = rb_float_new(obj->floatval);
+      xmlXPathFreeObject(obj);
+      break;
+    case XPATH_STRING:
+      set = rb_str_new2((char *)obj->stringval);
+      xmlXPathFreeObject(obj);
+      break;
+    default:
+      set = Qnil;
+  }  
+  xmlXPathFreeContext(ctxt);
+
+  return set;
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_change_handler_set(VALUE self)
+{
+  rbxs_dom *prbxs_dom;
+
+  Data_Get_Struct(self, rbxs_dom, prbxs_dom);
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "you need to supply a block with #on_change");
+
+  rb_ary_push(prbxs_dom->changeHandlers,rb_block_proc());
+  return(Qtrue); 
+}  
+
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_change_handlers(VALUE self)
+{
+  rbxs_dom *prbxs_dom;
+  Data_Get_Struct(self, rbxs_dom, prbxs_dom);
+  return(prbxs_dom->changeHandlers);
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_namespaces_get(VALUE self)
+{
+  rbxs_dom *prbxs_dom;
+  Data_Get_Struct(self, rbxs_dom, prbxs_dom);
+  rb_ary_push(prbxs_dom->changeHandlers,rb_block_proc());
+  return(prbxs_dom->namespaces);
+}
+/*
+ *  Documentation
+ */
+VALUE rbxs_dom_namespaces_set(VALUE self, VALUE ns)
+{
+  rbxs_dom *prbxs_dom;
+  Data_Get_Struct(self, rbxs_dom, prbxs_dom);
+  Check_Type(ns, T_HASH);
+  if (!RHASH_EMPTY_P(ns))
+    rb_hash_foreach(ns, nslistset_each, Qnil);
+  prbxs_dom->namespaces = ns;
+  return(Qnil);
+}
+    
+void rbxs_dom_change_handlers_execute(rbxs_dom *prbxs_dom, unsigned short int type, VALUE node) {
+  long i;
+  for (i = 0; i < RARRAY_LEN(prbxs_dom->changeHandlers); i++) {
+    VALUE args = rb_ary_new2(2);
+
+    VALUE e = RARRAY_PTR(prbxs_dom->changeHandlers)[i];
+    rb_ary_push(args,INT2FIX(type));
+    rb_ary_push(args,node);
+    rb_eval_cmd(e,args,1);
+  }
+}
+
+//***********************************************************************************
+// Constructors
+//***********************************************************************************
+VALUE rbxs_dom_string(VALUE string) {
+  rbxs_dom *prbxs_dom;
+  xmlParserCtxtPtr ctxt;
+
+  Check_Type(string, T_STRING);
+  
+  prbxs_dom = (rbxs_dom *)malloc(sizeof(rbxs_dom));
+  if (prbxs_dom == NULL)
+    rb_raise(rb_eNoMemError, "No memory left for XML::Smart::Dom struct");
+
+  xmlInitParser();
+
+  ctxt = xmlCreateMemoryParserCtxt(StringValuePtr(string),strlen(StringValuePtr(string)));
+  if (ctxt == NULL)
+   rb_sys_fail(StringValuePtr(string));
+
+  if (xmlParseDocument(ctxt) == -1) {
+    xmlFreeDoc(ctxt->myDoc);
+    xmlFreeParserCtxt(ctxt);
+    rb_raise(rb_eRuntimeError, "Document didn't parse");
+  }
+
+  if (!ctxt->wellFormed) {
+    xmlFreeDoc(ctxt->myDoc);
+    xmlFreeParserCtxt(ctxt);
+    ctxt = NULL;
+    rb_raise(rb_eRuntimeError, "Document is not wellformed");
+  }
+
+  prbxs_dom->type = RBXS_DOM_TYPE_STRING;
+  prbxs_dom->lock = 0;
+  prbxs_dom->changeHandlers = rb_ary_new2(0);
+  prbxs_dom->namespaces = rb_hash_new();
+  prbxs_dom->encodeEntities = 1;
+  prbxs_dom->doc  = ctxt->myDoc;
+  
+  xmlFreeParserCtxt(ctxt);
+
+  return(Data_Wrap_Struct(cSmartDom, rbxs_dom_mark, rbxs_dom_free, prbxs_dom));
+}
+
+VALUE rbxs_dom_open(VALUE name, char *root, unsigned short int lock, unsigned short int save) {
+  rbxs_dom *prbxs_dom;
+  xmlParserCtxtPtr ctxt;
+  char *lockfile;
+
+  ctxt = NULL;
+  lockfile = NULL;
+
+  if ((!rb_block_given_p()) && save>0)
+    rb_raise(rb_eArgError, "you need to supply a block with #modify");
+    
+  prbxs_dom = (rbxs_dom *)malloc(sizeof(rbxs_dom));
+  if (prbxs_dom == NULL)
+    rb_raise(rb_eNoMemError, "No memory left for XML::Smart::Dom struct");
+
+  if (root != NULL) {
+    int fd;
+    fd = open(StringValuePtr(name), O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR);
+    if (fd < 0) {
+      if (errno != EEXIST)
+        rb_raise(rb_eRuntimeError, "Failed to create new file");
+    } else {
+      char *wr;
+      wr = (char *)calloc(strlen("<?xml version='1.0'?>\n") + strlen(root) + 1,sizeof(char));
+      strncat(wr,"<?xml version='1.0'?>\n",strlen("<?xml version='1.0'?>\n"));
+      strncat(wr,root,strlen(root));
+      if (!(write(fd,wr,strlen(wr)) > 0))
+        rb_raise(rb_eRuntimeError, "Failed to write new file");
+      free(wr);
+    }  
+    close(fd);
+  }
+    
+  if (save > 0 && lock > 0) {
+    struct stat buffer;
+    lockfile = (char *)calloc(strlen(StringValuePtr(name)) + 6,sizeof(char));
+    strncat(lockfile,StringValuePtr(name),strlen(StringValuePtr(name)));
+    strncat(lockfile,".lock",5);
+    int fd;
+    do {
+      fd = open(lockfile, O_CREAT|O_EXCL, S_IRUSR|S_IWUSR);
+      if (fd < 0) {
+        if (errno != EEXIST) {
+          xmlFreeDoc(ctxt->myDoc);
+          ctxt = NULL;
+          free(lockfile);
+          rb_raise(rb_eRuntimeError, "Failed to create lockfile");
+        } else {
+          stat(lockfile, &buffer);
+          if (buffer.st_mtime < time(NULL) - lock)
+            unlink(lockfile); 
+        }  
+      } 
+      rb_thread_polling();
+    } while (fd < 0);
+    close(fd);
+  }
+
+  xmlInitParser();
+  ctxt = xmlCreateFileParserCtxt(StringValuePtr(name));
+
+  prbxs_dom->type = RBXS_DOM_TYPE_FILE;
+  prbxs_dom->encodeEntities = 1;
+  prbxs_dom->changeHandlers = rb_ary_new2(0);
+  prbxs_dom->namespaces = rb_hash_new();
+  prbxs_dom->lock = lock;
+
+  if (ctxt == NULL) {
+    if (save>0 && prbxs_dom->lock>0) {
+      unlink(lockfile);
+      free(lockfile);
+    }  
+    rb_sys_fail(StringValuePtr(name));
+  } 
+
+  if (xmlParseDocument(ctxt) == -1) {
+    if (save>0 && prbxs_dom->lock>0) {
+      unlink(lockfile);
+      free(lockfile);
+    }  
+    xmlFreeDoc(ctxt->myDoc);
+    xmlFreeParserCtxt(ctxt);
+    rb_raise(rb_eRuntimeError, "Document didn't parse");
+  }
+
+  if (!ctxt->wellFormed) {
+    if (save>0 && prbxs_dom->lock>0) {
+      unlink(lockfile);
+      free(lockfile);
+    }  
+    xmlFreeDoc(ctxt->myDoc);
+    xmlFreeParserCtxt(ctxt);
+    ctxt = NULL;
+    rb_raise(rb_eRuntimeError, "Document is not wellformed");
+  }
+
+  prbxs_dom->doc = ctxt->myDoc;
+  xmlFreeParserCtxt(ctxt);
+  xmlCleanupParser(); // Hmmm, no problem to call it as this point
+    
+  if (rb_block_given_p()) {
+    rb_yield(Data_Wrap_Struct(cSmartDom, rbxs_dom_mark, rbxs_dom_free, prbxs_dom));
+    if (save > 0) {
+      int status = -1;
+      status = xmlSaveFormatFile(StringValuePtr(name), prbxs_dom->doc, 1);
+      if (prbxs_dom->lock > 0) {
+        unlink(lockfile);
+        free(lockfile);
+      }  
+      if (status == -1)
+        rb_raise(rb_eRuntimeError, "Unable to write file back to disk");
+    }  
+    return(Qnil);
+  }
+
+  return(Data_Wrap_Struct(cSmartDom, rbxs_dom_mark, rbxs_dom_free, prbxs_dom));
+}
+
+//***********************************************************************************
+// Initialize module and class
+//***********************************************************************************
+#ifdef RDOC__
+  mXML  = rb_define_module( "XML" );
+  cSmart = rb_define_class_under( mXML, "Smart", rb_cObject );
+#endif
+VALUE cSmartDom;
+
+void init_rbxs_dom( void ) {
+  cSmartDom = rb_define_class_under( cSmart, "Dom", rb_cObject );
+  
+  rb_define_const(cSmartDom, "SIGNAL_ADD",    INT2NUM(RBXS_DOM_SIGNAL_ADD   ));
+  rb_define_const(cSmartDom, "SIGNAL_CHANGE", INT2NUM(RBXS_DOM_SIGNAL_CHANGE));
+  rb_define_const(cSmartDom, "SIGNAL_DELETE", INT2NUM(RBXS_DOM_SIGNAL_DELETE));
+  
+  rb_define_method(cSmartDom, "inspect",               rbxs_dom_inspect,                0);
+  rb_define_method(cSmartDom, "to_s",                  rbxs_dom_to_s,                   0);
+  rb_define_method(cSmartDom, "root",                  rbxs_dom_root,                   0);
+  rb_define_method(cSmartDom, "root=",                 rbxs_dom_root_set,               1);
+  rb_define_method(cSmartDom, "find",                  rbxs_dom_find,                  -1);
+  rb_define_method(cSmartDom, "on_change",             rbxs_dom_change_handler_set,     0);
+  rb_define_method(cSmartDom, "change_handlers",       rbxs_dom_change_handlers,        0);
+  rb_define_method(cSmartDom, "save_as",               rbxs_dom_save_as,                1);
+  rb_define_method(cSmartDom, "namespaces=",           rbxs_dom_namespaces_set,         1);
+  rb_define_method(cSmartDom, "namespaces",            rbxs_dom_namespaces_get,         0);
+  rb_define_method(cSmartDom, "encode_entities=",      rbxs_dom_encode_entities_set,    1);
+  rb_define_method(cSmartDom, "encode_entities?",      rbxs_dom_encode_entities_q,      0);
+}

data/rbxs_dom.h

@@ -0,0 +1,32 @@
+/* Please see the COPYING file for copyright and distribution information */
+
+#ifndef __RBXS_DOM_H__
+#define __RBXS_DOM_H__
+
+#include "rbxs.h"
+
+#define RBXS_DOM_TYPE_STRING 0
+#define RBXS_DOM_TYPE_FILE   1
+
+#define RBXS_DOM_SIGNAL_ADD    0
+#define RBXS_DOM_SIGNAL_CHANGE 1
+#define RBXS_DOM_SIGNAL_DELETE 2
+
+RUBY_EXTERN VALUE cSmartDom;
+
+typedef struct rbxs_dom {
+  unsigned short int encodeEntities;
+  int                type;
+  unsigned short int lock;
+  xmlDocPtr          doc;
+  VALUE              changeHandlers;
+  VALUE              namespaces;
+} rbxs_dom;
+
+void rbxs_dom_change_handlers_execute(rbxs_dom *prbxs_dom, unsigned short int type, VALUE node);
+
+RUBY_EXTERN VALUE rbxs_dom_open(VALUE name, char *root, unsigned short int lock, unsigned short int save);
+RUBY_EXTERN VALUE rbxs_dom_string(VALUE string);
+RUBY_EXTERN void  init_rbxs_dom(void);
+
+#endif

data/rbxs_domattribute.c

@@ -0,0 +1,189 @@
+#include "rbxs_domattribute.h"
+#include "rbxs_domelement.h"
+#include "rbxs_dom.h"
+
+/* -- */
+//***********************************************************************************
+// GC
+//***********************************************************************************
+void rbxs_domattribute_free(rbxs_domattribute *prbxs_domattribute) {
+  if (prbxs_domattribute != NULL) {
+    free(prbxs_domattribute);
+  }  
+}
+  
+void rbxs_domattribute_mark(rbxs_domattribute *prbxs_domattribute) { 
+  if (prbxs_domattribute == NULL) return;
+  if (!NIL_P(prbxs_domattribute->doc)) rb_gc_mark(prbxs_domattribute->doc);
+}
+
+//***********************************************************************************
+// Methods
+//***********************************************************************************
+/* ++ */
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_domattribute_inspect(VALUE self)
+{
+  rbxs_domattribute *prbxs_domattribute;
+  xmlBufferPtr ret;
+  VALUE *argv;
+
+  argv = ALLOCA_N(VALUE, 4);
+  argv[0] = rb_str_new2("#<%s:0x%x @%s>");
+  argv[1] = CLASS_OF(self);
+  argv[2] = rb_obj_id(self);
+  
+  Data_Get_Struct(self, rbxs_domattribute, prbxs_domattribute);
+  ret = xmlBufferCreate();
+  xmlNodeDump(ret, prbxs_domattribute->attribute->doc, (xmlNodePtr)prbxs_domattribute->attribute, 0, 1);
+  argv[3] = rb_str_new2((char *)ret->content);
+  argv[3] = rb_str_substr(argv[3],1,RSTRING_LEN(argv[3]));
+
+  xmlBufferFree(ret);
+  return(rb_f_sprintf(4, argv));
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_domattribute_value_get(VALUE self)
+{
+  rbxs_domattribute *prbxs_domattribute;
+  xmlChar *ret;
+  VALUE val;
+
+  Data_Get_Struct(self, rbxs_domattribute, prbxs_domattribute);
+  ret = xmlGetProp(prbxs_domattribute->attribute->parent,prbxs_domattribute->attribute->name);
+  val = rb_str_new2((char *)ret);
+  xmlFree(ret);
+  return(val);
+}
+  
+/*
+ *  Documentation
+ */
+VALUE rbxs_domattribute_path(VALUE self)
+{
+  rbxs_domattribute *prbxs_domattribute;
+  xmlChar *ret;
+  VALUE val;
+
+  Data_Get_Struct(self, rbxs_domattribute, prbxs_domattribute);
+  ret = xmlGetNodePath((xmlNodePtr)prbxs_domattribute->attribute);
+  val = rb_str_new2((char *)ret);
+  xmlFree(ret);
+  return(val);
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_domattribute_to_i(int argc, VALUE *argv, VALUE self)
+{
+    VALUE b;
+    int base;
+
+    rb_scan_args(argc, argv, "01", &b);
+    if (argc == 0) base = 10;
+    else base = NUM2INT(b);
+
+    if (base < 0)
+	    rb_raise(rb_eArgError, "illegal radix %d", base);
+    return(rb_str_to_inum(rbxs_domattribute_value_get(self),base,Qfalse));
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_domattribute_to_f(VALUE self)
+{
+  return rb_float_new(rb_str_to_dbl(rbxs_domattribute_value_get(self), Qfalse));
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_domattribute_name_get(VALUE self)
+{
+  rbxs_domattribute *prbxs_domattribute;
+  Data_Get_Struct(self, rbxs_domattribute, prbxs_domattribute);
+  return(rb_str_new2((char *)prbxs_domattribute->attribute->name));
+}  
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_domattribute_value_set(VALUE self, VALUE value)
+{
+  rbxs_domattribute *prbxs_domattribute;
+  rbxs_dom *prbxs_dom;
+  unsigned char *tc;
+  VALUE str;
+
+  Data_Get_Struct(self, rbxs_domattribute, prbxs_domattribute);
+  Data_Get_Struct(prbxs_domattribute->doc, rbxs_dom, prbxs_dom);
+
+  str = rb_obj_as_string(value);
+  if (NIL_P(str) || TYPE(str) != T_STRING)
+    rb_raise(rb_eTypeError, "cannot convert obj to string");
+  tc = (unsigned char *)StringValuePtr(str);
+  if (!xmlCheckUTF8(tc))
+    rb_raise(rb_eArgError, "text must be utf8 encoded");
+  xmlNodeSetContent((xmlNodePtr)prbxs_domattribute->attribute,tc);
+  
+  rbxs_dom_change_handlers_execute(prbxs_dom,RBXS_DOM_SIGNAL_CHANGE,self);
+  return(value);
+}
+
+/*
+ *  Documentation
+ */
+VALUE rbxs_domattribute_element(VALUE self) 
+{
+  rbxs_domattribute *prbxs_domattribute;
+  Data_Get_Struct(self, rbxs_domattribute, prbxs_domattribute);
+  return(rbxs_domelement_new(cSmartDomElement,prbxs_domattribute->doc,prbxs_domattribute->attribute->parent));
+}
+
+//***********************************************************************************
+// Constructors
+//***********************************************************************************
+VALUE rbxs_domattribute_new(VALUE class, VALUE doc, xmlAttrPtr attribute) {
+  rbxs_domattribute *prbxs_domattribute;
+
+  prbxs_domattribute = (rbxs_domattribute *)malloc(sizeof(rbxs_domattribute));
+  if (prbxs_domattribute == NULL )
+    rb_raise(rb_eNoMemError, "No memory left for XML::Smart::Dom::Attribute struct");
+
+  prbxs_domattribute->doc       = doc;
+  prbxs_domattribute->attribute = attribute;
+
+  return(Data_Wrap_Struct(class, rbxs_domattribute_mark, rbxs_domattribute_free, prbxs_domattribute));
+}
+
+//***********************************************************************************
+// Initialize class Node
+//***********************************************************************************
+#ifdef RDOC__
+  mXML  = rb_define_module( "XML" );
+  cSmart = rb_define_class_under( mXML, "Smart", rb_cObject );
+  cSmartDom = rb_define_class_under( cSmart, "Dom", rb_cObject );
+#endif
+VALUE cSmartDomAttribute;
+ 
+void init_rbxs_domattribute(void) {
+  cSmartDomAttribute = rb_define_class_under( cSmartDom, "Attribute", rb_cObject );
+
+  rb_define_method(cSmartDomAttribute, "inspect", rbxs_domattribute_inspect,    0);
+  rb_define_method(cSmartDomAttribute, "to_s",    rbxs_domattribute_value_get,  0);
+  rb_define_method(cSmartDomAttribute, "to_i",    rbxs_domattribute_to_i,      -1);
+  rb_define_method(cSmartDomAttribute, "to_f",    rbxs_domattribute_to_f,       0);
+  rb_define_method(cSmartDomAttribute, "name",    rbxs_domattribute_name_get,   0);
+  rb_define_method(cSmartDomAttribute, "path",    rbxs_domattribute_path,       0);
+  rb_define_method(cSmartDomAttribute, "value",   rbxs_domattribute_value_get,  0);
+  rb_define_method(cSmartDomAttribute, "value=",  rbxs_domattribute_value_set,  1);
+  rb_define_method(cSmartDomAttribute, "element", rbxs_domattribute_element,    0);
+}