Class: REXML::DocType (Ruby 2.2.4)
Description: Class : REXML::DocType - Ruby 2.2.4

- Home
- Core 2.2.4
- Std-lib 2.2.4
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- rexml/doctype.rb
- rexml/text.rb

### Parent

Parent

### Methods

- ::new
- #add
- #attribute_of
- #attributes_of
- #clone
- #context
- #entity
- #node_type
- #notation
- #notations
- #public
- #system
- #write

### Included Modules

- REXML::XMLTokens

### Class/Module Index

Quicksearch

- Array
- Fixnum
- Float
- Object
- REXML
- REXML::AttlistDecl
- REXML::Attribute
- REXML::Attributes
- REXML::CData
- REXML::Child
- REXML::Comment
- REXML::DTD
- REXML::DTD::AttlistDecl
- REXML::DTD::ElementDecl
- REXML::DTD::EntityDecl
- REXML::DTD::NotationDecl
- REXML::DTD::Parser
- REXML::Declaration
- REXML::DocType
- REXML::Document
- REXML::Element
- REXML::ElementDecl
- REXML::Elements
- REXML::Encoding
- REXML::Entity
- REXML::EntityConst
- REXML::ExternalEntity
- REXML::Formatters
- REXML::Formatters::Default
- REXML::Formatters::Pretty
- REXML::Formatters::Transitive
- REXML::Functions
- REXML::IOSource
- REXML::Instruction
- REXML::Light
- REXML::Light::Node
- REXML::Namespace
- REXML::Node
- REXML::NotationDecl
- REXML::Output
- REXML::Parent
- REXML::ParseException
- REXML::Parsers
- REXML::Parsers::BaseParser
- REXML::Parsers::LightParser
- REXML::Parsers::PullEvent
- REXML::Parsers::PullParser
- REXML::Parsers::SAX2Parser
- REXML::Parsers::StreamParser
- REXML::Parsers::TreeParser
- REXML::Parsers::UltraLightParser
- REXML::Parsers::XPathParser
- REXML::QuickPath
- REXML::SAX2Listener
- REXML::Security
- REXML::Source
- REXML::SourceFactory
- REXML::StreamListener
- REXML::SyncEnumerator
- REXML::Text
- REXML::UndefinedNamespaceException
- REXML::Validation
- REXML::Validation::Choice
- REXML::Validation::Event
- REXML::Validation::Interleave
- REXML::Validation::OneOrMore
- REXML::Validation::Optional
- REXML::Validation::Ref
- REXML::Validation::RelaxNG
- REXML::Validation::Sequence
- REXML::Validation::State
- REXML::Validation::ValidationException
- REXML::Validation::Validator
- REXML::Validation::ZeroOrMore
- REXML::XMLDecl
- REXML::XMLTokens
- REXML::XPath
- REXML::XPathParser
- Symbol

No matching classes.

# REXML::DocType

Represents an XML DOCTYPE declaration; that is, the contents of <!DOCTYPE … >. DOCTYPES can be used to declare the DTD of a document, as well as being used to declare entities used in the document.

### Constants

DEFAULT_ENTITIES
PUBLIC
START
STOP
SYSTEM

### Attributes

entities[R]

name is the name of the doctype #external_id is the referenced DTD, if given

external_id[R]

name is the name of the doctype #external_id is the referenced DTD, if given

name[R]

name is the name of the doctype #external_id is the referenced DTD, if given

namespaces[R]

name is the name of the doctype #external_id is the referenced DTD, if given

### Public Class Methods

new( first, parent=nil ) click to toggle source

Constructor

    dt = DocType.new( 'foo', '-//I/Hate/External/IDs' )
    # <!DOCTYPE foo '-//I/Hate/External/IDs'>
    dt = DocType.new( doctype_to_clone )
    # Incomplete.  Shallow clone of doctype

`Note` that the constructor:

    Doctype.new( Source.new( "<!DOCTYPE foo 'bar'>" ) )

