rng 0.1.1 → 0.3.3

data/lib/rng/builder.rb

@@ -1,158 +0,0 @@
-module Rng
-  class Builder
-    def build(schema, format:)
-      case format
-      when :rng
-        build_rng(schema)
-      when :rnc
-        build_rnc(schema)
-      else
-        raise ArgumentError, "Unsupported format: #{format}"
-      end
-    end
-
-    private
-
-    def build_rng(schema)
-      doc = Nokogiri::XML::Document.new
-      doc.encoding = "UTF-8"
-
-      if schema.is_a?(Rng::Schema)
-        root = Nokogiri::XML::Node.new("grammar", doc)
-        root["xmlns"] = "http://relaxng.org/ns/structure/1.0"
-        doc.root = root
-
-        start = Nokogiri::XML::Node.new("start", doc)
-        root.add_child(start)
-
-        if schema.start.ref
-          ref = Nokogiri::XML::Node.new("ref", doc)
-          ref["name"] = schema.start.ref
-          start.add_child(ref)
-        end
-
-        schema.start.elements.each do |element|
-          start.add_child(build_rng_element(element, doc))
-        end
-
-        schema.define&.each do |define|
-          define_node = Nokogiri::XML::Node.new("define", doc)
-          define_node["name"] = define.name
-          define.elements.each do |element|
-            define_node.add_child(build_rng_element(element, doc))
-          end
-          root.add_child(define_node)
-        end
-      elsif schema.is_a?(Rng::Element)
-        el = build_rng_element(schema, doc)
-        el["xmlns"] = "http://relaxng.org/ns/structure/1.0"
-        doc.root = el
-      end
-
-      doc.to_xml
-    end
-
-    def build_rng_element(element, doc)
-      if element.zero_or_more&.any?
-        zero_or_more = Nokogiri::XML::Node.new("zeroOrMore", doc)
-        el = Nokogiri::XML::Node.new("element", doc)
-        el["name"] = element.name
-        add_element_content(element, el, doc)
-        zero_or_more.add_child(el)
-        return zero_or_more
-      elsif element.one_or_more&.any?
-        one_or_more = Nokogiri::XML::Node.new("oneOrMore", doc)
-        el = Nokogiri::XML::Node.new("element", doc)
-        el["name"] = element.name
-        add_element_content(element, el, doc)
-        one_or_more.add_child(el)
-        return one_or_more
-      elsif element.optional&.any?
-        optional = Nokogiri::XML::Node.new("optional", doc)
-        el = Nokogiri::XML::Node.new("element", doc)
-        el["name"] = element.name
-        add_element_content(element, el, doc)
-        optional.add_child(el)
-        return optional
-      else
-        el = Nokogiri::XML::Node.new("element", doc)
-        el["name"] = element.name
-        add_element_content(element, el, doc)
-        return el
-      end
-    end
-
-    def add_element_content(element, el, doc)
-      element.attributes&.each do |attr|
-        attr_node = Nokogiri::XML::Node.new("attribute", doc)
-        attr_node["name"] = attr.name
-        if attr.type&.any?
-          data = Nokogiri::XML::Node.new("data", doc)
-          data["type"] = attr.type.first
-          attr_node.add_child(data)
-        else
-          text = Nokogiri::XML::Node.new("text", doc)
-          attr_node.add_child(text)
-        end
-        el.add_child(attr_node)
-      end
-
-      element.elements&.each do |child|
-        el.add_child(build_rng_element(child, doc))
-      end
-
-      if element.text
-        text = Nokogiri::XML::Node.new("text", doc)
-        el.add_child(text)
-      end
-    end
-
-    def build_rnc(schema)
-      result = ""
-      elements = schema.is_a?(Rng::Schema) ? schema.start.elements : [schema]
-      elements.each do |element|
-        result += build_rnc_element(element)
-      end
-      result
-    end
-
-    def build_rnc_element(element, indent = 0)
-      return "" unless element # Handle nil elements
-
-      result = "  " * indent
-      result += "element #{element.name} {\n"
-
-      element.attributes&.each do |attr|
-        result += "  " * (indent + 1)
-        result += "attribute #{attr.name} { text }"
-        result += ",\n" unless element.attributes.last == attr && !element.elements&.any? && !element.text
-      end
-
-      element.elements&.each_with_index do |child, index|
-        child_result = build_rnc_element(child, indent + 1)
-        result += child_result
-        result += "," unless index == element.elements.size - 1 && !element.text
-        result += "\n"
-      end
-
-      if element.text
-        result += "  " * (indent + 1)
-        result += "text"
-        result += "\n"
-      end
-
-      result += "  " * indent
-      result += "}"
-
-      if element.zero_or_more&.any?
-        result += "*"
-      elsif element.one_or_more&.any?
-        result += "+"
-      elsif element.optional&.any?
-        result += "?"
-      end
-
-      result
-    end
-  end
-end

data/lib/rng/rng_parser.rb

