rng 0.1.1 → 0.1.2

data/lib/rng/rnc_parser.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "parslet"
-require_relative "schema"
+require "nokogiri"
+require_relative "grammar"
 
 module Rng
   class RncParser < Parslet::Parser
@@ -12,125 +15,379 @@ module Rng
     rule(:comma?) { (whitespace >> comma >> whitespace).maybe }
 
     rule(:identifier) { match("[a-zA-Z0-9_]").repeat(1).as(:identifier) }
+    rule(:namespace_prefix) { identifier.as(:prefix) >> str(":") }
+    rule(:namespace_prefix?) { namespace_prefix.maybe }
+    rule(:qualified_name) { namespace_prefix? >> identifier.as(:local_name) }
+
+    rule(:datatype_library) { str("datatypes") >> space >> identifier.as(:prefix) >> space >> string_literal.as(:uri) }
 
-    rule(:element_def) {
+    rule(:string_literal) { str('"') >> match('[^"]').repeat.as(:string) >> str('"') }
+
+    rule(:element_def) do
       str("element") >> space >>
-      identifier >>
-      whitespace >>
-      str("{") >>
-      whitespace >>
-      content.maybe.as(:content) >>
-      whitespace >>
-      str("}") >>
-      (str("*") | str("+") | str("?")).maybe.as(:occurrence)
-    }
+        qualified_name.as(:name) >>
+        whitespace >>
+        str("{") >>
+        whitespace >>
+        content.maybe.as(:content) >>
+        whitespace >>
+        str("}") >>
+        (str("*") | str("+") | str("?")).maybe.as(:occurrence)
+    end
 
-    rule(:attribute_def) {
+    rule(:attribute_def) do
       str("attribute") >> space >>
-      identifier.as(:name) >>
-      whitespace >>
-      str("{") >>
-      whitespace >>
-      (str("text")).as(:type) >>
-      whitespace >>
-      str("}")
-    }
+        qualified_name.as(:name) >>
+        whitespace >>
+        str("{") >>
+        whitespace >>
+        (datatype_ref | str("text")).as(:type) >>
+        whitespace >>
+        str("}")
+    end
+
+    rule(:datatype_ref) do
+      identifier.as(:prefix) >> str(":") >> identifier.as(:type)
+    end
 
     rule(:text_def) { str("text").as(:text) }
+    rule(:empty_def) { str("empty").as(:empty) }
 
-    rule(:content_item) {
-      ((element_def | attribute_def | text_def).as(:item) >> comma?).repeat(1).as(:items)
-    }
+    rule(:group_def) do
+      str("(") >>
+        whitespace >>
+        content.as(:group) >>
+        whitespace >>
+        str(")") >>
+        (str("*") | str("+") | str("?")).maybe.as(:occurrence)
+    end
+
+    rule(:choice_def) do
+      content_item.as(:first) >>
+        (whitespace >> str("|") >> whitespace >> content_item.as(:second)).repeat(1).as(:rest)
+    end
 
-    rule(:content) { content_item }
+    rule(:named_pattern) do
+      identifier.as(:name) >> whitespace >> str("=") >> whitespace >> content_item.as(:pattern)
+    end
 
-    rule(:grammar) { whitespace >> element_def.as(:element) >> whitespace }
+    rule(:content_item) do
+      element_def | attribute_def | text_def | empty_def | group_def | choice_def | identifier.as(:ref)
+    end
+
+    rule(:content) do
+      (content_item >> (comma? >> content_item).repeat).as(:items)
+    end
+
+    rule(:start_def) do
+      str("start") >> whitespace >> str("=") >> whitespace >> content_item.as(:start)
+    end
+
+    rule(:grammar) do
+      whitespace >>
+        datatype_library.maybe.as(:datatype_library) >>
+        whitespace >>
+        (start_def | named_pattern | element_def).as(:root) >>
+        (whitespace >> (named_pattern | element_def)).repeat.as(:definitions) >>
+        whitespace
+    end
 
     root(:grammar)
 
-    def parse(input)
-      tree = super(input.strip)
-      build_schema(tree)
+    def self.parse(input)
+      parser = new
+      tree = parser.parse(input.strip)
+      convert_to_rng(tree)
     end
 