is deprecated. Do not use it. It will probably disappear.

                   # File rexml/doctype.rb, line 41
    def initialize( first, parent=nil )
      @entities = DEFAULT_ENTITIES
      @long_name = @uri = nil
      if first.kind_of? String
        super()
        @name = first
        @external_id = parent
      elsif first.kind_of? DocType
        super( parent )
        @name = first.name
        @external_id = first.external_id
      elsif first.kind_of? Array
        super( parent )
        @name = first[0]
        @external_id = first[1]
        @long_name = first[2]
        @uri = first[3]
      elsif first.kind_of? Source
        super( parent )
        parser = Parsers::BaseParser.new( first )
        event = parser.pull
        if event[0] == :start_doctype
          @name, @external_id, @long_name, @uri, = event[1..-1]
        end
      else
        super()
      end
    end

### Public Instance Methods

add(child) click to toggle source

                   # File rexml/doctype.rb, line 136
    def add child
      super(child)
      @entities = DEFAULT_ENTITIES.clone if @entities == DEFAULT_ENTITIES
      @entities[ child.name ] = child if child.kind_of? Entity
    end

attribute_of(element, attribute) click to toggle source

                   # File rexml/doctype.rb, line 84
    def attribute_of element, attribute
      att_decl = find do |child|
        child.kind_of? AttlistDecl and
        child.element_name == element and
        child.include? attribute
      end
      return nil unless att_decl
      att_decl[attribute]
    end

attributes_of(element) click to toggle source

                   # File rexml/doctype.rb, line 74
    def attributes_of element
      rv = []
      each do |child|
        child.each do |key,val|
          rv << Attribute.new(key,val)
        end if child.kind_of? AttlistDecl and child.element_name == element
      end
      rv
    end

clone() click to toggle source

                   # File rexml/doctype.rb, line 94
    def clone
      DocType.new self
    end

context() click to toggle source

                   # File rexml/doctype.rb, line 128
    def context
      @parent.context
    end

entity( name ) click to toggle source

                   # File rexml/doctype.rb, line 132
    def entity( name )
      @entities[name].unnormalized if @entities[name]
    end

node_type() click to toggle source

                   # File rexml/doctype.rb, line 70
    def node_type
      :doctype
    end

notation(name) click to toggle source

Retrieves a named notation. Only notations declared in the internal DTD subset can be retrieved.

Method contributed by Henrik Martensson

                   # File rexml/doctype.rb, line 180
    def notation(name)
      notations.find { |notation_decl|
        notation_decl.name == name
      }
    end

notations() click to toggle source

This method returns a list of notations that have been declared in the internal DTD subset. Notations in the external DTD subset are not listed.

Method contributed by Henrik Martensson

                   # File rexml/doctype.rb, line 172
    def notations
      children().select {|node| node.kind_of?(REXML::NotationDecl)}
    end

public() click to toggle source

This method retrieves the public identifier identifying the document's DTD.

Method contributed by Henrik Martensson

                   # File rexml/doctype.rb, line 146
    def public
      case @external_id
      when "SYSTEM"
        nil
      when "PUBLIC"
        strip_quotes(@long_name)
      end
    end

system() click to toggle source

This method retrieves the system identifier identifying the document's DTD

Method contributed by Henrik Martensson

                   # File rexml/doctype.rb, line 158
    def system
      case @external_id
      when "SYSTEM"
        strip_quotes(@long_name)
      when "PUBLIC"
        @uri.kind_of?(String) ? strip_quotes(@uri) : nil
      end
    end

write( output, indent=0, transitive=false, ie_hack=false ) click to toggle source

output

  Where to write the string

indent

  An integer. If -1, no indentation will be used; otherwise, the indentation will be this number of spaces, and children will be indented an additional amount.

transitive

  Ignored

ie_hack

  Ignored

                   # File rexml/doctype.rb, line 108
    def write( output, indent=0, transitive=false, ie_hack=false )
      f = REXML::Formatters::Default.new
      indent( output, indent )
      output << START
      output << ' '
      output << @name
      output << " #@external_id" if @external_id
      output << " #{@long_name.inspect}" if @long_name
      output << " #{@uri.inspect}" if @uri
      unless @children.empty?
        output << ' ['
        @children.each { |child|
          output << "\n"
          f.write( child, output )
        }
        output << "\n]"
      end
      output << STOP
    end