@@ -1,107 +0,0 @@
-require "nokogiri"
-require_relative "schema"
-require_relative "element"
-
-module Rng
-  class RngParser
-    RELAXNG_NS = "http://relaxng.org/ns/structure/1.0"
-
-    def parse(input)
-      doc = Nokogiri::XML(input)
-      doc.remove_namespaces! # This simplifies namespace handling
-
-      root = doc.root
-      case root.name
-      when "grammar"
-        parse_grammar(doc)
-      when "element"
-        parse_element(doc)
-      else
-        raise Rng::Error, "Unexpected root element: #{root.name}"
-      end
-    end
-
-    private
-
-    def parse_grammar(doc)
-      Schema.new(
-        start: parse_start(doc.at_xpath("//start")),
-        define: doc.xpath("//define").map { |define| parse_define(define) },
-      )
-    end
-
-    def parse_start(node)
-      return nil unless node
-
-      Start.new(
-        ref: node.at_xpath(".//ref")&.attr("name"),
-        elements: node.xpath(".//element").map { |element| parse_element(element) },
-      )
-    end
-
-    def parse_define(node)
-      Define.new(
-        name: node["name"],
-        elements: node.xpath(".//element").map { |element| parse_element(element) },
-      )
-    end
-
-    def parse_element(node)
-      return nil unless node["name"]
-
-      element = Element.new(
-        name: node["name"],
-        attributes: [],
-        elements: [],
-        text: false,
-      )
-
-      node.children.each do |child|
-        parse_child(child, element)
-      end
-
-      element
-    end
-
-    def parse_child(node, element)
-      case node.name
-      when "attribute"
-        element.attributes << parse_attribute(node)
-      when "element"
-        element.elements << parse_element(node)
-      when "text"
-        element.text = true
-      when "zeroOrMore"
-        parse_zero_or_more(node).each { |el| element.zero_or_more << el }
-      when "oneOrMore"
-        parse_one_or_more(node).each { |el| element.one_or_more << el }
-      when "optional"
-        parse_optional(node).each { |el| element.optional << el }
-      end
-    end
-
-    def parse_attribute(node)
-      data_node = node.at_xpath(".//data")
-      Attribute.new(
-        name: node["name"],
-        type: data_node ? [data_node["type"]] : ["string"],
-      )
-    end
-
-    def parse_zero_or_more(node)
-      node.xpath("./element").map { |el| parse_element(el) }
-    end
-
-    def parse_one_or_more(node)
-      node.xpath("./element").map { |el| parse_element(el) }
-    end
-
-    def parse_optional(node)
-      node.xpath("./element").map { |el| parse_element(el) }
-    end
-
-    def parse_choice(node)
-      node.xpath(".//choice/element").map { |el| parse_element(el) }
-    end
-  end
-end

data/lib/rng/schema.rb

@@ -1,18 +0,0 @@
-require "lutaml/model"
-require_relative "start"
-require_relative "define"
-
-module Rng
-  class Schema < Lutaml::Model::Serializable
-    attribute :start, Start
-    attribute :define, Define, collection: true
-
-    xml do
-      root "grammar"
-      namespace "http://relaxng.org/ns/structure/1.0"
-
-      map_element "start", to: :start
-      map_element "define", to: :define
-    end
-  end
-end

data/spec/rng/rng_parser_spec.rb

@@ -1,102 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Rng::RngParser do
-  let(:parser) { described_class.new }
-
-  describe "#parse" do
-    context "with a simple RNG schema" do
-      let(:input) do
-        <<~RNG
-          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
-            <start>
-              <element name="addressBook">
-                <zeroOrMore>
-                  <element name="card">
-                    <element name="name">
-                      <text/>
-                    </element>
-                    <element name="email">
-                      <text/>
-                    </element>
-                  </element>
-                </zeroOrMore>
-              </element>
-            </start>
-          </grammar>
-        RNG
-      end
-
-      it "correctly parses the schema" do
-        result = parser.parse(input)
-        expect(result).to be_a(Rng::Schema)
-        expect(result.start.elements.first.name).to eq("addressBook")
-        expect(result.start.elements.first.zero_or_more.first.name).to eq("card")
-        expect(result.start.elements.first.zero_or_more.first.elements.map(&:name)).to eq(["name", "email"])
-      end
-    end
-
-    context "with a complex RNG schema" do
-      let(:input) do
-        <<~RNG
-          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
-            <start>
-              <ref name="addressBook"/>
-            </start>
-            <define name="addressBook">
-              <element name="addressBook">
-                <zeroOrMore>
-                  <element name="card">
-                    <element name="name">
-                      <text/>
-                    </element>
-                    <element name="email">
-                      <text/>
-                    </element>
-                    <optional>
-                      <element name="note">
-                        <text/>
-                      </element>
-                    </optional>
-                  </element>
-                </zeroOrMore>
-              </element>
-            </define>
-          </grammar>
-        RNG
-      end
-
-      it "correctly parses the schema" do
-        result = parser.parse(input)
-        expect(result).to be_a(Rng::Schema)
-        expect(result.start.ref).to eq("addressBook")
-        expect(result.define.first.name).to eq("addressBook")
-        expect(result.define.first.elements.first.name).to eq("addressBook")
-      end
-    end
-
-    context "with attributes" do
-      let(:input) do
-        <<~RNG
-          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
-            <start>
-              <element name="person">
-                <attribute name="id">
-                  <data type="ID"/>
-                </attribute>
-                <element name="name">
-                  <text/>
-                </element>
-              </element>
-            </start>
-          </grammar>
-        RNG
-      end
-
-      it "correctly parses attributes" do
-        result = parser.parse(input)
-        expect(result.start.elements.first.attributes.first.name).to eq("id")
-        expect(result.start.elements.first.attributes.first.type).to eq(["ID"])
-      end
-    end
-  end
-end