-    private
+    def self.to_rnc(schema)
+      # Convert RNG schema to RNC
+      builder = RncBuilder.new
+      builder.build(schema)
+    end
+
+    def self.convert_to_rng(tree)
+      builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+        if tree[:root].key?(:start)
+          # This is a grammar with named patterns
+          xml.grammar(xmlns: "http://relaxng.org/ns/structure/1.0") do
+            # Add datatype library if present
+            xml.datatypeLibrary tree[:datatype_library][:uri][:string].to_s if tree[:datatype_library]
+
+            # Process start pattern
+            xml.start do
+              process_content_item(xml, tree[:root][:start])
+            end
+
+            # Process named patterns
+            tree[:definitions]&.each do |def_item|
+              next unless def_item.key?(:name)
+
+              xml.define(name: def_item[:name][:identifier].to_s) do
+                process_content_item(xml, def_item[:pattern])
+              end
+            end
+          end
+        else
+          # This is a simple element pattern
+          process_content_item(xml, tree[:root])
+        end
+      end
+
+      builder.to_xml
+    end
+
+    def self.process_content_item(xml, item)
+      if item.key?(:name)
+        # Element definition
+        attrs = {}
+        attrs[:name] = item[:name][:local_name][:identifier].to_s
+
+        attrs[:ns] = item[:name][:prefix][:identifier].to_s if item[:name][:prefix]
+
+        xml.element(attrs) do
+          if item[:content]
+            item[:content][:items].each do |content_item|
+              process_content_item(xml, content_item)
+            end
+          end
+        end
+
+        # Handle occurrence
+        if item[:occurrence]
+          case item[:occurrence].to_s
+          when "*"
+            xml.parent.name = "zeroOrMore"
+          when "+"
+            xml.parent.name = "oneOrMore"
+          when "?"
+            xml.parent.name = "optional"
+          end
+        end
+      elsif item.key?(:attr_name)
+        # Attribute definition
+        attrs = {}
+        attrs[:name] = item[:attr_name][:local_name][:identifier].to_s
+
+        attrs[:ns] = item[:attr_name][:prefix][:identifier].to_s if item[:attr_name][:prefix]
+
+        xml.attribute(attrs) do
+          if item[:type] == "text"
+            xml.text
+          elsif item[:type].key?(:prefix)
+            xml.data(type: item[:type][:type][:identifier].to_s,
+                     datatypeLibrary: "http://www.w3.org/2001/XMLSchema-datatypes")
+          end
+        end
+      elsif item.key?(:text)
+        xml.text
+      elsif item.key?(:empty)
+        xml.empty
+      elsif item.key?(:group)
+        xml.group do
+          item[:group][:items].each do |group_item|
+            process_content_item(xml, group_item)
+          end
+        end
+
+        # Handle occurrence
+        if item[:occurrence]
+          case item[:occurrence].to_s
+          when "*"
+            xml.parent.name = "zeroOrMore"
+          when "+"
+            xml.parent.name = "oneOrMore"
+          when "?"
+            xml.parent.name = "optional"
+          end
+        end
+      elsif item.key?(:first) && item.key?(:rest)
+        # Choice definition
+        xml.choice do
+          process_content_item(xml, item[:first])
+          item[:rest].each do |choice_item|
+            process_content_item(xml, choice_item[:second])
+          end
+        end
+      elsif item.key?(:ref)
+        # Reference to a named pattern
+        xml.ref(name: item[:ref][:identifier].to_s)
+      end
+    end
+  end
+
+  class RncBuilder
+    def build(schema)
+      if schema.element
+        # Simple element pattern
+        build_element(schema.element)
+      else
+        # Grammar with named patterns
+        result = []
+
+        # Add datatype library if present
+        if schema.datatypeLibrary
+          result << "datatypes xsd = \"#{schema.datatypeLibrary}\""
+          result << ""
+        end
+
+        # Process start pattern
+        if schema.start
+          result << "start = #{build_pattern(schema.start)}"
+          result << ""
+        end
+
+        # Process named patterns
+        if schema.define && !schema.define.empty?
+          schema.define.each do |define|
+            result << "#{define.name} = #{build_pattern(define)}"
+            result << ""
+          end
+        end
 
-    def build_schema(tree)
-      element = tree[:element]
-      Schema.new(
-        start: Start.new(
-          elements: [build_element(element)],
-        ),
-      )
+        result.join("\n")
+      end
     end
 
+    private
+
     def build_element(element)
