ox-bundlecachetest 2.14.23

data/lib/ox/hasattrs.rb

@@ -0,0 +1,54 @@
+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?
+      a_str = attr.to_s
+      a_sym = attr.to_sym
+      if @attributes.has_key?(a_str)
+        attr = a_str
+      elsif @attributes.has_key?(a_sym)
+        attr = a_sym
+      end
+      @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/lib/ox/instruct.rb

@@ -0,0 +1,34 @@
+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
+      return false unless attributes == other.attributes
+      return false unless content == other.content
+
+      true
+    end
+    alias == eql?
+  end # Instruct
+end # Ox

data/lib/ox/node.rb

@@ -0,0 +1,23 @@
+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 == value
+    end
+    alias == eql?
+  end # Node
+end # Ox

data/lib/ox/raw.rb

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

data/lib/ox/sax.rb

@@ -0,0 +1,97 @@
+module Ox
+  # A SAX style parse handler. The Ox::Sax handler class should be subclasses
+  # and then used with the Ox.sax_parse() method. The Sax methods will then be
+  # called as the file is parsed. This is best suited for very large files or
+  # IO streams.<p/>
+  #
+  # *Example*
+  #
+  #  require 'ox'
+  #
+  #  class MySax < ::Ox::Sax
+  #    def initialize()
+  #      @element_names = []
+  #    end
+  #
+  #    def start_element(name)
+  #      @element_names << name
+  #    end
+  #  end
+  #
+  #  any = MySax.new()
+  #  File.open('any.xml', 'r') do |f|
+  #    Ox.sax_parse(any, f)
+  #  end
+  #
+  # To make the desired methods active while parsing the desired method should
+  # be made public in the subclasses. If the methods remain private they will
+  # not be called during parsing. The 'name' argument in the callback methods
+  # will be a Symbol. The 'str' arguments will be a String. The 'value'
+  # arguments will be Ox::Sax::Value objects. Since both the text() and the
+  # value() methods are called for the same element in the XML document the the
+  # text() method is ignored if the value() method is defined or public. The
+  # same is true for attr() and attr_value(). When all attributes have been read
+  # the attr_done() callback will be invoked.
+  #
+  #    def instruct(target); end
+  #    def end_instruct(target); end
+  #    def attr(name, str); end
+  #    def attr_value(name, value); end
+  #    def attrs_done(); end
+  #    def doctype(str); end
+  #    def comment(str); end
+  #    def cdata(str); end
+  #    def text(str); end
+  #    def value(value); end
+  #    def start_element(name); end
+  #    def end_element(name); end
+  #    def error(message, line, column); end
+  #    def abort(name); end
+  #
+  # Initializing _line_ attribute in the initializer will cause that variable to
+  # be updated before each callback with the XML line number. The same is true
+  # for the _column_ attribute but it will be updated with the column in the XML
+  # file that is the start of the element or node just read. @pos if defined
+  # will hold the number of bytes from the start of the document.
+  class Sax
+    # Create a new instance of the Sax handler class.
+    def initialize
+      # @pos = nil
+      # @line = nil
+      # @column = nil
+    end
+
+    # To make the desired methods active while parsing the desired method
+    # should be made public in the subclasses. If the methods remain private
+    # they will not be called during parsing.
+    private
+
+    def instruct(target); end
+
+    def end_instruct(target); end
+
+    def attr(name, str); end
+
+    def attr_value(name, value); end
+
+    def attrs_done; end
+
+    def doctype(str); end
+
+    def comment(str); end
+
+    def cdata(str); end
+
+    def text(str); end
+
+    def value(value); end
+
+    def start_element(name); end
+
+    def end_element(name); end
+
+    def error(message, line, column); end
+
+    def abort(name); end
+  end # Sax
+end # Ox

data/lib/ox/version.rb

@@ -0,0 +1,4 @@
+module Ox
+  # Current version of the module.
+  VERSION = '2.14.23'
+end

data/lib/ox/xmlrpc_adapter.rb

@@ -0,0 +1,33 @@
+require 'ox'
+
+module Ox
+  # This is an alternative parser for the stdlib xmlrpc library. It makes
+  # use of Ox and is based on REXMLStreamParser. To use it set is as the
+  # parser for an XMLRPC client:
+  #
+  #   require 'xmlrpc/client'
+  #   require 'ox/xmlrpc_adapter'
+  #   client = XMLRPC::Client.new2('http://some_server/rpc')
+  #   client.set_parser(Ox::StreamParser.new)
+  class StreamParser < XMLRPC::XMLParser::AbstractStreamParser
+    # Create a new instance.
+    def initialize
+      super
+      @parser_class = OxParser
+    end
+
+    # The SAX wrapper.
+    class OxParser < Ox::Sax
+      include XMLRPC::XMLParser::StreamParserMixin
+
+      alias text character
+      alias end_element endElement
+      alias start_element startElement
+
+      # Initiates the sax parser with the provided string.
+      def parse(str)
+        Ox.sax_parse(self, StringIO.new(str), symbolize: false, convert_special: true)
+      end
+    end
+  end
+end

data/lib/ox.rb

