xaiml 0.1.0

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox/type.h

@@ -0,0 +1,39 @@
+/* type.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef __OX_TYPE_H__
+#define __OX_TYPE_H__
+
+typedef enum {
+    NoCode	   = 0,
+    ArrayCode	   = 'a',
+    String64Code   = 'b', /* base64 encoded String */
+    ClassCode	   = 'c',
+    Symbol64Code   = 'd', /* base64 encoded Symbol */
+    DateCode	   = 'D',
+    BigDecimalCode = 'B',
+    ExceptionCode  = 'e',
+    FloatCode	   = 'f',
+    RegexpCode	   = 'g',
+    HashCode	   = 'h',
+    FixnumCode	   = 'i',
+    BignumCode	   = 'j',
+    KeyCode	   = 'k', /* indicates the value is a hash key, kind of a hack */
+    RationalCode   = 'l',
+    SymbolCode	   = 'm',
+    FalseClassCode = 'n',
+    ObjectCode	   = 'o',
+    RefCode	   = 'p',
+    RangeCode	   = 'r',
+    StringCode	   = 's',
+    TimeCode	   = 't',
+    StructCode	   = 'u',
+    ComplexCode	   = 'v',
+    RawCode	   = 'x',
+    TrueClassCode  = 'y',
+    NilClassCode   = 'z',
+} Type;
+
+#endif /* __OX_TYPE_H__ */

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/bag.rb

@@ -0,0 +1,99 @@
+
+module Ox
+
+  # A generic class that is used only for storing attributes. It is the base
+  # Class for auto-generated classes in the storage system. Instance variables
+  # are added using the instance_variable_set() method. All instance variables
+  # can be accessed using the variable name (without the @ prefix). No setters
+  # are provided as the Class is intended for reading only.
+  class Bag
+
+    # The initializer can take multiple arguments in the form of key values
+    # where the key is the variable name and the value is the variable
+    # value. This is intended for testing purposes only.
+    # - +args+ [Hash] instance variable symbols and their values
+    #
+    # *Example*
+    #
+    #  Ox::Bag.new(:@x => 42, :@y => 57)
+    #
+    def initialize(args={ })
+      args.each do |k,v|
+        self.instance_variable_set(k, v)
+      end
+    end
+
+    # Replaces the Object.respond_to?() method.
+    # - +m+ [Symbol] method symbol
+    # *return* [Boolean] true for any method that matches an instance variable
+    # reader, otherwise false.
+    def respond_to?(m)
+      return true if super
+      at_m = ('@' + m.to_s).to_sym
+      instance_variables.include?(at_m)
+    end
+
+    # Handles requests for variable values. Others cause an Exception to be
+    # raised.
+    # - +m+ (Symbol) method symbol
+    # *return* [Boolean] the value of the specified instance variable.
+    #
+    # _raise_ [ArgumentError] if an argument is given. Zero arguments expected.
+    #
+    # _raise_ [NoMethodError] if the instance variable is not defined.
+    def method_missing(m, *args, &block)
+      raise ArgumentError.new("wrong number of arguments (#{args.size} for 0) to method #{m}") unless args.nil? or args.empty?
+      at_m = ('@' + m.to_s).to_sym
+      raise NoMethodError.new("undefined method #{m}", m) unless instance_variable_defined?(at_m)
+      instance_variable_get(at_m)
+    end
+
+    # Replaces eql?() with something more reasonable for this Class.
+    # - +other+ [Object] Object to compare self to
+    # *return* [Boolean] true if each variable and value are the same, otherwise false.
+    def eql?(other)
+      return false if (other.nil? or self.class != other.class)
+      ova = other.instance_variables
+      iv = instance_variables
+      return false if ova.size != iv.size
+      iv.each do |vid|
+        return false if instance_variable_get(vid) != other.instance_variable_get(vid)
+      end
+      true
+    end
+    alias == eql?
+    
+    # Define a new class based on the Ox::Bag class. This is used internally in
+    # the Ox module and is available to service wrappers that receive XML
+    # requests that include Objects of Classes not defined in the storage
+    # process.
+    # - +classname+ (String) Class name or symbol that includes Module names.
+    # *return* [Object] an instance of the specified Class.
+    #
+    # _raise_ [NameError] if the classname is invalid.
+    def self.define_class(classname)
+      classname = classname.to_s unless classname.is_a?(String)
+      tokens = classname.split('::').map { |n| n.to_sym }
+      raise NameError.new("Invalid classname '#{classname}") if tokens.empty?
+      m = Object
+      tokens[0..-2].each do |sym|
+        if m.const_defined?(sym)
+          m = m.const_get(sym)
+        else
+          c = Module.new
+          m.const_set(sym, c)
+          m = c
+        end
+      end
+      sym = tokens[-1]
+      if m.const_defined?(sym)
+        c = m.const_get(sym)
+      else
+        c = Class.new(Ox::Bag)
+        m.const_set(sym, c)
+      end
+      c
+    end
+
+  end # Bag
+end # Ox

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/cdata.rb

