vcdom 0.2.0

data/lib/vcdom/minidom/document.rb

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+# ソースコードのエンコーディング指定
+
+require "vcdom/minidom/node"
+require "vcdom/minidom/text"
+require "vcdom/minidom/element"
+require "vcdom/minidom/element_ns"
+require "vcdom/minidom/attr"
+require "vcdom/minidom/attr_ns"
+require "vcdom/minidom/comment"
+require "vcdom/minidom/cdata_section"
+require "vcdom/minidom/mod_parent_node"
+require "vcdom/minidom/mod_elements_getter"
+
+module VCDOM
+  module MiniDOM
+    class Document < Node
+      
+      include ModParentNode
+      include ModElementsGetter
+      #include Const
+      
+      def node_type; return Node::DOCUMENT_NODE end
+      def node_name; return "#document" end
+      def text_content; return nil end
+      def text_content=( value );  end
+      def implementation; return DOMImplementation.get_instance() end
+      
+      # documentElement of type Element, readonly
+      #   This is a convenience attribute that allows direct access to the child node 
+      #   that is the document element of the document.
+      def document_element; return @document_element end
+      
+      def append_child( new_child )
+        super( new_child )
+        case new_child.node_type
+          when Node::ELEMENT_NODE then
+            @document_element = new_child
+          when Node::DOCUMENT_TYPE_NODE then
+            @doctype = new_child
+        end
+      end
+      def remove_child( old_child )
+        super( old_child )
+        case old_child.node_type
+          when Node::ELEMENT_NODE then
+            @document_element = nil
+          when Node::DOCUMENT_TYPE_NODE then
+            @doctype = nil
+        end
+      end
+      
+      def create_element( tagname )
+        return Element.new( self, tagname )
+      end
+      
+      # createElementNS introduced in DOM Level 2
+      #   Creates an element of the given qualified name and namespace URI.
+      #   Per [XML Namespaces], applications must use the value null as the namespaceURI parameter for methods if they wish to have no namespace.
+      # 
+      #   Parameters
+      #     namespaceURI of type DOMString :  The namespace URI of the element to create.
+      #     qualifiedName of type DOMString : The qualified name of the element type to instantiate.
+      #   Return Value
+      #     Element :
+      #       A new Element object with the following attributes:
+      #         Attribute         Value
+      #         ----------------------------------------
+      #         Node.nodeName     qualifiedName
+      #         Node.namespaceURI namespaceURI
+      #         Node.prefix       prefix, extracted from qualifiedName, or null if there is no prefix
+      #         Node.localName    local name, extracted from qualifiedName
+      #         Element.tagName   qualifiedName
+      #   Exceptions
+      #     DOMException
+      #       INVALID_CHARACTER_ERR: Raised if the specified qualifiedName is not an 
+      #                 XML name according to the XML version in use specified in 
+      #                 the Document.xmlVersion attribute.
+      #       NAMESPACE_ERR: Raised if the qualifiedName is a malformed qualified name, 
+      #                 if the qualifiedName has a prefix and the namespaceURI is null, 
+      #                 or if the qualifiedName has a prefix that is "xml" and the 
+      #                 namespaceURI is different from 
+      #                 "http://www.w3.org/XML/1998/namespace" [XML Namespaces], or 
+      #                 if the qualifiedName or its prefix is "xmlns" and the 
+      #                 namespaceURI is different from "http://www.w3.org/2000/xmlns/", 
+      #                 or if the namespaceURI is "http://www.w3.org/2000/xmlns/" and 
+      #                 neither the qualifiedName nor its prefix is "xmlns".
+      #       NOT_SUPPORTED_ERR: Always thrown if the current document does not support 
+      #                 the "XML" feature, since namespaces were defined by XML.
+      def create_element_ns( namespace_uri, qualified_name )
+        return ElementNS.new( self, namespace_uri, qualified_name )
+      end
+      
+      # createAttribute
+      #   Creates an Attr of the given name. Note that the Attr instance can then be set on an Element 
+      #   using the setAttributeNode method.
+      #   To create an attribute with a qualified name and namespace URI, use the createAttributeNS method.
+      #   
+      #   Parameters
+      #     name of type DOMString
+      #       The name of the attribute.
+      #   Return Value
+      #     Attr
+      #       A new Attr object with the nodeName attribute set to name, and localName, prefix, 
+      #       and namespaceURI set to null. The value of the attribute is the empty string.
+      #   Exceptions
+      #     DOMException
+      #       INVALID_CHARACTER_ERR: Raised if the specified name is not an XML name 
+      #                 according to the XML version in use specified in the Document.xmlVersion attribute.
+      def create_attribute( name )
+        return Attr.new( self, name )
+      end
+      
+      # createAttributeNS introduced in DOM Level 2
+      #   
+      #   Creates an attribute of the given qualified name and namespace URI.
+      #   Per [XML Namespaces], applications must use the value null as the namespaceURI parameter 
+      #   for methods if they wish to have no namespace.
+      #   
+      #   Parameters
+      #     namespaceURI of type DOMString
+      #       The namespace URI of the attribute to create.
+      #     qualifiedName of type DOMString
+      #       The qualified name of the attribute to instantiate.
+      #   Return Value
+      #     Attr
+      #       A new Attr object with the following attributes:
+      #         Attribute         Value
+      #         ---------------------------------------------------------------
+      #         Node.nodeName     qualifiedName
+      #         Node.namespaceURI namespaceURI
+      #         Node.prefix       prefix, extracted from qualifiedName, or null if there is no prefix
+      #         Node.localName    local name, extracted from qualifiedName
+      #         Attr.name         qualifiedName
+      #         Node.nodeValue    the empty string
+      #   Exceptions
+      #     DOMException
+      #       INVALID_CHARACTER_ERR: Raised if the specified qualifiedName is not an XML name according 
+      #                 to the XML version in use specified in the Document.xmlVersion attribute.
+      #       NAMESPACE_ERR: Raised if the qualifiedName is a malformed qualified name, 
+      #                 if the qualifiedName has a prefix and the namespaceURI is null, 
+      #                 if the qualifiedName has a prefix that is "xml" and the namespaceURI is different 
+      #                 from "http://www.w3.org/XML/1998/namespace", if the qualifiedName or its prefix is 
+      #                 "xmlns" and the namespaceURI is different from "http://www.w3.org/2000/xmlns/", 
+      #                 or if the namespaceURI is "http://www.w3.org/2000/xmlns/" and 
+      #                 neither the qualifiedName nor its prefix is "xmlns".
+      #         #=> QName が奇形の場合, QName が接頭辞を持ちながら名前空間 URI が null の場合, QName の接頭辞が
+      #         #=> "xml" なのに名前空間 URI が "http://www.w3.org/XML/1998/namespace" ではない場合,
+      #         #=> QName の接頭辞が "xmlns" にもかかわらず名前空間 URI が "http://www.w3.org/2000/xmlns/"
+      #         #=> ではないとき, そして名前空間 URI が "http://www.w3.org/2000/xmlns/" なのに, QName または接頭辞が
+      #         #=> "xmlns" ではないとき例外発生.
+      #       NOT_SUPPORTED_ERR: Always thrown if the current document does not support the "XML" feature, 
+      #                 since namespaces were defined by XML.
+      def create_attribute_ns( namespace_uri, qualified_name )
+        return AttrNS.new( self, namespace_uri, qualified_name )
+      end
+      
+      # createTextNode
+      #   Creates a Text node given the specified string.
+      #
+      #   Parameters
+      #     data of type DOMString
+      #       The data for the node.
+      #   Return Value
+      #     Text
+      #       The new Text object.
+      #   No Exceptions
+      def create_text_node( data )
+        return Text.new( self, data )
+      end
+      
+      # createCDATASection
+      #   
+      #   Creates a CDATASection node whose value is the specified string.
+      #   
+      #   Parameters
+      #     data of type DOMString
+      #       The data for the CDATASection contents.
+      #   Return Value
+      #     CDATASection
+      #       The new CDATASection object.
+      #   Exceptions
+      #     DOMException
+      #       NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
+      def create_cdata_section( data )
+        return CDATASection.new( self, data )
+      end
+      
+      # createComment
+      #   
+      #   Creates a Comment node given the specified string.
+      #   
+      #   Parameters
+      #     data of type DOMString
+      #       The data for the node.
+      #   Return Value
+      #     Comment
+      #       The new Comment object.
+      #   No Exceptions
+      def create_comment( data )
+        return Comment.new( self, data )
+      end
+      
+      # ===== コンストラクタ =====
+      
+      #def initialize( aDOMImplementation, aNamespaceURI, aQualifiedName, aDoctype )
+      def initialize()
+        super(nil)
+        init_mod_parent_node()
+        @doctype = nil
+        @document_element = nil
+      end
+      
+      private
+      def check_hierarchy( new_child )
+        # Element (maximum of one), ProcessingInstruction, Comment, DocumentType (maximum of one)
+        super( new_child, true )
+        case new_child.node_type
+          when Node::ELEMENT_NODE then
+            if @document_element.nil? or @document_element.equal? new_child then
+              return true
+            else
+              raise DOMException.new( DOMException::HIERARCHY_REQUEST_ERR, 
+                      'This Document node already has an Element node. A second Element node can\'t be appended to a Document node.' )
+            end
+          when Node::DOCUMENT_TYPE_NODE then
+            if @doctype.nil? or @doctype.equal? new_child then
+              return true
+            else
+              raise DOMException.new( DOMException::HIERARCHY_REQUEST_ERR, 
+                      'This Document node already has an DocumentType node. A second DocumentType node can\'t be appended to a Document node.' )
+            end
+          when Node::COMMENT_NODE then
+            return true
+          when Node::PROCESSING_INSTRUCTION_NODE then
+            return true
+          else
+            raise DOMException.new( DOMException::HIERARCHY_REQUEST_ERR, 
+                    'This node is of a type that does not allow children of the type of the newChild node.' )
+        end
+      end
+      
+    end
+  end
+end