-      name = element[:identifier].to_s
-      content = element[:content]&.[](:items)
-      occurrence = element[:occurrence]
-
-      # Create base element
-      el = Element.new(
-        name: name,
-        attributes: [],
-        elements: [],
-        text: false,
-      )
-
-      if content
-        current_elements = []
-        current_attributes = []
-
-        content.each do |item|
-          case
-          when item[:item][:name] || (item[:item][:identifier] && item[:item][:type])
-            attr_name = item[:item][:name] || item[:item][:identifier]
-            attr = Attribute.new(
-              name: attr_name.to_s,
-              type: ["string"],
-            )
-            current_attributes << attr
-          when item[:item][:identifier]
-            current_elements << build_element(item[:item])
-          when item[:item][:text]
-            el.text = true
+      result = "element #{element.name} {\n"
+      result += "  #{build_content(element)}\n"
+      result += "}"
+      result
+    end
+
+    def build_content(node)
+      content_parts = []
+
+      # Process attributes
+      if node.attribute
+        if node.attribute.is_a?(Array)
+          node.attribute.each do |attr|
+            content_parts << build_attribute(attr)
           end
+        else
+          content_parts << build_attribute(node.attribute)
         end
+      end
 
-        el.attributes = current_attributes
-        el.elements = current_elements
+      # Process child elements
+      if node.element
+        if node.element.is_a?(Array)
+          node.element.each do |elem|
+            content_parts << build_element(elem)
+          end
+        else
+          content_parts << build_element(node.element)
+        end
       end
 
-      # Handle occurrence modifiers
-      result = el
-      case occurrence
-      when "*"
-        result = Element.new(
-          name: el.name,
-          attributes: el.attributes,
-          elements: el.elements,
-          text: el.text,
-        )
-        result.zero_or_more = [el]
-      when "+"
-        result = Element.new(
-          name: el.name,
-          attributes: el.attributes,
-          elements: el.elements,
-          text: el.text,
-        )
-        result.one_or_more = [el]
-      when "?"
-        result = Element.new(
-          name: el.name,
-          attributes: el.attributes,
-          elements: el.elements,
-          text: el.text,
-        )
-        result.optional = [el]
+      # Process text
+      content_parts << "text" if node.text
+
+      # Process empty
+      content_parts << "empty" if node.empty
+
+      # Process choice
+      if node.choice
+        choice_parts = []
+        if node.choice.is_a?(Array)
+          node.choice.each do |choice|
+            choice_parts << build_pattern(choice)
+          end
+        else
+          choice_parts << build_pattern(node.choice)
+        end
+        content_parts << choice_parts.join(" | ")
+      end
+
+      # Process group
+      if node.group
+        group_parts = []
+        if node.group.is_a?(Array)
+          node.group.each do |group|
+            group_parts << build_pattern(group)
+          end
+        else
+          group_parts << build_pattern(node.group)
+        end
+        content_parts << "(#{group_parts.join(", ")})"
       end
 
+      # Process ref
+      if node.ref
+        if node.ref.is_a?(Array)
+          node.ref.each do |ref|
+            content_parts << ref.name
+          end
+        else
+          content_parts << node.ref.name
+        end
+      end
+
+      # Process zeroOrMore
+      content_parts << "#{build_pattern(node.zeroOrMore)}*" if node.zeroOrMore
+
+      # Process oneOrMore
+      content_parts << "#{build_pattern(node.oneOrMore)}+" if node.oneOrMore
+
+      # Process optional
+      content_parts << "#{build_pattern(node.optional)}?" if node.optional
+
+      content_parts.join(",\n  ")
+    end
+
+    def build_attribute(attr)
+      result = "attribute #{attr.name} { "
+
+      result += if attr.data
+                  if attr.data.type
+                    "xsd:#{attr.data.type}"
+                  else
+                    "text"
+                  end
+                else
+                  "text"
+                end
+
+      result += " }"
       result
     end
+
+    def build_pattern(node)
+      if node.element
+        build_element(node.element)
+      elsif node.ref
+        node.ref.name
+      elsif node.choice
+        choice_parts = []
+        if node.choice.is_a?(Array)
+          node.choice.each do |choice|
+            choice_parts << build_pattern(choice)
+          end
+        else
+          choice_parts << build_pattern(node.choice)
+        end
+        choice_parts.join(" | ")
+      elsif node.group
+        group_parts = []
+        if node.group.is_a?(Array)
+          node.group.each do |group|
+            group_parts << build_pattern(group)
+          end
+        else
+          group_parts << build_pattern(node.group)
+        end
+        "(#{group_parts.join(", ")})"
+      elsif node.text
+        "text"
+      elsif node.empty
+        "empty"
+      else
+        # Default case
+        ""
+      end
+    end
   end
 end

data/lib/rng/start.rb

@@ -1,14 +1,63 @@
+# frozen_string_literal: true
+
 require "lutaml/model"
-require_relative "element"
 
 module Rng
   class Start < Lutaml::Model::Serializable