@@ -0,0 +1,12 @@
+
+module Ox
+  # CData represents a CDATA element in an XML document.
+  class CData < Node
+    # Creates a CDATA element.
+    # - +value+ [String] value for the CDATA contents
+    def initialize(value)
+      super
+    end
+
+  end # CData
+end # Ox

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/comment.rb

@@ -0,0 +1,13 @@
+
+module Ox
+  # Comments represent XML comments in an XML document. A comment has a value
+  # attribute only.
+  class Comment < Node
+    # Creates a new Comment with the specified value.
+    # - +value+ [String] string value for the comment
+    def initialize(value)
+      super
+    end
+
+  end # Comment
+end # Ox

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/doctype.rb

@@ -0,0 +1,13 @@
+
+module Ox
+  # Represents a DOCTYPE in an XML document.
+  class DocType < Node
+    # Creates a DOCTYPE elements with the content as a string specified in the
+    # value parameter.
+    # - +value+ [String] string value for the element
+    def initialize(value)
+      super
+    end
+
+  end # DocType
+end # Ox

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/document.rb

@@ -0,0 +1,30 @@
+
+module Ox
+  # Represents an XML document. It has a fixed set of attributes which form
+  # the XML prolog. A Document includes Elements.
+  class Document < Element
+    # Create a new Document.
+    # - +prolog+ [Hash] prolog attributes
+    #   - _:version_ [String] version, typically '1.0' or '1.1'
+    #   - _:encoding_ [String] encoding for the document, currently included but ignored
+    #   - _:standalone_ [String] indicates the document is standalone
+    def initialize(prolog={})
+      super(nil)
+      @attributes = { }
+      @attributes[:version] = prolog[:version] unless prolog[:version].nil?
+      @attributes[:encoding] = prolog[:encoding] unless prolog[:encoding].nil?
+      @attributes[:standalone] = prolog[:standalone] unless prolog[:standalone].nil?
+    end
+    
+    # Returns the first Element in the document.
+    def root()
+      unless !instance_variable_defined?(:@nodes) || @nodes.nil?
+        @nodes.each do |n|
+          return n if n.is_a?(::Ox::Element)
+        end
+      end
+      nil
+    end
+
+  end # Document
+end # Ox

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/element.rb