data/lib/vcdom/minidom/dom_exception.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# ソースコードのエンコーディング指定
+
+#require "vcdom/const"
+require "vcdom/minidom/minidom_standard_error"
+
+module VCDOM
+  module MiniDOM
+    class DOMException < MiniDOMStandardError
+      
+      #include Const::DOMException
+      # ExceptionCode
+      INDEX_SIZE_ERR                 = 1;
+      DOMSTRING_SIZE_ERR             = 2;
+      HIERARCHY_REQUEST_ERR          = 3;
+      WRONG_DOCUMENT_ERR             = 4;
+      INVALID_CHARACTER_ERR          = 5;
+      NO_DATA_ALLOWED_ERR            = 6;
+      NO_MODIFICATION_ALLOWED_ERR    = 7;
+      NOT_FOUND_ERR                  = 8;
+      NOT_SUPPORTED_ERR              = 9;
+      INUSE_ATTRIBUTE_ERR            = 10;
+      INVALID_STATE_ERR              = 11;
+      SYNTAX_ERR                     = 12;
+      INVALID_MODIFICATION_ERR       = 13;
+      NAMESPACE_ERR                  = 14;
+      INVALID_ACCESS_ERR             = 15;
+      VALIDATION_ERR                 = 16;
+      TYPE_MISMATCH_ERR              = 17;
+      
+      # ===== インスタンス変数 =====
+      def code; return @code end
+      
+      # ===== コンストラクタ =====
+      
+      def initialize( err_code, err_message = '' )
+        if err_code.is_a? DOMException then
+          err_message = err_code.message
+          err_code = err_code.code
+        end
+        super( err_message )
+        @code = err_code
+      end
+      
+      # ===== 内部メソッド =====
+      
+      # ===== 上書き =====
+      
+    end
+  end
+end

