xsd_struct 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1c1c5f92fb6a7e7b8b6200de5ab3af4b28b6c53deac97d3d7afe1320fe6eb33b
+  data.tar.gz: f9463188c81bb62633693623c552ecbf96dddca1f6cd8257a12276da4a8b0b69
+SHA512:
+  metadata.gz: 9ec4efce2cb37f56222a6f3ae26fd0615447506b16e768877aa1dec95be1d078fe1c885101e0fb228a31082f508bff4f3ec4dde11076f1ead56bd643c15e7a9f
+  data.tar.gz: 68568be909b88169c0006ce36bfd900f5538319c144e0a456287cf72abc6cb5d26528221e3818c1a24442547a886f7ce32301351fbb8fa8665000f9ea60eba87

data/AI_POLICY.md

@@ -0,0 +1,5 @@
+# AI / LLMs Policy
+
+An interactions - whether they be code, issues or documentation - must be entirely written by humans.
+
+For reasons as to why LLM tools are not welcome here, a good starting point is https://whynoai.info.

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-10-31
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,89 @@
+# Contributor Covenant 3.0 Code of Conduct
+
+## Our Pledge
+
+We pledge to make our community welcoming, safe, and equitable for all.
+
+We are committed to fostering an environment that respects and promotes the dignity, rights, and contributions of all individuals, regardless of characteristics including race, ethnicity, caste, colour, age, physical characteristics, neurodiversity, disability, sex or gender, gender identity or expression, sexual orientation, language, philosophy or religion, national or social origin, socio-economic position, level of education, or other status. The same privileges of participation are extended to everyone who participates in good faith and in accordance with this Covenant.
+
+
+## Encouraged Behaviours
+
+While acknowledging differences in social norms, we all strive to meet our community's expectations for positive behaviour. We also understand that our words and actions may be interpreted differently than we intend based on culture, background, or native language.
+
+With these considerations in mind, we agree to behave mindfully toward each other and act in ways that centre our shared values, including:
+
+1. Respecting the **purpose of our community**, our activities, and our ways of gathering.
+2. Engaging **kindly and honestly** with others.
+3. Respecting **different viewpoints** and experiences.
+4. **Taking responsibility** for our actions and contributions.
+5. Gracefully giving and accepting **constructive feedback**.
+6. Committing to **repairing harm** when it occurs.
+7. Behaving in other ways that promote and sustain the **well-being of our community**.
+
+
+## Restricted Behaviours
+
+We agree to restrict the following behaviours in our community. Instances, threats, and promotion of these behaviours are violations of this Code of Conduct.
+
+1. **Harassment.** Violating explicitly expressed boundaries or engaging in unnecessary personal attention after any clear request to stop.
+2. **Character attacks.** Making insulting, demeaning, or pejorative comments directed at a community member or group of people.
+3. **Stereotyping or discrimination.** Characterising anyone’s personality or behaviour on the basis of immutable identities or traits.
+4. **Sexualization.** Behaving in a way that would generally be considered inappropriately intimate in the context or purpose of the community.
+5. **Violating confidentiality**. Sharing or acting on someone's personal or private information without their permission.
+6. **Endangerment.** Causing, encouraging, or threatening violence or other harm toward any person or group.
+7. Behaving in other ways that **threaten the well-being** of our community.
+
+### Other Restrictions
+
+1. **Misleading identity.** Impersonating someone else for any reason, or pretending to be someone else to evade enforcement actions.
+2. **Failing to credit sources.** Not properly crediting the sources of content you contribute.
+3. **Promotional materials**. Sharing marketing or other commercial content in a way that is outside the norms of the community.
+4. **Irresponsible communication.** Failing to responsibly present content which includes, links or describes any other restricted behaviours.
+
+
+## Reporting an Issue
+
+Tensions can occur between community members even when they are trying their best to collaborate. Not every conflict represents a code of conduct violation, and this Code of Conduct reinforces encouraged behaviours and norms that can help avoid conflicts and minimise harm.
+
+When an incident does occur, it is important to report it promptly. To report a possible violation, please email pat@freelancing-gods.com.
+
+Community Moderators take reports of violations seriously and will make every effort to respond in a timely manner. They will investigate all reports of code of conduct violations, reviewing messages, logs, and recordings, or interviewing witnesses and other participants. Community Moderators will keep investigation and enforcement actions as transparent as possible while prioritising safety and confidentiality. In order to honour these values, enforcement actions are carried out in private with the involved parties, but communicating to the whole community may be part of a mutually agreed upon resolution.
+
+
+## Addressing and Repairing Harm
+
+If an investigation by the Community Moderators finds that this Code of Conduct has been violated, the following enforcement ladder may be used to determine how best to repair harm, based on the incident's impact on the individuals involved and the community as a whole. Depending on the severity of a violation, lower rungs on the ladder may be skipped.
+
+1) Warning
+   1) Event: A violation involving a single incident or series of incidents.
+   2) Consequence: A private, written warning from the Community Moderators.
+   3) Repair: Examples of repair include a private written apology, acknowledgement of responsibility, and seeking clarification on expectations.
+2) Temporarily Limited Activities
+   1) Event: A repeated incidence of a violation that previously resulted in a warning, or the first incidence of a more serious violation.
+   2) Consequence: A private, written warning with a time-limited cooldown period designed to underscore the seriousness of the situation and give the community members involved time to process the incident. The cooldown period may be limited to particular communication channels or interactions with particular community members.
+   3) Repair: Examples of repair may include making an apology, using the cooldown period to reflect on actions and impact, and being thoughtful about re-entering community spaces after the period is over.
+3) Temporary Suspension
+   1) Event: A pattern of repeated violation which the Community Moderators have tried to address with warnings, or a single serious violation.
+   2) Consequence: A private written warning with conditions for return from suspension. In general, temporary suspensions give the person being suspended time to reflect upon their behaviour and possible corrective actions.
+   3) Repair: Examples of repair include respecting the spirit of the suspension, meeting the specified conditions for return, and being thoughtful about how to reintegrate with the community when the suspension is lifted.
+4) Permanent Ban
+   1) Event: A pattern of repeated code of conduct violations that other steps on the ladder have failed to resolve, or a violation so serious that the Community Moderators determine there is no way to keep the community safe with this person as a member.
+   2) Consequence: Access to all community spaces, tools, and communication channels is removed. In general, permanent bans should be rarely used, should have strong reasoning behind them, and should only be resorted to if working through other remedies has failed to change the behaviour.
+   3) Repair: There is no possible repair in cases of this severity.
+
+This enforcement ladder is intended as a guideline. It does not limit the ability of Community Managers to use their discretion and judgment, in keeping with the best interests of our community.
+
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public or other spaces. Examples of representing our community include using an official email address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+
+## Attribution
+
+This Code of Conduct is adapted from the Contributor Covenant, version 3.0, permanently available at [https://www.contributor-covenant.org/version/3/0/](https://www.contributor-covenant.org/version/3/0/).
+
+Contributor Covenant is stewarded by the Organization for Ethical Source and licensed under CC BY-SA 4.0. To view a copy of this license, visit [https://creativecommons.org/licenses/by-sa/4.0/](https://creativecommons.org/licenses/by-sa/4.0/)
+
+For answers to common questions about Contributor Covenant, see the FAQ at [https://www.contributor-covenant.org/faq](https://www.contributor-covenant.org/faq). Translations are provided at [https://www.contributor-covenant.org/translations](https://www.contributor-covenant.org/translations). Additional enforcement and community guideline resources can be found at [https://www.contributor-covenant.org/resources](https://www.contributor-covenant.org/resources). The enforcement ladder was inspired by the work of [Mozilla’s code of conduct team](https://github.com/mozilla/inclusion).

data/LICENSE.txt

@@ -0,0 +1,17 @@
+MIT NON-AI License
+
+Copyright (c) 2026, Pat Allan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of the software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions.
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+In addition, the following restrictions apply:
+
+1. The Software and any modifications made to it may not be used for the purpose of training or improving machine learning algorithms, including but not limited to artificial intelligence, natural language processing, or data mining. This condition applies to any derivatives, modifications, or updates based on the Software code. Any usage of the Software in an AI-training dataset is considered a breach of this License.
+
+2. The Software may not be included in any dataset used for training or improving machine learning algorithms, including but not limited to artificial intelligence, natural language processing, or data mining.
+
+3. Any person or organisation found to be in violation of these restrictions will be subject to legal action and may be held liable for any damages resulting from such use.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+# XSD Struct
+
+Take an XSD schema and turn XML documents following that schema into Ruby object trees.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add xsd_struct
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install xsd_struct
+```
+
+## Usage
+
+To load a new schema in, you can either refer to the raw string XSD (which is itself an XML document):
+
+```ruby
+ schema = XSDStruct::Schema.new(
+  "<?xml version="1.0" encoding="UTF-8" ?> ..."
+)
+```
+
+Or, you can load the schema from a file. This has the additional benefit that the schema can refer to other files to build out its full understanding.
+
+```ruby
+schema = XSDStruct::Schema.from_path("./path/to/schema.xsd")
+```
+
+It's also possible to refer to a gzipped schema, which is useful when the schema files are extremely large:
+
+```ruby
+schema = XSDStruct::Schema.from_path(
+  "./path/to/schema.gz", gzip: true
+)
+```
+
+Once a schema is loaded, then you can pass in the raw string of an XML document which conforms to that schema, to retrieve an object tree representing the document. It responds to methods matching any root element names, downcased and underscored to match usual Ruby naming styles. So, as a contrived example:
+
+```ruby
+document = schema.build("<Page><Item id="7" /></Page>")
+# presuming a page may have many items:
+document.page.items.first.id #=> 7
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on Codeberg at https://codeberg.org/patallan/xsd_struct. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://codeberg.org/patallan/xsd_struct/src/branch/main/CODE_OF_CONDUCT.md) and [AI/LLMs policy](https://codeberg.org/patallan/xsd_struct/src/branch/main/AI_POLICY.md).
+
+## License
+
+The gem is available as open source under the terms of a [modified MIT License](https://codeberg.org/patallan/xsd_struct/src/branch/main/LICENSE.txt) - mostly the same, but cannot be used for training/improving machine learning algorithms (AI/LLMs) directly or indirectly.
+
+## Code of Conduct
+
+Everyone interacting in the xsd_struct project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://codeberg.org/patallan/xsd_struct/src/branch/main/CODE_OF_CONDUCT.md).

data/lib/xsd_struct/attribute_method.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "attribute_valuer"
+
+module XSDStruct
+  # Appends a method to an element subclass for a given attribute. The method
+  # name will be the attribute's name, but translated to idiomatic Ruby - so,
+  # downcased and underscored.
+  #
+  class AttributeMethod
+    def self.call(...)
+      new(...).call
+    end
+
+    def initialize(klass, attribute)
+      @klass = klass
+      @attribute = attribute
+    end
+
+    def call
+      valuer = AttributeValuer.new(attribute)
+      name = valuer.accessor_name
+
+      klass.define_method(name) do
+        attributes[name] ||= valuer.call(node)
+      end
+    end
+
+    private
+
+    attr_reader :klass, :attribute
+  end
+end

data/lib/xsd_struct/attribute_valuer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module XSDStruct
+  # Generates a attribute's value for a given element.
+  #
+  class AttributeValuer
+    def initialize(attribute)
+      @attribute = attribute
+    end
+
+    def call(parent)
+      parent.attributes[attribute.name].value
+    end
+
+    def accessor_name
+      XSDStruct.inflector.underscore(attribute.name)
+    end
+
+    private
+
+    attr_reader :attribute
+  end
+end

data/lib/xsd_struct/cache.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+require_relative "element"
+
+module XSDStruct
+  # XSDStruct::Cache maintains a known list of Element classes, representing
+  # each element in the given XSD document reader.
+  #
+  # The cache is lazily loaded, meaning that only elements that are traversed
+  # are generated.
+  class Cache
+    def initialize(reader)
+      @reader = reader
+      @cache = {}
+    end
+
+    def [](tree)
+      cache.fetch(tree) do
+        Element.generate(definition(tree), self, tree)
+      end
+    end
+
+    private
+
+    attr_reader :reader, :cache
+
+    def definition(tree)
+      tree.inject(reader) { |parent, name| parent[name] } || reader[tree.last]
+    end
+  end
+end

data/lib/xsd_struct/document.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "element_method"
+
+module XSDStruct
+  # XSDStruct::Document represents the root of an XML document that has been
+  # parsed according to a given XSD schema.
+  #
+  # It responds to methods matching any root element names, downcased and
+  # underscored to match usual Ruby naming styles. So, for example:
+  #
+  #   document = schema.build("<Page><Item id="7" /></Page>")
+  #   # presuming a page may have many items:
+  #   document.page.items.first.id #=> 7
+  #
+  class Document
+    def self.generate(xsd, cache)
+      klass = Class.new(Document)
+
+      xsd.elements.each do |element|
+        ElementMethod.call(klass, element, cache, [])
+      end
+
+      klass
+    end
+
+    def initialize(node)
+      @node = node
+      @elements = {}
+    end
+
+    private
+
+    attr_reader :node, :elements
+  end
+end

data/lib/xsd_struct/element.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+
+require_relative "attribute_method"
+require_relative "element_method"
+
+module XSDStruct
+  # Represents an element/node in an XML object tree. Attributes and inner
+  # elements can be accessed via methods (downcased, underscored, and pluralised
+  # where appropriate).
+  #
+  # If this element does not have any attributes or inner/sub-elements, then
+  # the value can be returned directly - and will be typed beyond raw strings if
+  # possible.
+  #
+  class Element
+    def self.generate(xsd, cache, tree)
+      klass = Class.new(Element)
+
+      xsd.collect_attributes.each do |attribute|
+        AttributeMethod.call(klass, attribute)
+      end
+
+      xsd.collect_elements.each do |element|
+        ElementMethod.call(klass, element, cache, tree)
+      end
+
+      klass
+    end
+
+    def initialize(node, schema)
+      @node = node
+      @schema = schema
+      @attributes = {}
+      @elements = {}
+    end
+
+    def value
+      case schema.data_type
+      when "positiveInteger"
+        node.text.to_i
+      when "decimal"
+        node.text.to_f
+      else
+        node.text
+      end
+    end
+
+    def value_or_self
+      direct? ? value : self
+    end
+
+    private
+
+    attr_reader :node, :schema, :attributes, :elements
+
+    def direct?
+      schema.collect_elements.empty? && schema.collect_attributes.empty?
+    end
+  end
+end

data/lib/xsd_struct/element_method.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "element_valuer"
+
+module XSDStruct
+  # Appends a method to an element subclass for a given sub-element. The method
+  # name will be the sub-element's name, but translated to idiomatic Ruby - so,
+  # downcased and underscored - and will also be plural if multiple instances of
+  # the sub-element are allowed.
+  #
+  class ElementMethod
+    def self.call(...)
+      new(...).call
+    end
+
+    def initialize(klass, element, cache, tree)
+      @klass = klass
+      @element = element
+      @cache = cache
+      @tree = tree
+    end
+
+    def call
+      valuer = ElementValuer.new(element, cache, tree)
+      name = valuer.accessor_name
+
+      klass.define_method(name) do
+        elements[name] ||= valuer.call(node)
+      end
+    end
+
+    private
+
+    attr_reader :klass, :element, :cache, :tree
+  end
+end

data/lib/xsd_struct/element_valuer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module XSDStruct
+  # Generates a sub-element's value for a given parent. In the situation where
+  # the parent can have multiple sub-elements of the same type, this will return
+  # an array, but otherwise a single value.
+  #
+  # If the element has no possible children or attributes, then the raw text of
+  # that element is instead returned, typed accordingly where possible.
+  #
+  class ElementValuer
+    def initialize(element, cache, parent_tree)
+      @element = element
+      @cache = cache
+      @tree = parent_tree + [element.name]
+    end
+
+    def call(parent)
+      values = parent
+               .children
+               .select { |child| child.name == element.name }
+               .collect { |child| cache[tree].new(child, element).value_or_self }
+
+      element.multiple_allowed? ? values : values.first
+    end
+
+    def accessor_name
+      if element.multiple_allowed?
+        XSDStruct.inflector.pluralize(XSDStruct.inflector.underscore(element.name))
+      else
+        XSDStruct.inflector.underscore(element.name)
+      end
+    end
+
+    private
+
+    attr_reader :element, :cache, :tree
+  end
+end

data/lib/xsd_struct/schema.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "xsd"
+require "zlib"
+
+require_relative "cache"
+require_relative "document"
+
+module XSDStruct
+  # XSDStruct::Schema performs the initial parsing of a raw XSD string, which
+  # can then in turn be used to generate object trees from an XML document that
+  # conforms to the schema.
+  #
+  # To load a new schema in, you can either refer to the raw string XSD (which
+  # is itself an XML document):
+  #
+  #   schema = XSDStruct::Schema.new(
+  #     "<<?xml version="1.0" encoding="UTF-8" ?> ..."
+  #   )
+  #
+  # Or, you can load the schema from a file. This has the additional benefit
+  # that the schema can refer to other files to build out its full
+  # understanding.
+  #
+  #   schema = XSDStruct::Schema.from_path("./path/to/schema.xsd")
+  #
+  # It's also possible to refer to a gzipped schema, which is useful when the
+  # schema files are extremely large:
+  #
+  #   schema = XSDStruct::Schema.from_path(
+  #     "./path/to/schema.gz", gzip: true
+  #   )
+  #
+  # Once a schema is loaded, then you can pass in the raw string of an XML
+  # document which conforms to that schema, to retrieve an object tree
+  # representing the document:
+  #
+  #   document = schema.build("<?xml version="1.0" encoding="UTF-8" ?> ...")
+  #
+  # This document is an instance of XSDStruct::Document.
+  #
+  class Schema
+    def self.from_path(path, gzip: false)
+      raw = gzip ? Zlib::Inflate.inflate(File.binread(path)) : File.read(path)
+
+      new(raw, location: path)
+    end
+
+    def initialize(raw, location: nil)
+      @raw = raw
+      @location = location
+    end
+
+    def build(raw)
+      XSDStruct::Document
+        .generate(reader, cache)
+        .new(Nokogiri::XML(raw))
+    end
+
+    private
+
+    attr_reader :raw, :location
+
+    def cache
+      @cache ||= XSDStruct::Cache.new(reader)
+    end
+
+    def reader
+      @reader ||= XSD::XML.new.tap do |xml_reader|
+        xml_reader.add_schema_xml(raw, location:)
+      end
+    end
+  end
+end

data/lib/xsd_struct.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "nokogiri"
+
+# XSDStruct transforms XML documents into object trees, based on a schema
+# defined by an XSD document.
+#
+# See XSDStruct::Schema for usage.
+#
+module XSDStruct
+  def self.inflector
+    @inflector ||= Dry::Inflector.new
+  end
+end
+
+require_relative "xsd_struct/schema"

data/sig/xsd_struct.rbs

@@ -0,0 +1,52 @@
+module XSDStruct
+  type elementValue = (XSDStruct::Element | String | Integer | Float)
+
+  def self.inflector: () -> Dry::Inflector
+
+  class AttributeMethod
+    def self.call: (::Class klass, XSD::Attribute attribute) -> ::Symbol
+    def initialize: (::Class klass, XSD::Attribute attribute) -> void
+    def call: () -> ::Symbol
+  end
+
+  class AttributeValuer
+    def initialize: (XSD::Attribute attribute) -> void
+    def call: (untyped parent) -> String
+    def accessor_name: () -> String
+  end
+
+  class Cache
+    def initialize: (XSD::XML reader) -> void
+    def []: (Array[String] tree) -> Class
+  end
+
+  class Document
+    def self.generate: (XSD::XML xsd, XSDStruct::Cache cache) -> Class
+    def initialize: (Nokogiri::XML::Document node) -> void
+  end
+
+  class ElementMethod
+    def self.call: (Class klass, XSD::Element element, XSDStruct::Cache cache, Array[String] tree) -> Symbol
+    def initialize: (Class klass, XSD::Element element, XSDStruct::Cache cache, Array[String] tree) -> void
+    def call: () -> Symbol
+  end
+
+  class ElementValuer
+    def initialize: (XSD::Element element, XSDStruct::Cache cache, Array[String] parent_tree) -> void
+    def call: (untyped parent) -> (elementValue | Array[elementValue] | nil)
+    def accessor_name: () -> String
+  end
+
+  class Element
+    def self.generate: (XSD::Element xsd, XSDStruct::Cache cache, Array[String] tree) -> Class
+    def initialize: (Nokogiri::XML::Node node, XSD::Element schema) -> void
+    def value: () -> (String | Integer | Float)
+    def value_or_self: () -> elementValue
+  end
+
+  class Schema
+    def self.from_path: (String path, ?gzip: bool) -> XSDStruct::Schema
+    def initialize: (String raw, ?location: (nil | String)) -> void
+    def build: (String raw) -> XSDStruct::Document
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: xsd_struct
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Pat Allan
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.19'
+- !ruby/object:Gem::Dependency
+  name: xsd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: zlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Uses XSD schemas to turn an XML document into a collection of Ruby objects
+email:
+- pat@freelancing-gods.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AI_POLICY.md
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- lib/xsd_struct.rb
+- lib/xsd_struct/attribute_method.rb
+- lib/xsd_struct/attribute_valuer.rb
+- lib/xsd_struct/cache.rb
+- lib/xsd_struct/document.rb
+- lib/xsd_struct/element.rb
+- lib/xsd_struct/element_method.rb
+- lib/xsd_struct/element_valuer.rb
+- lib/xsd_struct/schema.rb
+- sig/xsd_struct.rbs
+homepage: https://codeberg.org/patallan/xsd_struct
+licenses:
+- MIT NON-AI
+metadata:
+  homepage_uri: https://codeberg.org/patallan/xsd_struct
+  source_code_uri: https://codeberg.org/patallan/xsd_struct
+  changelog_uri: https://codeberg.org/patallan/xsd_struct/src/branch/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Combine XSD and XML documents to build Ruby object trees
+test_files: []