@@ -0,0 +1,319 @@
+
+module Ox
+
+  # An Element represents a element of an XML document. It has a name,
+  # attributes, and sub-nodes.
+  #
+  # To access the child elements or attributes there are several options. One
+  # is to walk the nodes and attributes. Another is to use the locate()
+  # method. The easiest for simple regularly formatted XML is to reference the
+  # sub elements or attributes simply by name. Repeating elements with the
+  # same name can be referenced with an element count as well. A few examples
+  # should explain the 'easy' API more clearly.
+  #
+  # *Example*
+  #
+  #   doc = Ox.parse(%{
+  #   <?xml?>
+  #   <People>
+  #     <Person age="58">
+  #       <given>Peter</given>
+  #       <surname>Ohler</surname>
+  #     </Person>
+  #     <Person>
+  #       <given>Makie</given>
+  #       <surname>Ohler</surname>
+  #     </Person>
+  #   </People>
+  #   })
+  #
+  #   doc.People.Person.given.text
+  #   => "Peter"
+  #   doc.People.Person(1).given.text
+  #   => "Makie"
+  #   doc.People.Person.age
+  #   => "58"
+  class Element < Node
+    include HasAttrs
+
+    # Creates a new Element with the specified name.
+    # - +name+ [String] name of the Element
+    def initialize(name)
+      super
+      @attributes = {}
+      @nodes = []
+    end
+    alias name value
+
+    # Returns the Element's nodes array. These are the sub-elements of this
+    # Element.
+    # *return* [Array] all child Nodes.
+    def nodes
+      @nodes = [] if !instance_variable_defined?(:@nodes) or @nodes.nil?
+      @nodes
+    end
+
+    # Appends a Node to the Element's nodes array. Returns the element itself
+    # so multiple appends can be chained together.
+    # - +node+ [Node] Node to append to the nodes array
+    def <<(node)
+      raise "argument to << must be a String or Ox::Node." unless node.is_a?(String) or node.is_a?(Node)
+      @nodes = [] if !instance_variable_defined?(:@nodes) or @nodes.nil?
+      @nodes << node
+      self
+    end
+
+    # Prepend a Node to the Element's nodes array. Returns the element itself
+    # so multiple appends can be chained together.
+    # - +node+ [Node] Node to prepend to the nodes array
+    def prepend_child(node)
+      raise "argument to << must be a String or Ox::Node." unless node.is_a?(String) or node.is_a?(Node)
+      @nodes = [] if !instance_variable_defined?(:@nodes) or @nodes.nil?
+      @nodes.unshift(node)
+      self
+    end
+
+    # Returns true if this Object and other are of the same type and have the
+    # equivalent value and the equivalent elements otherwise false is returned.
+    # - +other+ [Object] Object compare _self_ to.
+    # *return* [Boolean] true if both Objects are equivalent, otherwise false.
+    def eql?(other)
+      return false unless super(other)
+      return false unless self.attributes == other.attributes
+      return false unless self.nodes == other.nodes
+      true
+    end
+    alias == eql?
+
+    # Returns the first String in the elements nodes array or nil if there is
+    # no String node.
+    def text()
+      nodes.each { |n| return n if n.is_a?(String) }
+      nil
+    end
+
+    # Clears any child nodes of an element and replaces those with a single Text
+    # (String) node. Note the existing nodes array is modified and not replaced.
+    # - +txt+ [String] to become the only element of the nodes array
+    def replace_text(txt)
+      raise "the argument to replace_text() must be a String" unless txt.is_a?(String)
+      @nodes.clear()
+      @nodes << txt
+    end
+
+    # Return true if all the key-value pairs in the cond Hash match the
+    # @attributes key-values.
+    def attr_match(cond)
+      cond.each_pair { |k,v| return false unless v == @attributes[k.to_sym] || v == @attributes[k.to_s] }
+      true
+    end
+
+    # Iterate over each child of the instance yielding according to the cond
+    # argument value. If the cond argument is nil then all child nodes are
+    # yielded to. If cond is a string then only the child Elements with a
+    # matching name will be yielded to. If the cond is a Hash then the
+    # keys-value pairs in the cond must match the child attribute values with
+    # the same keys. Any other cond type will yield to nothing.
+    def each(cond=nil)
+      if cond.nil?
+        nodes.each { |n| yield(n) }
+      else
+        cond = cond.to_s if cond.is_a?(Symbol)
+        if cond.is_a?(String)
+          nodes.each { |n| yield(n) if n.is_a?(Element) && cond == n.name }
+        elsif cond.is_a?(Hash)
+          nodes.each { |n| yield(n) if n.is_a?(Element) && n.attr_match(cond) }
+        end
+      end
+    end
+
+    # Returns an array of Nodes or Strings that correspond to the locations
+    # specified by the path parameter. The path parameter describes the path
+    # to the return values which can be either nodes in the XML or
+    # attributes. The path is a relative description. There are similarities
+    # between the locate() method and XPath but locate does not follow the
+    # same rules as XPath. The syntax is meant to be simpler and more Ruby
+    # like.
+    #
+    # Like XPath the path delimiters are the slash (/) character. The path is
+    # split on the delimiter and each element of the path then describes the
+    # child of the current Element to traverse.
+    #
+    # Attributes are specified with an @ prefix.
+    #
+    # Each element name in the path can be followed by a bracket expression
+    # that narrows the paths to traverse. Supported expressions are numbers
+    # with a preceeding qualifier. Qualifiers are -, +, <, and >. The +
+    # qualifier is the default. A - qualifier indicates the index begins at
+    # the end of the children just like for Ruby Arrays. The < and >
+    # qualifiers indicates all elements either less than or greater than
+    # should be matched. Note that unlike XPath, the element index starts at 0
+    # similar to Ruby be contrary to XPath.
+    #
+    # Element names can also be wildcard characters. A * indicates any decendent should be followed. A ? indicates any
+    # single Element can match the wildcard. A ^ character followed by the name of a Class will match any node of the
+    # specified class. Valid class names are Element, Comment, String (or Text), CData, DocType.
+    #
+    # Examples are:
+    # * <code>element.locate("Family/Pete/*")</code> returns all children of the Pete Element.
+    # * <code>element.locate("Family/?[1]")</code> returns the first element in the Family Element.
+    # * <code>element.locate("Family/?[<3]")</code> returns the first 3 elements in the Family Element.
+    # * <code>element.locate("Family/?[@age]")</code> returns the elements with an age attribute defined in the Family Element.
+    # * <code>element.locate("Family/Kid[@age]")</code> returns the Kid elements with an age attribute defined in the Family Element.
+    # * <code>element.locate("Family/?[@age=32]")</code> returns the elements with an age attribute equal to 32 in the Family Element.
+    # * <code>element.locate("Family/Kid[@age=32]")</code> returns the Kid elements with an age attribute equal to 32 in the Family Element.
+    # * <code>element.locate("Family/?/@age")</code> returns the arg attribute for each child in the Family Element.
+    # * <code>element.locate("Family/*/@type")</code> returns the type attribute value for decendents of the Family.
+    # * <code>element.locate("Family/^Comment")</code> returns any comments that are a child of Family.
+    #
+    # - +path+ [String] path to the Nodes to locate
+    def locate(path)
+      return [self] if path.nil?
+      found = []
+      pa = path.split('/')
+      if '*' == path[0]
+        # a bit of a hack but it allows self to be checked as well
+        e = Element.new('')
+        e << self
+        e.alocate(pa, found)
+      else
+        alocate(pa, found)
+      end
+      found
+    end
+
+    # Handles the 'easy' API that allows navigating a simple XML by
+    # referencing elements and attributes by name.
+    # - +id+ [Symbol] element or attribute name
+    # *return* [Element|Node|String|nil] the element, attribute value, or Node identifed by the name
+    #
+    # _raise_ [NoMethodError] if no match is found
+    def method_missing(id, *args, &block)
+      has_some = false
+      ids = id.to_s
+      i = args[0].to_i # will be 0 if no arg or parsing fails
+      nodes.each do |n|
+        if (n.is_a?(Element) || n.is_a?(Instruct)) && (n.value == id || n.value == ids || name_matchs?(n.value, ids))
+          return n if 0 == i
+          has_some = true
+          i -= 1
+        end
+      end
+      if instance_variable_defined?(:@attributes)
+        return @attributes[id] if @attributes.has_key?(id)
+        return @attributes[ids] if @attributes.has_key?(ids)
+      end
+      return nil if has_some
+      raise NoMethodError.new("#{ids} not found", name)
+    end
+
+    # - +id+ [String|Symbol] identifer of the attribute or method
+    # - +ignored+ inc_all [Boolean]
+    # *return* true if the element has a member that matches the provided name.
+    def respond_to?(id, inc_all=false)
+      return true if super
+      id_str = id.to_s
+      id_sym = id.to_sym
+      nodes.each do |n|
+        next if n.is_a?(String)
+        return true if n.value == id_str || n.value == id_sym || name_matchs?(n.value, id_str)
+      end
+      if instance_variable_defined?(:@attributes) && !@attributes.nil?
+        return true if @attributes.has_key?(id_str)
+        return true if @attributes.has_key?(id_sym)
+      end
+      false
+    end
+
+    # - +path+ [Array] array of steps in a path
+    # - +found+ [Array] matching nodes
+    def alocate(path, found)
+      step = path[0]
+      if step.start_with?('@') # attribute
+        raise InvalidPath.new(path) unless 1 == path.size
+        if instance_variable_defined?(:@attributes)
+          step = step[1..-1]
+          sym_step = step.to_sym
+          @attributes.each do |k,v|
+            found << v if ('?' == step or k == step or k == sym_step)
+          end
+        end
+      else # element name
+        if (i = step.index('[')).nil? # just name
+          name = step
+          qual = nil
+        else
+          name = step[0..i-1]
+          raise InvalidPath.new(path) unless step.end_with?(']')
+          i += 1
+          qual = step[i..i] # step[i] would be better but some rubies (jruby, ree, rbx) take that as a Fixnum.
+          if '0' <= qual and qual <= '9'
+            qual = '+'
+          else
+            i += 1
+          end
+          index = step[i..-2].to_i
+        end
+        if '?' == name or '*' == name
+          match = nodes
+        elsif '^' == name[0..0] # 1.8.7 thinks name[0] is a fixnum
+          case name[1..-1]
+           when 'Element'
+            match = nodes.select { |e| e.is_a?(Element) }
+           when 'String', 'Text'
+            match = nodes.select { |e| e.is_a?(String) }
+          when 'Comment'
+            match = nodes.select { |e| e.is_a?(Comment) }
+          when 'CData'
+            match = nodes.select { |e| e.is_a?(CData) }
+          when 'DocType'
+            match = nodes.select { |e| e.is_a?(DocType) }
+          else
+            #puts "*** no match on #{name}"
+            match = []
+          end
+        else
+          match = nodes.select { |e| e.is_a?(Element) and name == e.name }
+        end
+        unless qual.nil? or match.empty?
+          case qual
+          when '+'
+            match = index < match.size ? [match[index]] : []
+          when '-'
+            match = index <= match.size ? [match[-index]] : []
+          when '<'
+            match = 0 < index ? match[0..index - 1] : []
+          when '>'
+            match = index <= match.size ? match[index + 1..-1] : []
+          when '@'
+            k,v = step[i..-2].split('=')
+            if v
+              match = match.select { |n| n.is_a?(Element) && (v == n.attributes[k.to_sym] || v == n.attributes[k]) }
+            else
+              match = match.select { |n| n.is_a?(Element) && (n.attributes[k.to_sym] || n.attributes[k]) }
+            end
+          else
+            raise InvalidPath.new(path)
+          end
+        end
+        if (1 == path.size)
+          match.each { |n| found << n }
+        elsif '*' == name
+          match.each { |n| n.alocate(path, found) if n.is_a?(Element) }
+          match.each { |n| n.alocate(path[1..-1], found) if n.is_a?(Element) }
+        else
+          match.each { |n| n.alocate(path[1..-1], found) if n.is_a?(Element) }
+        end
+      end
+    end
+
+    private
+
+    def name_matchs?(pat, id)
+      return false unless pat.length == id.length
+      pat.length.times { |i| return false unless '_' == id[i] || pat[i] == id[i] }
+      true
+    end
+
+  end # Element
+end # Ox

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/error.rb

