xsd 1.0.0

data/lib/xsd/base_object.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+module XSD
+  # Base object
+  class BaseObject
+    attr_reader :options
+
+    # Objects that can not have nested elements
+    NO_ELEMENTS_CONTAINER = %i[annotation simpleType attributeGroup attribute
+                               unique union simpleContent list any anyAttribute key keyref].freeze
+
+    # Objects that cannot have nested attributes
+    NO_ATTRIBUTES_CONTAINER = %i[annotation unique anyAttribute all
+                                 attribute choice sequence group simpleType facet key keyref].freeze
+
+    # Base XMLSchema namespace
+    XML_SCHEMA = 'http://www.w3.org/2001/XMLSchema'
+
+    class << self
+      attr_reader :properties, :children, :links
+
+      def properties
+        @properties ||= {}
+      end
+
+      def links
+        @links ||= {}
+      end
+
+      def children
+        @children ||= {}
+      end
+    end
+
+    # Optional. Specifies a unique ID for the element
+    # @!attribute id
+    # @return [String]
+    # property :id, :string
+    def id
+      node['id']
+    end
+
+    def initialize(options = {})
+      @options = options
+      @cache   = {}
+
+      raise Error, "#{self.class}.new expects a hash parameter" unless @options.is_a?(Hash)
+    end
+
+    # Get current XML node
+    # @return [Nokogiri::XML::Node]
+    def node
+      options[:node]
+    end
+
+    # Get current namespaces
+    # @return [Hash]
+    def namespaces
+      node.namespaces || {}
+    end
+
+    # Get child nodes
+    # @param [Symbol] name
+    # @return [Nokogiri::XML::NodeSet]
+    def nodes(name = :*)
+      node.xpath("./xs:#{name}", { 'xs' => XML_SCHEMA })
+    end
+
+    # Get schema object for specified namespace prefix
+    # @param [String] prefix
+    # @return [Schema]
+    def schema_for_namespace(prefix)
+      if schema.targets_namespace?(prefix)
+        schema
+      elsif (import = schema.import_by_namespace(prefix))
+        import.imported_reader.schema
+      else
+        raise Error, "Schema not found for namespace '#{prefix}' in '#{schema.id || schema.target_namespace}'"
+      end
+    end
+
+    # Get element or attribute by path
+    # @return [Element, Attribute, nil]
+    def [](*args)
+      result = self
+
+      args.flatten.each do |curname|
+        next if result.nil?
+
+        curname = curname.to_s
+
+        if curname[0] == '@'
+          result = result.all_attributes.find { |attr| attr.name == curname[1..-1] }
+        else
+          result = result.all_elements.find { |elem| elem.name == curname }
+        end
+      end
+
+      result
+    end
+
+    # Search node by name in all available schemas and return its object
+    # @param [Symbol] node_name
+    # @param [String] name
+    # @return [BaseObject, nil]
+    def object_by_name(node_name, name)
+      # get prefix and local name
+      name_prefix = get_prefix(name)
+      name_local  = strip_prefix(name)
+
+      # do not search for built-in types
+      return nil if schema.namespace_prefix == name_prefix
+
+      # determine schema for namespace
+      search_schema = schema_for_namespace(name_prefix)
+
+      # find element in target schema
+      result = search_schema.node.xpath("./xs:#{node_name}[@name=\"#{name_local}\"]", { 'xs' => XML_SCHEMA }).first
+
+      result ? search_schema.node_to_object(result) : nil
+    end
+
+    # Get reader object for node
+    # @param [Nokogiri::XML::Node]
+    # @return [BaseObject]
+    def node_to_object(node)
+      # check object in cache first
+      # TODO: проверить работу!
+      return reader.object_cache[node.object_id] if reader.object_cache[node.object_id]
+
+      klass = XML::CLASS_MAP[node.name]
+      raise Error, "Object class not found for '#{node.name}'" unless klass
+
+      reader.object_cache[node.object_id] = klass.new(options.merge(node: node, schema: schema))
+    end
+
+    # Get xml parent object
+    # @return [BaseObject, nil]
+    def parent
+      node.respond_to?(:parent) && node.parent ? node_to_object(node.parent) : nil
+    end
+
+    # Get current schema object
+    # @return [Schema]
+    def schema
+      options[:schema]
+    end
+
+    # Get child objects
+    # @param [Symbol] name
+    # @return [Array<BaseObject>]
+    def map_children(name)
+      nodes(name).map { |node| node_to_object(node) }
+    end
+
+    # Get child object
+    # @param [Symbol] name
+    # @return [BaseObject, nil]
+    def map_child(name)
+      map_children(name).first
+    end
+
+    # Strip namespace prefix from node name
+    # @param [String, nil] name Name to strip from
+    # @return [String, nil]
+    def strip_prefix(name)
+      name&.include?(':') ? name.split(':').last : name
+    end
+
+    # Get namespace prefix from node name
+    # @param [String, nil] name Name to strip from
+    # @return [String]
+    def get_prefix(name)
+      name&.include?(':') ? name.split(':').first : ''
+    end
+
+    # Return element documentation
+    # @return [Array<String>]
+    def documentation
+      documentation_for(node)
+    end
+
+    # Return documentation for specified node
+    # @param [Nokogiri::XML::Node] node
+    # @return [Array<String>]
+    def documentation_for(node)
+      node.xpath('./xs:annotation/xs:documentation/text()', { 'xs' => XML_SCHEMA }).map(&:to_s).map(&:strip)
+    end
+
+    # Get all available elements on the current stack level
+    # @return [Array<Element>]
+    def all_elements(*)
+      # exclude element that can not have elements
+      return [] if NO_ELEMENTS_CONTAINER.include?(self.class.mapped_name)
+
+      if is_a?(Referenced) && ref
+        reference.all_elements
+      else
+        # map children recursive
+        map_children(:*).map do |obj|
+          if obj.is_a?(Element)
+            obj
+          else
+            # get elements considering references
+            (obj.is_a?(Referenced) && obj.ref ? obj.reference : obj).all_elements
+          end
+        end.flatten
+      end
+    end
+
+    # Get all available attributes on the current stack level
+    # @return [Array<Attribute>]
+    def all_attributes(*)
+      # exclude element that can not have elements
+      return [] if NO_ATTRIBUTES_CONTAINER.include?(self.class.mapped_name)
+
+      if is_a?(Referenced) && ref
+        reference.all_attributes
+      else
+        # map children recursive
+        map_children(:*).map do |obj|
+          if obj.is_a?(Attribute)
+            obj
+          else
+            # get attributes considering references
+            (obj.is_a?(Referenced) && obj.ref ? obj.reference : obj).all_attributes
+          end
+        end.flatten
+      end
+    end
+
+    # Get reader instance
+    # @return [XML]
+    def reader
+      options[:reader]
+    end
+
+    protected
+
+    def self.to_underscore(string)
+      string.to_s.gsub(/([^A-Z])([A-Z]+)/, '\1_\2').sub(':', '_').downcase.to_sym
+    end
+
+    # Define new object property
+    # @param [Symbol] name
+    # @param [Symbol] type
+    # @param [Hash] options
+    def self.property(name, type, options = {}, &block)
+      properties[to_underscore(name)] = {
+        name:    name,
+        type:    type,
+        resolve: block,
+        **options
+      }
+    end
+
+    # Define new object child
+    # @param [Symbol] name
+    # @param [Symbol, Array<Symbol>] type
+    # @param [Hash] options
+    def self.child(name, type, options = {})
+      children[to_underscore(name)] = {
+        type: type,
+        **options
+      }
+    end
+
+    # Define new object child
+    # @param [Symbol] name
+    # @param [Symbol] type
+    # @param [Hash] options
+    def self.link(name, type, options = {})
+      links[to_underscore(name)] = {
+        type: type,
+        **options
+      }
+    end
+
+    # Lookup for properties
+    # @param [Symbol] method
+    # @param [Array] args
+    def method_missing(method, *args)
+      # check cache first
+      return @cache[method] if @cache[method]
+
+      # check for property first
+      if (property = self.class.properties[method])
+        value  = property[:resolve] ? property[:resolve].call(self) : node[property[:name].to_s]
+        result = if value.nil?
+                   # if object has reference - search property in referenced object
+                   node['ref'] ? reference.send(method, *args) : property[:default]
+                 else
+                   case property[:type]
+                   when :integer
+                     property[:name] == :maxOccurs && value == 'unbounded' ? :unbounded : value.to_i
+                   when :boolean
+                     !!value
+                   else
+                     value
+                   end
+                 end
+        return @cache[method] = result
+      end
+
+      # if object has ref it cannot contain any type and children, so proxy call to target object
+      if node['ref'] && method != :ref && method != :reference
+        return reference.send(method, *args)
+      end
+
+      # then check for linked types
+      if (link = self.class.links[method])
+        name = link[:property] ? send(link[:property]) : nil
+        if name
+          return @cache[method] = object_by_name(link[:type], name)
+        end
+      end
+
+      # last check for nested objects
+      if (child = self.class.children[method])
+        result = child[:type].is_a?(Array) ? map_children(child[:type][0]) : map_child(child[:type])
+        return @cache[method] = result
+      end
+
+      super
+      # api = self.class.properties.keys + self.class.links.keys + self.class.children.keys
+      # raise Error, "Tried to access unknown object '#{method}' on '#{self.class.name}'. Available options are: #{api}"
+    end
+
+    # Does object has property/link/child?
+    # @param [Symbol] method
+    # @param [Array] args
+    def respond_to_missing?(method, *args)
+      self.class.properties[method] || self.class.links[method] || self.class.children[method] || super
+    end
+
+    # Get mapped element name
+    # @return [Symbol]
+    def self.mapped_name
+      # @mapped_name ||= XML::CLASS_MAP.each { |k, v| return k.to_sym if v == self }
+      @mapped_name ||= begin
+        name    = self.name.split('::').last
+        name[0] = name[0].downcase
+        name.to_sym
+      end
+    end
+  end
+end

