libxml-ruby 0.6.0 → 0.7.0

data/ext/libxml/libxml.c

@@ -1,62 +1,58 @@
-/* $Id: libxml.c 300 2008-07-01 19:14:15Z cfis $ */
-
-/* Please see the LICENSE file for copyright and distribution information */
-
-#include "ruby_libxml.h"
-
-VALUE mXML;
-VALUE eXMLError;
-
-static xmlFreeFunc freeFunc = NULL;
-static xmlMallocFunc mallocFunc = NULL;
-static xmlReallocFunc reallocFunc = NULL;
-static xmlStrdupFunc strdupFunc = NULL;
-
-#if defined(_WIN32)
-__declspec(dllexport) 
-#endif
-
-void
-Init_libxml_ruby(void) {
-  /* Some libxml memory goo that should be done before anything else */
-#ifdef NONE
-  xmlMemGet((xmlFreeFunc *) & freeFunc,
-            (xmlMallocFunc *) & mallocFunc,
-            (xmlReallocFunc *) & reallocFunc,
-            (xmlStrdupFunc *) & strdupFunc);
-
-  if (xmlMemSetup((xmlFreeFunc)RubyMemFree, (xmlMallocFunc)RubyMemMalloc,
-                  (xmlReallocFunc)RubyMemRealloc, (xmlStrdupFunc)RubyMemStrdup) != 0)
-    rb_fatal("could not install the memory handlers for libxml");
-#endif
-  xmlInitParser();
-
-  mXML = rb_define_module("XML");
-  eXMLError = rb_define_class_under(mXML, "Error", rb_eRuntimeError);
-
-  rb_define_const(mXML, "XML_NAMESPACE", rb_str_new2((const char*)XML_XML_NAMESPACE));
-
-  ruby_init_state();
-  ruby_init_parser();  
-  ruby_init_xml_parser_context();
-  ruby_init_xml_attr();
-  ruby_init_xml_document();
-  ruby_init_xml_node();
-  ruby_init_xml_node_set();
-  ruby_init_xml_ns();
-  ruby_init_xml_sax_parser();
-  ruby_init_xml_tree();
-  ruby_init_xml_xinclude();
-  ruby_init_xml_xpath();
-  ruby_init_xml_xpath_context();
-  ruby_init_xml_xpointer();
-  ruby_init_xml_xpointer_context();
-  ruby_init_html_parser();
-  ruby_init_input_callbacks(); 
-  ruby_init_xml_dtd();         
-  ruby_init_xml_schema();      
-  ruby_init_xml_reader();      
-
-  ruby_xml_parser_default_substitute_entities_set(cXMLParser, Qtrue);
-  ruby_xml_parser_default_load_external_dtd_set(cXMLParser, Qtrue);
-}
+/* $Id: libxml.c 323 2008-07-08 22:59:23Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+
+VALUE mXML;
+VALUE eXMLError;
+
+
+#if defined(_WIN32)
+__declspec(dllexport) 
+#endif
+
+void
+Init_libxml_ruby(void) {
+  /* Some libxml memory goo that should be done before anything else */
+#ifdef NONE
+  xmlMemGet((xmlFreeFunc *) & freeFunc,
+            (xmlMallocFunc *) & mallocFunc,
+            (xmlReallocFunc *) & reallocFunc,
+            (xmlStrdupFunc *) & strdupFunc);
+
+  if (xmlMemSetup((xmlFreeFunc)RubyMemFree, (xmlMallocFunc)RubyMemMalloc,
+                  (xmlReallocFunc)RubyMemRealloc, (xmlStrdupFunc)RubyMemStrdup) != 0)
+    rb_fatal("could not install the memory handlers for libxml");
+#endif
+
+  mXML = rb_define_module("XML");
+  eXMLError = rb_define_class_under(mXML, "Error", rb_eRuntimeError);
+
+  rb_define_const(mXML, "XML_NAMESPACE", rb_str_new2((const char*)XML_XML_NAMESPACE));
+
+  ruby_init_state();
+  ruby_init_parser();  
+  ruby_init_xml_parser_context();
+  ruby_init_xml_attributes();
+  ruby_init_xml_attr();
+  ruby_init_xml_document();
+  ruby_init_xml_node();
+  ruby_init_xml_node_set();
+  ruby_init_xml_ns();
+  ruby_init_xml_sax_parser();
+  ruby_init_xml_tree();
+  ruby_init_xml_xinclude();
+  ruby_init_xml_xpath();
+  ruby_init_xml_xpath_context();
+  ruby_init_xml_xpointer();
+  ruby_init_xml_xpointer_context();
+  ruby_init_html_parser();
+  ruby_init_input_callbacks(); 
+  ruby_init_xml_dtd();         
+  ruby_init_xml_schema();      
+  ruby_init_xml_reader();      
+
+  ruby_xml_parser_default_substitute_entities_set(cXMLParser, Qtrue);
+  ruby_xml_parser_default_load_external_dtd_set(cXMLParser, Qtrue);
+}