@@ -0,0 +1,24 @@
+
+module Ox
+
+  # Base error class for Ox errors.
+  class Error < StandardError
+  end # Error
+
+  # An Exception that is raised as a result of a parse error while parsing a XML document.
+  class ParseError < Error
+  end # ParseError
+
+  # An Exception that is raised as a result of an invalid argument.
+  class ArgError < Error
+  end # ArgError
+
+  # An Exception raised if a path is not valid.
+  class InvalidPath < Error
+    # Create a new instance with the +path+ specified.
+    def initialize(path)
+      super("#{path.join('/')} is not a valid location.")
+    end
+  end # InvalidPath
+
+end # Ox

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/hasattrs.rb

@@ -0,0 +1,48 @@
+
+module Ox
+
+  # An Object that includes the HasAttrs module can have attributes which are a Hash of String values and either String
+  # or Symbol keys.
+  #
+  # To access the attributes there are several options. One is to walk the attributes. The easiest for simple regularly
+  # formatted XML is to reference the attributes simply by name.
+  module HasAttrs
+    # Returns all the attributes of the Instruct as a Hash.
+    # *return* [Hash] all attributes and attribute values.
+    def attributes
+      @attributes = { } if !instance_variable_defined?(:@attributes) or @attributes.nil?
+      @attributes
+    end
+    
+    # Returns the value of an attribute.
+    # - +attr+ [Symbol|String] attribute name or key to return the value for
+    def [](attr)
+      return nil unless instance_variable_defined?(:@attributes) and @attributes.is_a?(Hash)
+      @attributes[attr] or (attr.is_a?(String) ? @attributes[attr.to_sym] : @attributes[attr.to_s])
+    end
+
+    # Adds or set an attribute of the Instruct.
+    # - +attr+ [Symbol|String] attribute name or key
+    # - +value+ [Object] value for the attribute
+    def []=(attr, value)
+      raise "argument to [] must be a Symbol or a String." unless attr.is_a?(Symbol) or attr.is_a?(String)
+      @attributes = { } if !instance_variable_defined?(:@attributes) or @attributes.nil?
+      @attributes[attr] = value.to_s
+    end
+    
+    # Handles the 'easy' API that allows navigating a simple XML by
+    # referencing attributes by name.
+    # - +id+ [Symbol] element or attribute name
+    # *return* [String|nil] the attribute value
+    # _raise_ [NoMethodError] if no match is found
+    def method_missing(id, *args, &block)
+      ids = id.to_s
+      if instance_variable_defined?(:@attributes)
+        return @attributes[id] if @attributes.has_key?(id)
+        return @attributes[ids] if @attributes.has_key?(ids)
+      end
+      raise NoMethodError.new("#{ids} not found", name)
+    end
+
+  end # HasAttrs
+end # Ox

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/instruct.rb