data/lib/xsd/exceptions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module XSD
+  class Error < StandardError
+  end
+
+  class ValidationError < Error
+  end
+
+  class ImportError < Error
+  end
+end

data/lib/xsd/generator.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'builder'
+
+module XSD
+  module Generator
+    # Generate XML from provided data
+    # @param [Hash] data
+    # @param [String, Array<String>] element
+    # @param [Builder::XmlMarkup] builder
+    # @return [Builder::XmlMarkup]
+    def generate(data, element = nil, builder = nil)
+      # find root element
+      root = find_root_element(element)
+
+      # create builder
+      builder ||= default_builder
+
+      # build element tree
+      @namespace_index = 0
+      build_element(builder, root, data)
+
+      builder
+    end
+
+    private
+
+    # Build element tree
+    # @param [Builder::XmlMarkup] xml
+    # @param [Element] element
+    # @param [Hash] data
+    # @param [Hash] namespaces
+    def build_element(xml, element, data, namespaces = {})
+      # get item data
+      elements         = (element.abstract ? [] : [element]) + element.substitution_elements
+      provided_element = elements.find { |elem| !data[elem.name].nil? }
+
+      if element.required? && provided_element.nil?
+        raise Error, "Element #{element.name} is required, but no data in provided for it"
+      end
+      return unless provided_element
+
+      element = provided_element
+      data    = data[element.name]
+
+      # handle repeated items
+      if element.multiple_allowed?
+        unless data.is_a?(Array)
+          raise Error, "Element #{element.name} is allowed to occur multiple times, but non-array is provided"
+        end
+      else
+        if data.is_a?(Array)
+          raise Error, "Element #{element.name} is not allowed to occur multiple times, but an array is provided"
+        end
+
+        data = [data]
+      end
+
+      # configure namespaces
+      # TODO: попытаться использовать collect_namespaces?
+      attributes = {}
+      all_attributes = element.all_attributes
+      if element.complex?
+        all_elements = element.all_elements
+
+        # get namespaces for current element and it's children
+        prefix = nil
+        [*all_elements, element].each do |elem|
+          prefix = get_namespace_prefix(elem, attributes, namespaces)
+        end
+      else
+        prefix = get_namespace_prefix(element, attributes, namespaces)
+      end
+
+      # iterate through each item
+      data.each do |item|
+        # prepare attributes
+        all_attributes.each do |attribute|
+          value = item["@#{attribute.name}"]
+          if value
+            attributes[attribute.name] = value
+          else
+            attributes.delete(attribute.name)
+          end
+        end
+
+        # generate element
+        if element.complex?
+          # generate tag recursively
+          xml.tag!("#{prefix}:#{element.name}", attributes) do
+            all_elements.each do |elem|
+              build_element(xml, elem, item, namespaces.dup)
+            end
+          end
+        else
+          value  = item.is_a?(Hash) ? item['#text'] : item
+          xml.tag!("#{prefix}:#{element.name}", attributes, (value == '' ? nil : value))
+        end
+      end
+    end
+
+    # Get namespace prefix for element
+    # @param [Element] element
+    # @param [Hash] attributes
+    # @param [Hash] namespaces
+    # @return [String]
+    def get_namespace_prefix(element, attributes, namespaces)
+      namespace = (element.referenced? ? element.reference : element).target_namespace
+      prefix    = namespaces.key(namespace)
+      unless prefix
+        prefix             = "tns#{@namespace_index += 1}"
+        namespaces[prefix] = attributes["xmlns:#{prefix}"] = namespace
+      end
+
+      prefix
+    end
+
+    # Find root element with provided lookup
+    # @param [String, Array<String>, nil] lookup
+    def find_root_element(lookup)
+      if lookup
+        element = schema[*lookup]
+        raise Error, "Cant find start element #{lookup}" unless element.is_a?(Element)
+
+        element
+      else
+        raise Error, 'XSD contains more that one root element. Please, specify starting element' if elements.size > 1
+
+        elements.first
+      end
+    end
+
+    def default_builder
+      Builder::XmlMarkup.new
+    end
+  end
+end