@@ -0,0 +1,79 @@
+# Copyright (c) 2011, Peter Ohler<br>
+# All rights reserved.
+
+#
+# === Description:
+#
+# Ox handles XML documents in two ways. It is a generic XML parser and writer as
+# well as a fast Object / XML marshaller. Ox was written for speed as a
+# replacement for Nokogiri and for Marshal.
+#
+# As an XML parser it is 2 or more times faster than Nokogiri and as a generic
+# XML writer it is 14 times faster than Nokogiri. Of course different files may
+# result in slightly different times.
+#
+# As an Object serializer Ox is 4 times faster than the standard Ruby
+# Marshal.dump(). Ox is 3 times faster than Marshal.load().
+#
+# === Object Dump Sample:
+#
+#   require 'ox'
+#
+#   class Sample
+#     attr_accessor :a, :b, :c
+#
+#     def initialize(a, b, c)
+#       @a = a
+#       @b = b
+#       @c = c
+#     end
+#   end
+#
+#   # Create Object
+#   obj = Sample.new(1, "bee", ['x', :y, 7.0])
+#   # Now dump the Object to an XML String.
+#   xml = Ox.dump(obj)
+#   # Convert the object back into a Sample Object.
+#   obj2 = Ox.parse_obj(xml)
+#
+# === Generic XML Writing and Parsing:
+#
+#   require 'ox'
+#
+#   doc = Ox::Document.new(:version => '1.0')
+#
+#   top = Ox::Element.new('top')
+#   top[:name] = 'sample'
+#   doc << top
+#
+#   mid = Ox::Element.new('middle')
+#   mid[:name] = 'second'
+#   top << mid
+#
+#   bot = Ox::Element.new('bottom')
+#   bot[:name] = 'third'
+#   mid << bot
+#
+#   xml = Ox.dump(doc)
+#   puts xml
+#   doc2 = Ox.parse(xml)
+#   puts "Same? #{doc == doc2}"
+module Ox
+end
+
+require 'ox/version'
+require 'ox/error'
+require 'ox/hasattrs'
+require 'ox/node'
+require 'ox/comment'
+require 'ox/raw'
+require 'ox/instruct'
+require 'ox/cdata'
+require 'ox/doctype'
+require 'ox/element'
+require 'ox/document'
+require 'ox/bag'
+require 'ox/sax'
+
+# C extension
+require 'ox/ox'

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: ox-bundlecachetest
+version: !ruby/object:Gem::Version
+  version: 2.14.23
+platform: ruby
+authors:
+- Peter Ohler
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: "A fast XML parser and object serializer that uses only standard C lib.\n\nOptimized
+  XML (Ox), as the name implies was written to provide speed optimized\nXML handling.
+  It was designed to be an alternative to Nokogiri and other Ruby\nXML parsers for
+  generic XML parsing and as an alternative to Marshal for Object\nserialization. "
+email: peter@ohler.com
+executables: []
+extensions:
+- ext/ox/extconf.rb
+extra_rdoc_files:
+- CHANGELOG.md
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- ext/ox/attr.h
+- ext/ox/base64.c
+- ext/ox/base64.h
+- ext/ox/buf.h
+- ext/ox/builder.c
+- ext/ox/cache.c
+- ext/ox/cache.h
+- ext/ox/cache8.c
+- ext/ox/cache8.h
+- ext/ox/dump.c
+- ext/ox/err.c
+- ext/ox/err.h
+- ext/ox/extconf.rb
+- ext/ox/gen_load.c
+- ext/ox/hash_load.c
+- ext/ox/helper.h
+- ext/ox/intern.c
+- ext/ox/intern.h
+- ext/ox/obj_load.c
+- ext/ox/ox.c
+- ext/ox/ox.h
+- ext/ox/parse.c
+- ext/ox/sax.c
+- ext/ox/sax.h
+- ext/ox/sax_as.c
+- ext/ox/sax_buf.c
+- ext/ox/sax_buf.h
+- ext/ox/sax_hint.c
+- ext/ox/sax_hint.h
+- ext/ox/sax_stack.h
+- ext/ox/slotcache.c
+- ext/ox/slotcache.h
+- ext/ox/special.c
+- ext/ox/special.h
+- ext/ox/type.h
+- lib/ox.rb
+- lib/ox/bag.rb
+- lib/ox/cdata.rb
+- lib/ox/comment.rb
+- lib/ox/doctype.rb
+- lib/ox/document.rb
+- lib/ox/element.rb
+- lib/ox/error.rb
+- lib/ox/hasattrs.rb
+- lib/ox/instruct.rb
+- lib/ox/node.rb
+- lib/ox/raw.rb
+- lib/ox/sax.rb
+- lib/ox/version.rb
+- lib/ox/xmlrpc_adapter.rb
+homepage: http://www.ohler.com/ox
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/ohler55/ox/issues
+  changelog_uri: https://github.com/ohler55/ox/blob/master/CHANGELOG.md
+  documentation_uri: http://www.ohler.com/ox/doc/index.html
+  homepage_uri: http://www.ohler.com/ox/
+  source_code_uri: https://github.com/ohler55/ox
+  rubygems_mfa_required: 'true'
+rdoc_options:
+- "--main"
+- README.md
+- "--title"
+- Ox
+- "--exclude"
+- extconf.rb
+- lib
+- ext/ox
+- README.md
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: A fast XML parser and object serializer.
+test_files: []