data/lib/vcdom/minidom/dom_implementation.rb

@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+
+require "vcdom/minidom/document"
+#require "vcdom/minidom/document_type"
+require "vcdom/minidom/dom_exception"
+
+require "vcdom/minidom/mini_parser"
+require "vcdom/minidom/mini_serializer"
+require "vcdom/minidom/xml_reg_exp"
+
+=begin
+  Interface DOMImplementation
+
+    The DOMImplementation interface provides a number of methods for performing 
+    operations that are independent of any particular instance of the document object model.
+
+    IDL Definition
+
+        interface DOMImplementation {
+          boolean            hasFeature(in DOMString feature, 
+                                        in DOMString version);
+          // Introduced in DOM Level 2:
+          DocumentType       createDocumentType(in DOMString qualifiedName, 
+                                                in DOMString publicId, 
+                                                in DOMString systemId)
+                                                raises(DOMException);
+          // Introduced in DOM Level 2:
+          Document           createDocument(in DOMString namespaceURI, 
+                                            in DOMString qualifiedName, 
+                                            in DocumentType doctype)
+                                                raises(DOMException);
+          // Introduced in DOM Level 3:
+          DOMObject          getFeature(in DOMString feature, 
+                                        in DOMString version);
+        };
+
+=end
+
+module VCDOM
+  module MiniDOM
+    class DOMImplementation
+      
+      @@instance = nil
+      
+      def mini_parser
+        return @mini_parser
+      end
+      def mini_serializer
+        return @mini_serializer
+      end
+      
+      # ===== Methods =====
+      
+      # createDocument introduced in DOM Level 2
+      #   
+      #   Creates a DOM Document object of the specified type with its document element.
+      #   Note that based on the DocumentType given to create the document, 
+      #   the implementation may instantiate specialized Document objects that support 
+      #   additional features than the "Core", such as "HTML" [DOM Level 2 HTML]. 
+      #   On the other hand, setting the DocumentType after the document was 
+      #   created makes this very unlikely to happen. 
+      #   Alternatively, specialized Document creation methods, such as createHTMLDocument
+      #   [DOM Level 2 HTML], can be used to obtain specific types of Document objects.
+      #   
+      #   Parameters
+      #     namespaceURI of type DOMString
+      #       The namespace URI of the document element to create or null.
+      #     qualifiedName of type DOMString
+      #       The qualified name of the document element to be created or null.
+      #     doctype of type DocumentType
+      #       The type of document to be created or null.
+      #       When doctype is not null, its Node.ownerDocument attribute is set to 
+      #       the document being created.
+      #   Return Value
+      #     Document
+      #       A new Document object with its document element. 
+      #       If the NamespaceURI, qualifiedName, and doctype are null, the returned 
+      #       Document is empty with no document element.
+      #   Exceptions
+      #     DOMException
+      #       INVALID_CHARACTER_ERR: Raised if the specified qualified name is not an 
+      #                 XML name according to [XML 1.0].
+      #       NAMESPACE_ERR: Raised if the qualifiedName is malformed, if the 
+      #                 qualifiedName has a prefix and the namespaceURI is null, 
+      #                 or if the qualifiedName is null and the namespaceURI is 
+      #                 different from null, or if the qualifiedName has a prefix 
+      #                 that is "xml" and the namespaceURI is different from 
+      #                 "http://www.w3.org/XML/1998/namespace" [XML Namespaces], 
+      #                 or if the DOM implementation does not support the "XML" feature 
+      #                 but a non-null namespace URI was provided, since namespaces were 
+      #                 defined by XML.
+      #       WRONG_DOCUMENT_ERR: Raised if doctype has already been used with a different 
+      #                 document or was created from a different implementation.
+      #       NOT_SUPPORTED_ERR: May be raised if the implementation does not support 
+      #                 the feature "XML" and the language exposed through the Document 
+      #                 does not support XML Namespaces (such as [HTML 4.01]).
+      def create_document( namespace_uri, qualified_name, doctype = nil )
+        # 第 3 引数が nil でなければエラー
+        if ! doctype.nil? then
+          raise TypeError.new( 'This DOM implementation does not support a Doctype, so the third argument must be null.' )
+        end
+        doc = Document.new()
+        if qualified_name.nil? and ! namespace_uri.nil? then
+          # the qualified name is null, but namespace URI is different from null
+          raise DOMException.new( DOMException::NAMESPACE_ERR, 
+                  'The qualified name is null, but namespace URI is different from null.' )
+        end
+        if ! qualified_name.nil? then
+          doc.append_child( doc.create_element_ns( namespace_uri, qualified_name ) )
+        end
+        #doc._set_document_type( doctype )
+        #doc._set_document_element( doc.create_element_ns( namespace_uri, qualified_name ) )
+        # doctype の ownerDocument を設定
+        #aDoctype._setOwnerDocument( doc ) if ( aDoctype != nil )
+        return doc
+      end
+      #alias :createDocument :create_document
+      
+      # createDocumentType introduced in DOM Level 2
+      #   
+      #   Creates an empty DocumentType node. 
+      #   Entity declarations and notations are not made available. 
+      #   Entity reference expansions and default attribute additions do not occur..
+      #   
+      #   Parameters
+      #     qualifiedName of type DOMString
+      #       The qualified name of the document type to be created.
+      #     publicId of type DOMString
+      #       The external subset public identifier.
+      #     systemId of type DOMString
+      #       The external subset system identifier.
+      #   Return Value
+      #     DocumentType
+      #       A new DocumentType node with Node.ownerDocument set to null.
+      #   Exceptions
+      #     DOMException
+      #       INVALID_CHARACTER_ERR: Raised if the specified qualified name is not 
+      #                 an XML name according to [XML 1.0].
+      #       NAMESPACE_ERR: Raised if the qualifiedName is malformed.
+      #       NOT_SUPPORTED_ERR: May be raised if the implementation does not support 
+      #                 the feature "XML" and the language exposed through the Document 
+      #                 does not support XML Namespaces (such as [HTML 4.01]).
+      #def create_document_type( qualified_name, public_id, system_id )
+        #return DocumentType.new( qualified_name, public_id, system_id )
+      #end
+      #alias :createDocumentType :create_document_type
+      
+=begin
+      
+      # getFeature introduced in DOM Level 3
+      #   
+      #   This method returns a specialized object which implements the specialized 
+      #   APIs of the specified feature and version, as specified in DOM Features. 
+      #   The specialized object may also be obtained by using binding-specific 
+      #   casting methods but is not necessarily expected to, as discussed in Mixed 
+      #   DOM Implementations. 
+      #   This method also allow the implementation to provide specialized objects 
+      #   which do not support the DOMImplementation interface.
+      #   
+      #   Parameters
+      #     feature of type DOMString
+      #       The name of the feature requested. 
+      #       Note that any plus sign "+" prepended to the name of the feature will 
+      #       be ignored since it is not significant in the context of this method.
+      #     version of type DOMString
+      #       This is the version number of the feature to test.
+      #   Return Value
+      #     DOMObject
+      #       Returns an object which implements the specialized APIs of the specified 
+      #       feature and version, if any, or null if there is no object which implements 
+      #       interfaces associated with that feature. 
+      #       If the DOMObject returned by this method implements the DOMImplementation 
+      #       interface, it must delegate to the primary core DOMImplementation and not 
+      #       return results inconsistent with the primary core DOMImplementation such 
+      #       as hasFeature, getFeature, etc.
+      #   No Exceptions
+      
+      # hasFeature
+      #   
+      #   Test if the DOM implementation implements a specific feature and version, 
+      #   as specified in DOM Features.
+      #   
+      #   Parameters
+      #     feature of type DOMString
+      #       The name of the feature to test.
+      #     version of type DOMString
+      #       This is the version number of the feature to test.
+      #   Return Value
+      #     boolean
+      #       true if the feature is implemented in the specified version, false otherwise.
+      #   No Exceptions
+      
+=end
+      
+      def initialize()
+        if ! @@instance.nil? then
+          raise "既にインスタンス化されています"
+        end
+        @@instance = self
+        @mini_parser     = MiniParser.new()
+        @mini_serializer = MiniSerializer.new()
+      end
+      
+      def self.get_instance()
+        if @@instance.nil? then
+          return self.new()
+        else
+          return @@instance
+        end
+      end
+      
+    end
+  end
+end