data/lib/xsd/objects/all.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module XSD
+  # The all element specifies that the child elements can appear in any order and that each child element can
+  # occur zero or one time.
+  # Parent elements: group, complexType, restriction (both simpleContent and complexContent),
+  # extension (both simpleContent and complexContent)
+  # https://www.w3schools.com/xml/el_all.asp
+  class All < BaseObject
+    include ElementContainer
+
+    # Optional. Specifies the minimum number of times the element can occur. The value can be 0 or 1. Default value is 1
+    # @!attribute min_occurs
+    # @return [Integer]
+    property :minOccurs, :integer, default: 1
+
+    # Optional. Specifies the maximum number of times the element can occur. The value must be 1.
+    # @!attribute max_occurs
+    # @return [Integer]
+    property :maxOccurs, :integer, default: 1
+  end
+end

data/lib/xsd/objects/annotation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module XSD
+  # The annotation element is a top level element that specifies schema comments. The comments serve as inline
+  # documentation.
+  # Parent elements: Any element
+  # https://www.w3schools.com/xml/el_annotation.asp
+  class Annotation < BaseObject
+    # Nested appinfos
+    # @!attribute appinfos
+    # @return [Array<Appinfo>]
+    child :appinfos, [:appinfo]
+
+    # Nested documentations
+    # @!attribute documentations
+    # @return [Array<Documentation>]
+    child :documentations, [:documentation]
+  end
+end