-    attribute :ref, :string
-    attribute :elements, Element, collection: true
+    attribute :id, :string
+    attribute :ns, :string
+    attribute :datatypeLibrary, :string
+    attribute :combine, :string
+    attribute :ref, Ref
+    attribute :element, Element
+    attribute :choice, Choice
+    attribute :group, Group
+    attribute :interleave, Interleave
+    attribute :mixed, Mixed
+    attribute :optional, Optional
+    attribute :zeroOrMore, ZeroOrMore
+    attribute :oneOrMore, OneOrMore
+    attribute :text, Text
+    attribute :empty, Empty
+    attribute :value, Value
+    attribute :data, Data
+    attribute :list, List
+    attribute :parentRef, ParentRef
+    attribute :notAllowed, NotAllowed
+    attribute :grammar, Grammar
 
     xml do
-      map_attribute "ref", to: :ref
-      map_element "element", to: :elements
+      root "start", ordered: true
+      namespace "http://relaxng.org/ns/structure/1.0"
+
+      map_attribute "id", to: :id
+      map_attribute "ns", to: :ns, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_attribute "datatypeLibrary", to: :datatypeLibrary, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_attribute "combine", to: :combine
+
+      map_element "ref", to: :ref
+      map_element "element", to: :element
+      map_element "choice", to: :choice
+      map_element "group", to: :group
+      map_element "interleave", to: :interleave
+      map_element "mixed", to: :mixed
+      map_element "optional", to: :optional
+      map_element "zeroOrMore", to: :zeroOrMore
+      map_element "oneOrMore", to: :oneOrMore
+      map_element "text", to: :text
+      map_element "empty", to: :empty
+      map_element "value", to: :value
+      map_element "data", to: :data
+      map_element "list", to: :list
+      map_element "parentRef", to: :parentRef
+      map_element "notAllowed", to: :notAllowed
+      map_element "grammar", to: :grammar
     end
   end
 end

data/lib/rng/text.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Rng
+  class Text < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :ns, :string
+    attribute :datatypeLibrary, :string
+    attribute :value, :string, default: ""
+
+    xml do
+      root "text"
+      map_attribute "id", to: :id
+      map_attribute "ns", to: :ns, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_attribute "datatypeLibrary", to: :datatypeLibrary, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_content to: :value
+    end
+  end
+end

data/lib/rng/to_rnc.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rng
+  # RNG to RNC converter module
+  # Provides functionality to convert RELAX NG XML Schema (RNG) to RELAX NG Compact Syntax (RNC)
+  module ToRnc
+    class << self
+      # Convert an RNG schema object to RNC syntax
+      # @param schema [Rng::Grammar] The schema to convert
+      # @return [String] The RNC representation of the schema
+      def convert(schema)
+        # This is a placeholder implementation
+        # The actual conversion logic would need to be implemented
+
+        # Return a simple template indicating this is a stub
+        "# RELAX NG Compact Syntax (RNC) - STUB IMPLEMENTATION\n" \
+        "# This is a placeholder for the actual RNG to RNC conversion\n\n" \
+        "start = element #{element_name(schema)} {\n" \
+        "  # Conversion not yet implemented\n" \
+        "  text\n" \
+        "}\n"
+      end
+
+      private
+
+      # Extract a sensible element name from the schema
+      # @param schema [Rng::Grammar] The schema to extract element name from
+      # @return [String] The element name or a default
+      def element_name(schema)
+        # Try to determine the root element name from the schema
+        if schema.respond_to?(:start) &&
+           schema.start.respond_to?(:element) &&
+           schema.start.element.any? &&
+           schema.start.element.first.respond_to?(:name)
+          return schema.start.element.first.name
+        end
+
+        # Try other options if available
+        if schema.respond_to?(:element) &&
+           schema.element.respond_to?(:name) &&
+           schema.element.name.is_a?(String)
+          return schema.element.name
+        end
+
+        # Use default name if we can't determine from schema
+        "root"
+      end
+    end
+  end
+
+  # Add class-level conversion method
+  def self.to_rnc(schema)
+    ToRnc.convert(schema)
+  end
+end

data/lib/rng/value.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Rng
+  class Value < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :ns, :string
+    attribute :datatypeLibrary, :string
+    attribute :type, :string
+    attribute :value, :string
+
+    xml do
+      root "value"
+
+      map_attribute "type", to: :type
+      map_attribute "id", to: :id
+      map_attribute "ns", to: :ns, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_attribute "datatypeLibrary", to: :datatypeLibrary, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_content to: :value
+    end
+  end
+end

data/lib/rng/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rng
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end