data/ext/libxml/ruby_libxml.h

@@ -63,6 +63,7 @@ typedef struct rx_xpath_data {
 } rx_xpath_data;
 
 #include "ruby_xml_state.h"
+#include "ruby_xml_attributes.h"
 #include "ruby_xml_attr.h"
 #include "ruby_xml_document.h"
 #include "ruby_xml_node.h"

data/ext/libxml/ruby_xml_attr.c

@@ -1,103 +1,159 @@
-/* $Id: ruby_xml_attr.c 300 2008-07-01 19:14:15Z cfis $ */
+/* $Id: ruby_xml_attr.c 351 2008-07-09 19:55:21Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
+/*
+* Document-class: XML::Attr
+*
+* Provides access to an single element attribute.  Accessed by
+* calling XML::Node#attributes method.
+*
+* Basic Usage:
+*  require 'libxml'
+*
+*  doc = XML::Document.new(<some_file>)
+*  attribute = doc.root.attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
+*  attribute.name == 'href'
+*  attribute.value == 'http://www.mydocument.com'
+*  attribute.remove!
+*/
+
 #include "ruby_libxml.h"
 #include "ruby_xml_attr.h"
 
 VALUE cXMLAttr;
 
-void ruby_xml_attr_free(ruby_xml_attr_t *rx) {
-  if (rx == NULL ) return;
+void ruby_xml_attr_free(xmlAttrPtr xattr) {
+  if (!xattr) return;
 
-  if (rx->attr != NULL ) {
-    rx->attr->_private=NULL;
-    if (rx->attr->parent == NULL && rx->attr->doc == NULL ) {
+  if (xattr != NULL ) {
+    xattr->_private=NULL;
+    if (xattr->parent == NULL && xattr->doc == NULL ) {
 #ifdef NODE_DEBUG
       fprintf(stderr,"ruby_xfree rxn=0x%x xn=0x%x o=0x%x\n",(long)rxn,(long)rxn->node,(long)rxn->node->_private);
 #endif
-      xmlFreeProp(rx->attr);
+      xmlFreeProp(xattr);
     }
 
-    rx->attr=NULL;
+    xattr=NULL;
   }
-
-  ruby_xfree(rx);
 }
 
 void
-ruby_xml_attr_mark(ruby_xml_attr_t *rx) {
-  if ( rx == NULL ) return;
-  if ( rx->attr == NULL ) return;
+ruby_xml_attr_mark(xmlAttrPtr xattr) {
+  if (xattr == NULL) return;
 
-  if (rx->attr->_private == NULL ) {
+  if (xattr->_private == NULL ) {
     rb_warning("XmlAttr is not bound! (%s:%d)",
 	       __FILE__,__LINE__);
     return;
   }
 
-  ruby_xml_node_mark_common((xmlNodePtr)rx->attr);
+  ruby_xml_node_mark_common((xmlNodePtr)xattr);
 }
 
 VALUE
-ruby_xml_attr_wrap(VALUE class, xmlAttrPtr xnode)
+ruby_xml_attr_wrap(xmlAttrPtr xattr)
 {
-  VALUE obj;
-  ruby_xml_attr_t *rx;
-
+  VALUE result;
   // This node is already wrapped
-  if (xnode->_private != NULL)
-    return (VALUE)xnode->_private;
+  if (xattr->_private != NULL)
+    return (VALUE)xattr->_private;
 
-  obj=Data_Make_Struct(class,ruby_xml_attr_t,ruby_xml_attr_mark,
-		       ruby_xml_attr_free,rx);
+  result = Data_Wrap_Struct(cXMLAttr,
+                            ruby_xml_attr_mark, ruby_xml_attr_free,
+                            xattr);
 
-  rx->attr=xnode;
-  xnode->_private=(void*)obj;
+  xattr->_private=(void*)result;
 #ifdef NODE_DEBUG
   fprintf(stderr,"wrap rxn=0x%x xn=0x%x o=0x%x\n",(long)rxn,(long)xnode,(long)obj);
 #endif
-  return obj;
+  return result;
+}
+
+
+VALUE
+ruby_xml_attr_alloc(VALUE klass)
+{
+  return Data_Wrap_Struct(cXMLAttr,
+                          ruby_xml_attr_mark, ruby_xml_attr_free,
+                          NULL);
 }
 
 /*
- * Only use this when a xmlAttr has just been created since
- * oblitterates the _private. Not exposed to ruby interp.
+ * call-seq:
+ *    attr.initialize(node, "name", "value")
+ * 
+ * Creates a new attribute for the node.
+ *
+ * node: The XML::Node that will contain the attribute
+ * name: The name of the attribute
+ * value: The value of the attribute
+ *
+ *  attr = XML::Attr.new(doc.root, 'name', 'libxml')
  */
 VALUE
-ruby_xml_attr_new(VALUE class, xmlAttrPtr xnode)
-{
-  xnode->_private=NULL;
-  return ruby_xml_attr_wrap(class,xnode);
+ruby_xml_attr_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE node = argv[0];
+  VALUE name = argv[1];
+  VALUE value = argv[2];
+  VALUE ns = (argc == 4 ? argv[3] : Qnil);
+
+  xmlNodePtr xnode;
+  xmlAttrPtr xattr;
+  
+  if ( argc < 3 || argc > 4 )
+    rb_raise(rb_eArgError, "wrong number of arguments (3 or 4)");
+
+  Check_Type(name, T_STRING);
+  Check_Type(value, T_STRING);
+  
+  Data_Get_Struct(node, xmlNode, xnode);
+  
+  if NIL_P(ns)
+  {
+    xattr = xmlNewProp(xnode, (xmlChar*)StringValuePtr(name), (xmlChar*)StringValuePtr(value));
+  }
+  else
+  {
+    xmlNsPtr xns;
+    Data_Get_Struct(ns, xmlNs, xns);
+    xattr = xmlNewNsProp(xnode, xns, (xmlChar*)StringValuePtr(name), (xmlChar*)StringValuePtr(value));
+  }
+  
+  xattr->_private = (void *)self;
+  DATA_PTR(self) = xattr;
+  return self;
 }
+
 /*
  * call-seq:
- *    attr.child => node
+ *    attr.child -> node
  * 
  * Obtain this attribute's child attribute(s).
  */
 VALUE
 ruby_xml_attr_child_get(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->children == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->children == NULL)
     return(Qnil);
   else
-    return(ruby_xml_node2_wrap(cXMLNode, rxa->attr->children));
+    return(ruby_xml_node2_wrap(cXMLNode, (xmlNodePtr)xattr->children));
 }
 
 
 /*
  * call-seq:
- *    attr.child? => (true|false)
+ *    attr.child? -> (true|false)
  * 
  * Determine whether this attribute has child attributes.
  */
 VALUE
 ruby_xml_attr_child_q(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->children == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->children == NULL)
     return(Qfalse);
   else
     return(Qtrue);
@@ -106,33 +162,34 @@ ruby_xml_attr_child_q(VALUE self) {
 
 /*
  * call-seq:
- *    attr.doc => document
+ *    attr.doc -> XML::Document
  * 
- * Obtain the XML::Document this attribute is associated with,
- * if any.
+ * Returns this attribute's document.
+ *
+ *  doc.root.attributes.get_attribute('name').doc == doc
  */
 VALUE
 ruby_xml_attr_doc_get(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->doc == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->doc == NULL)
     return(Qnil);
   else
-    return(ruby_xml_document_wrap(rxa->attr->doc));
+    return(ruby_xml_document_wrap(xattr->doc));
 }
 
 /*
  * call-seq:
- *    attr.doc? => (true|false)
+ *    attr.doc? -> (true|false)
  * 
  * Determine whether this attribute is associated with an
  * XML::Document.
  */
 VALUE
 ruby_xml_attr_doc_q(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->doc == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->doc == NULL)
     return(Qfalse);
   else
     return(Qtrue);
@@ -141,32 +198,32 @@ ruby_xml_attr_doc_q(VALUE self) {
 
 /*
  * call-seq:
- *    attr.last => node
+ *    attr.last -> node
  * 
  * Obtain the last attribute.
  */
 VALUE
 ruby_xml_attr_last_get(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->last == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->last == NULL)
     return(Qnil);
   else
-    return(ruby_xml_node2_wrap(cXMLNode, rxa->attr->last));
+    return(ruby_xml_node2_wrap(cXMLNode, xattr->last));
 }
 
 
 /*
  * call-seq:
- *    attr.last? => (true|false)
+ *    attr.last? -> (true|false)
  * 
  * Determine whether this is the last attribute.
  */
 VALUE
 ruby_xml_attr_last_q(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->last == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->last == NULL)
     return(Qfalse);
   else
     return(Qtrue);
@@ -174,49 +231,49 @@ ruby_xml_attr_last_q(VALUE self) {
 
 /*
  * call-seq:
- *    attr.name => "name"
+ *    attr.name -> "name"
  * 
  * Obtain this attribute's name.
  */
 VALUE
 ruby_xml_attr_name_get(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
 
-  if (rxa->attr->name == NULL)
+  if (xattr->name == NULL)
     return(Qnil);
   else
-    return(rb_str_new2((const char*)rxa->attr->name));
+    return(rb_str_new2((const char*)xattr->name));
 }
 
 /*
  * call-seq:
- *    attr.next => node
+ *    attr.next -> node
  * 
  * Obtain the next attribute.
  */
 VALUE
 ruby_xml_attr_next_get(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->next == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->next == NULL)
     return(Qnil);
   else
-    return(ruby_xml_attr_wrap(cXMLAttr, rxa->attr->next));
+    return(ruby_xml_attr_wrap(xattr->next));
 }
 
 
 /*
  * call-seq:
- *    attr.next? => (true|false)
+ *    attr.next? -> (true|false)
  * 
  * Determine whether there is a next attribute.
  */
 VALUE
 ruby_xml_attr_next_q(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->next == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->next == NULL)
     return(Qfalse);
   else
     return(Qtrue);
@@ -225,7 +282,7 @@ ruby_xml_attr_next_q(VALUE self) {
 
 /*
  * call-seq:
- *    attr.type_name => "attribute"
+ *    attr.type_name -> "attribute"
  * 
  * Obtain this attribute node's type name.
  */
@@ -237,33 +294,33 @@ ruby_xml_attr_node_type_name(VALUE self) {
 
 /*
  * call-seq:
- *    attr.ns => namespace
+ *    attr.ns -> namespace
  * 
  * Obtain this attribute's associated XML::NS, if any.
  */
 VALUE
 ruby_xml_attr_ns_get(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->ns == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->ns == NULL)
     return(Qnil);
   else
-    return(ruby_xml_ns_new2(cXMLNS, Qnil, rxa->attr->ns));
+    return(ruby_xml_ns_wrap(xattr->ns));
 }
 
 
 /*
  * call-seq:
- *    attr.ns? => (true|false)
+ *    attr.ns? -> (true|false)
  * 
  * Determine whether this attribute has an associated 
  * namespace.
  */
 VALUE
 ruby_xml_attr_ns_q(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->ns == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->ns == NULL)
     return(Qfalse);
   else
     return(Qtrue);
@@ -272,32 +329,32 @@ ruby_xml_attr_ns_q(VALUE self) {
 
 /*
  * call-seq:
- *    attr.parent => node
+ *    attr.parent -> node
  * 
  * Obtain this attribute node's parent.
  */
 VALUE
 ruby_xml_attr_parent_get(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->parent == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->parent == NULL)
     return(Qnil);
   else
-    return(ruby_xml_node2_wrap(cXMLNode, rxa->attr->parent));
+    return(ruby_xml_node2_wrap(cXMLNode, xattr->parent));
 }
 
 
 /*
  * call-seq:
- *    attr.parent? => (true|false)
+ *    attr.parent? -> (true|false)
  * 
  * Determine whether this attribute has a parent.
  */
 VALUE
 ruby_xml_attr_parent_q(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->parent == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->parent == NULL)
     return(Qfalse);
   else
     return(Qtrue);
@@ -306,32 +363,32 @@ ruby_xml_attr_parent_q(VALUE self) {
 
 /*
  * call-seq:
- *    attr.prev => node
+ *    attr.prev -> node
  * 
  * Obtain the previous attribute.
  */
 VALUE
 ruby_xml_attr_prev_get(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->prev == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->prev == NULL)
     return(Qnil);
   else
-    return(ruby_xml_attr_wrap(cXMLAttr, rxa->attr->prev));
+    return(ruby_xml_attr_wrap(xattr->prev));
 }
 
 
 /*
  * call-seq:
- *    attr.prev? => (true|false)
+ *    attr.prev? -> (true|false)
  * 
  * Determine whether there is a previous attribute.
  */
 VALUE
 ruby_xml_attr_prev_q(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  if (rxa->attr->prev == NULL)
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  if (xattr->prev == NULL)
     return(Qfalse);
   else
     return(Qtrue);
@@ -340,33 +397,38 @@ ruby_xml_attr_prev_q(VALUE self) {
 
 /*
  * call-seq:
- *     node.remove! => nil
+ *     node.remove! -> nil
  * 
  * Removes this attribute from it's parent.
  */
 VALUE
 ruby_xml_attr_remove_ex(VALUE self) {
-  ruby_xml_attr_t *rxa;
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
-  xmlUnlinkNode(rxa->attr);
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlAttr, xattr);
+  
+  if (xattr->_private == NULL)
+    xmlRemoveProp(xattr);
+  else
+    xmlUnlinkNode((xmlNodePtr)xattr);
+
   return(Qnil);
 }
 
 /*
  * call-seq:
- *    attr.value => "value"
+ *    attr.value -> "value"
  * 
  * Obtain the value of this attribute.
  */
 VALUE
-ruby_xml_attr_value(VALUE self) {
-  ruby_xml_attr_t *rxa;
+ruby_xml_attr_value_get(VALUE self) {
+  xmlAttrPtr xattr;
   xmlChar *value;
   VALUE result = Qnil;
   
-  Data_Get_Struct(self, ruby_xml_attr_t, rxa);
+  Data_Get_Struct(self, xmlAttr, xattr);
   if (ruby_xml_attr_parent_q(self) == Qtrue) {
-    value = xmlGetProp(rxa->attr->parent, rxa->attr->name);
+    value = xmlGetProp(xattr->parent, xattr->name);
     if (value != NULL)
     {
       result = rb_str_new2((const char*)value);
@@ -376,6 +438,29 @@ ruby_xml_attr_value(VALUE self) {
   return(result);
 }
 
+
+/*
+ * call-seq:
+ *    attr.value = "value"
+ * 
+ * Sets the value of this attribute.
+ */
+VALUE
+ruby_xml_attr_value_set(VALUE self, VALUE val) {
+  xmlAttrPtr xattr;
+  
+  Check_Type(val, T_STRING);
+  Data_Get_Struct(self, xmlAttr, xattr);
+
+  if (xattr->ns)
+    xmlSetNsProp(xattr->parent, xattr->ns, xattr->name, (xmlChar*)StringValuePtr(val));
+  else
+    xmlSetProp(xattr->parent, xattr->name, (xmlChar*)StringValuePtr(val));
+    
+  return(self);
+}
+
+
 // Rdoc needs to know 
 #ifdef RDOC_NEVER_DEFINED
   mXML = rb_define_module("XML");
@@ -384,6 +469,8 @@ ruby_xml_attr_value(VALUE self) {
 void
 ruby_init_xml_attr(void) {
   cXMLAttr = rb_define_class_under(mXML, "Attr", rb_cObject);
+  rb_define_alloc_func(cXMLAttr, ruby_xml_attr_alloc);
+  rb_define_method(cXMLAttr, "initialize", ruby_xml_attr_initialize, -1);
   rb_define_method(cXMLAttr, "child", ruby_xml_attr_child_get, 0);
   rb_define_method(cXMLAttr, "child?", ruby_xml_attr_child_q, 0);
   rb_define_method(cXMLAttr, "doc", ruby_xml_attr_doc_get, 0);
@@ -401,5 +488,6 @@ ruby_init_xml_attr(void) {
   rb_define_method(cXMLAttr, "prev", ruby_xml_attr_prev_get, 0);
   rb_define_method(cXMLAttr, "prev?", ruby_xml_attr_prev_q, 0);
   rb_define_method(cXMLAttr, "remove!", ruby_xml_attr_remove_ex, 0);
-  rb_define_method(cXMLAttr, "value", ruby_xml_attr_value, 0);
+  rb_define_method(cXMLAttr, "value", ruby_xml_attr_value_get, 0);
+  rb_define_method(cXMLAttr, "value=", ruby_xml_attr_value_set, 1);
 }