data/lib/xsd/objects/any.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module XSD
+  # The any element enables the author to extend the XML document with elements not specified by the schema.
+  # Parent elements: choice, sequence
+  # https://www.w3schools.com/xml/el_any.asp
+  class Any < BaseObject
+    include MinMaxOccurs
+
+    # Optional. Specifies the namespaces containing the elements that can be used. Can be set to one of the following:
+    #     ##any - elements from any namespace is allowed (this is default)
+    #     ##other - elements from any namespace that is not the namespace of the parent element can be present
+    #     ##local - elements must come from no namespace
+    #     ##targetNamespace - elements from the namespace of the parent element can be present
+    #     List of {URI references of namespaces, ##targetNamespace, ##local} - elements from a space-delimited list of
+    #     the namespaces can be present
+    # @!attribute namespace
+    # @return [String]
+    property :namespace, :string, default: '##any'
+
+    # Optional. Specifies how the XML processor should handle validation against the elements specified by this any
+    # element. Can be set to one of the following:
+    #   strict - the XML processor must obtain the schema
+    #     for the required namespaces and validate the elements (this is default)
+    #   lax - same as strict but; if the schema cannot be obtained, no errors will occur
+    #   skip - The XML processor does not attempt to validate any elements from the specified namespaces
+    # @!attribute process_contents
+    # @return [String, nil]
+    property :processContents, :string, default: 'strict'
+  end
+end