@@ -0,0 +1,36 @@
+
+module Ox
+
+  # An Instruct represents a processing instruction of an XML document. It has a target, attributes, and a value or
+  # content. The content will be all characters with the exception of the target. If the content follows a regular
+  # attribute format then the attributes will be set to the parsed values. If it does not follow the attribute formate
+  # then the attributes will be empty.
+  class Instruct < Node
+    include HasAttrs
+
+    # The content of the processing instruction.
+    attr_accessor :content
+
+    # Creates a new Instruct with the specified name.
+    # - +name+ [String] name of the Instruct
+    def initialize(name)
+      super
+      @attributes = nil
+      @content = nil
+    end
+    alias target value
+    
+    # Returns true if this Object and other are of the same type and have the
+    # equivalent value and the equivalent elements otherwise false is returned.
+    # - +other+ [Object] Object compare _self_ to.
+    # *return* [Boolean] true if both Objects are equivalent, otherwise false.
+    def eql?(other)
+      return false unless super(other)
+      return false unless self.attributes == other.attributes
+      return false unless self.content == other.content
+      true
+    end
+    alias == eql?
+    
+  end # Instruct
+end # Ox

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/node.rb

@@ -0,0 +1,24 @@
+
+module Ox
+  # The Node is the base class for all other in the Ox module.
+  class Node
+    # String value associated with the Node.
+    attr_accessor :value
+    
+    # Creates a new Node with the specified String value.
+    # - +value+ [String] string value for the Node
+    def initialize(value)
+      @value = value.to_s
+    end
+
+    # Returns true if this Object and other are of the same type and have the
+    # equivalent value otherwise false is returned.
+    # - +other+ [Object] Object to compare _self_ to.
+    def eql?(other)
+      return false if (other.nil? or self.class != other.class)
+      other.value == self.value
+    end
+    alias == eql?
+
+  end # Node
+end # Ox

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/lib/ox/raw.rb

@@ -0,0 +1,14 @@
+
+module Ox
+  # Raw elements are used to inject existing XML strings into a document
+  # WARNING: Use of this feature can result in invalid XML, since `value` is
+  # injected as-is.
+  class Raw < Node
+    # Creates a new Raw element with the specified value.
+    # - +value+ [String] string value for the comment
+    def initialize(value)
+      super
+    end
+
+  end # Raw
+end # Ox