xaiml 0.1.3 → 0.1.4

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

@@ -1,39 +0,0 @@
-/* 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

@@ -1,99 +0,0 @@
-
-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

@@ -1,12 +0,0 @@
-
-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

@@ -1,13 +0,0 @@
-
-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

@@ -1,13 +0,0 @@
-
-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

@@ -1,30 +0,0 @@
-
-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

@@ -1,319 +0,0 @@
-
-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

@@ -1,24 +0,0 @@
-
-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

@@ -1,48 +0,0 @@
-
-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

@@ -1,36 +0,0 @@
-
-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

@@ -1,24 +0,0 @@
-
-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

@@ -1,14 +0,0 @@
-
-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