data/lib/xsd/objects/any_attribute.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module XSD
+  # The anyAttribute element enables the author to extend the XML document with attributes not specified by the schema.
+  # Parent elements: complexType, restriction (both simpleContent and complexContent), extension (both simpleContent
+  # and complexContent), attributeGroup
+  # https://www.w3schools.com/xml/el_anyattribute.asp
+  class AnyAttribute < BaseObject
+    # Optional. Specifies the namespaces containing the attributes that can be used. Can be set to one of the following:
+    #   ##any             - attributes from any namespace is allowed (this is default)
+    #   ##other           - attributes from any namespace that is not the namespace of the parent element can be present
+    #   ##local           - attributes must come from no namespace
+    #   ##targetNamespace - attributes from the namespace of the parent element can be present
+    #     List of {URI references of namespaces, ##targetNamespace, ##local} - attributes from a space-delimited list
+    #                        of the namespaces can be present
+    # @!attribute namespace
+    # @return [String]
+    property :namespace, :string, default: '##any'
+
+    # Optional. Specifies how the XML processor should handle validation against the elements specified by this any
+    # element. Can be set to one of the following:
+    #   strict - the XML processor must obtain the schema for the required namespaces and validate the elements (this
+    #              is default)
+    #   lax    - same as strict but; if the schema cannot be obtained, no errors will occur
+    #   skip   - The XML processor does not attempt to validate any elements from the specified namespaces
+    # @!attribute process_contents
+    # @return [String, nil]
+    property :processContents, :string, default: 'strict'
+  end
+end

data/lib/xsd/objects/appinfo.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module XSD
+  # The appinfo element specifies information to be used by the application.
+  # Parent elements: annotation
+  # https://www.w3schools.com/xml/el_appinfo.asp
+  class Appinfo < BaseObject
+    # Optional. A URI reference that specifies the source of the application information
+    # @!attribute source
+    # @return [String]
+    property :source, :string
+  end
+end

data/lib/xsd/objects/attribute.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module XSD
+  # The attribute element defines an attribute.
+  # Parent elements: attributeGroup, schema, complexType, restriction (both simpleContent and complexContent),
+  # extension (both simpleContent and complexContent)
+  # https://www.w3schools.com/xml/el_attribute.asp
+  class Attribute < BaseObject
+    TYPE_PROPERTY = :type
+
+    include SimpleTyped
+    include Referenced
+
+    # Optional. Specifies the name of the attribute. Name and ref attributes cannot both be present
+    # @!attribute name
+    # @return [String]
+    property :name, :string
+
+    # Optional. Specifies a default value for the attribute. Default and fixed attributes cannot both be present
+    # @!attribute default
+    # @return [String, nil]
+    property :default, :string
+
+    # Optional. Specifies a fixed value for the attribute. Default and fixed attributes cannot both be present
+    # @!attribute fixed
+    # @return [String, nil]
+    property :fixed, :string
+
+    # Optional. Specifies the form for the attribute. The default value is the value of the attributeFormDefault
+    # attribute of the element containing the attribute. Can be set to one of the following:
+    #   qualified   - indicates that this attribute must be qualified with the namespace prefix and the no-colon-name
+    #                 (NCName) of the attribute
+    #   unqualified - indicates that this attribute is not required to be qualified with the namespace prefix and is
+    #                 matched against the (NCName) of the attribute
+    # @!attribute form
+    # @return [String, nil]
+    # TODO: поддержка default значения с вычислением родителя
+    property :form, :string
+
+    # Optional. Specifies a built-in data type or a simple type. The type attribute can only be present when the
+    # content does not contain a simpleType element
+    # @!attribute type
+    # @return [String, nil]
+    property :type, :string
+
+    # Optional. Specifies how the attribute is used. Can be one of the following values:
+    #   optional   - the attribute is optional (this is default)
+    #   prohibited - the attribute cannot be used
+    #   required   - the attribute is required
+    # @!attribute use
+    # @return [String]
+    property :use, :string, default: 'optional'
+
+    # Determine if attribute is required
+    # @return [Boolean]
+    def required?
+      use == 'required'
+    end
+
+    # Determine if attribute is optional
+    # @return [Boolean]
+    def optional?
+      use == 'optional'
+    end
+
+    # Determine if attribute is prohibited
+    # @return [Boolean]
+    def prohibited?
+      use == 'prohibited'
+    end
+  end
+end