shale 0.6.0 → 0.8.0

data/lib/shale/mapping/xml_base.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require_relative 'descriptor/xml'
+require_relative 'descriptor/xml_namespace'
+require_relative 'validator'
+
+module Shale
+  module Mapping
+    # Base class for Mapping XML serialization format
+    #
+    # @api private
+    class XmlBase
+      # Return elements mapping hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :elements
+
+      # Return attributes mapping hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :attributes
+
+      # Return content mapping
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      attr_reader :content
+
+      # Return default namespace
+      #
+      # @return [Shale::Mapping::Descriptor::XmlNamespace]
+      #
+      # @api private
+      attr_reader :default_namespace
+
+      # Return unprefixed root
+      #
+      # @return [String]
+      #
+      # @api private
+      def unprefixed_root
+        @root
+      end
+
+      # Return prefixed root
+      #
+      # @return [String]
+      #
+      # @api private
+      def prefixed_root
+        [default_namespace.prefix, @root].compact.join(':')
+      end
+
+      # Initialize instance
+      #
+      # @api private
+      def initialize
+        super
+        @elements = {}
+        @attributes = {}
+        @content = nil
+        @root = ''
+        @default_namespace = Descriptor::XmlNamespace.new
+        @finalized = false
+      end
+
+      # Map element to attribute
+      #
+      # @param [String] element
+      # @param [Symbol, nil] to
+      # @param [Hash, nil] using
+      # @param [String, nil] group
+      # @param [String, nil] namespace
+      # @param [String, nil] prefix
+      # @param [true, false] cdata
+      # @param [true, false] render_nil
+      #
+      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      #
+      # @api private
+      def map_element(
+        element,
+        to: nil,
+        using: nil,
+        group: nil,
+        namespace: :undefined,
+        prefix: :undefined,
+        cdata: false,
+        render_nil: false
+      )
+        Validator.validate_arguments(element, to, using)
+        Validator.validate_namespace(element, namespace, prefix)
+
+        if namespace == :undefined && prefix == :undefined
+          nsp = default_namespace.name
+          pfx = default_namespace.prefix
+        else
+          nsp = namespace
+          pfx = prefix
+        end
+
+        namespaced_element = [nsp, element].compact.join(':')
+
+        @elements[namespaced_element] = Descriptor::Xml.new(
+          name: element,
+          attribute: to,
+          methods: using,
+          group: group,
+          namespace: Descriptor::XmlNamespace.new(nsp, pfx),
+          cdata: cdata,
+          render_nil: render_nil
+        )
+      end
+
+      # Map document's attribute to object's attribute
+      #
+      # @param [String] attribute
+      # @param [Symbol, nil] to
+      # @param [Hash, nil] using
+      # @param [String, nil] namespace
+      # @param [String, nil] prefix
+      # @param [true, false] render_nil
+      #
+      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      #
+      # @api private
+      def map_attribute(
+        attribute,
+        to: nil,
+        using: nil,
+        group: nil,
+        namespace: nil,
+        prefix: nil,
+        render_nil: false
+      )
+        Validator.validate_arguments(attribute, to, using)
+        Validator.validate_namespace(attribute, namespace, prefix)
+
+        namespaced_attribute = [namespace, attribute].compact.join(':')
+
+        @attributes[namespaced_attribute] = Descriptor::Xml.new(
+          name: attribute,
+          attribute: to,
+          methods: using,
+          namespace: Descriptor::XmlNamespace.new(namespace, prefix),
+          cdata: false,
+          group: group,
+          render_nil: render_nil
+        )
+      end
+
+      # Map document's content to object's attribute
+      #
+      # @param [Symbol] to
+      # @param [Hash, nil] using
+      # @param [true, false] cdata
+      #
+      # @api private
+      def map_content(to: nil, using: nil, group: nil, cdata: false)
+        Validator.validate_arguments('content', to, using)
+
+        @content = Descriptor::Xml.new(
+          name: nil,
+          attribute: to,
+          methods: using,
+          namespace: Descriptor::XmlNamespace.new(nil, nil),
+          cdata: cdata,
+          group: group,
+          render_nil: false
+        )
+      end
+
+      # Set the name for root element
+      #
+      # @param [String] value root's name
+      #
+      # @api private
+      def root(value)
+        @root = value
+      end
+
+      # Set default namespace for root element
+      #
+      # @param [String] name
+      # @param [String] prefix
+      #
+      # @api private
+      def namespace(name, prefix)
+        @default_namespace.name = name
+        @default_namespace.prefix = prefix
+      end
+
+      # Set the "finalized" instance variable to true
+      #
+      # @api private
+      def finalize!
+        @finalized = true
+      end
+
+      # Query the "finalized" instance variable
+      #
+      # @return [truem false]
+      #
+      # @api private
+      def finalized?
+        @finalized
+      end
+
+      # @api private
+      def initialize_dup(other)
+        @elements = other.instance_variable_get('@elements').dup
+        @attributes = other.instance_variable_get('@attributes').dup
+        @content = other.instance_variable_get('@content').dup
+        @root = other.instance_variable_get('@root').dup
+        @default_namespace = other.instance_variable_get('@default_namespace').dup
+        @finalized = false
+
+        super
+      end
+    end
+  end
+end

data/lib/shale/mapping/xml_group.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'xml_base'
+
+module Shale
+  module Mapping
+    # Group for XML serialization format
+    #
+    # @api private
+    class XmlGroup < XmlBase
+      # Return name of the group
+      #
+      # @return [String]
+      #
+      # @api private
+      attr_reader :name
+
+      # Initialize instance
+      #
+      # @api private
+      def initialize(from, to)
+        super()
+        @from = from
+        @to = to
+        @name = "group_#{hash}"
+      end
+
+      # Map element to attribute
+      #
+      # @param [String] element
+      # @param [String, nil] namespace
+      # @param [String, nil] prefix
+      #
+      # @api private
+      def map_element(element, namespace: :undefined, prefix: :undefined)
+        super(
+          element,
+          using: { from: @from, to: @to },
+          group: @name,
+          namespace: namespace,
+          prefix: prefix
+        )
+      end
+
+      # Map document's attribute to object's attribute
+      #
+      # @param [String] attribute
+      # @param [String, nil] namespace
+      # @param [String, nil] prefix
+      #
+      # @api private
+      def map_attribute(attribute, namespace: nil, prefix: nil)
+        super(
+          attribute,
+          using: { from: @from, to: @to },
+          group: @name,
+          namespace: namespace,
+          prefix: prefix
+        )
+      end
+
+      # Map document's content to object's attribute
+      #
+      # @api private
+      def map_content
+        super(using: { from: @from, to: @to }, group: @name)
+      end
+    end
+  end
+end

data/lib/shale/schema/json_generator.rb

@@ -124,9 +124,7 @@ module Shale
       # @api public
       def to_schema(klass, id: nil, title: nil, description: nil, pretty: false)
         schema = as_schema(klass, id: id, title: title, description: description)
-        options = pretty ? :pretty : nil
-
-        Shale.json_adapter.dump(schema, options)
+        Shale.json_adapter.dump(schema, pretty: pretty)
       end
 
       private

data/lib/shale/schema/xml_generator/import.rb

@@ -35,8 +35,8 @@ module Shale
         def as_xml(doc)
           import = doc.create_element('xs:import')
 
-          doc.add_attribute(import, 'namespace', @namespace)
-          doc.add_attribute(import, 'schemaLocation', @location)
+          doc.add_attribute(import, 'namespace', @namespace) if @namespace
+          doc.add_attribute(import, 'schemaLocation', @location) if @location
 
           import
         end

data/lib/shale/schema/xml_generator.rb

@@ -222,13 +222,11 @@ module Shale
       def to_schemas(klass, base_name = nil, pretty: false, declaration: false)
         schemas = as_schemas(klass, base_name)
 
-        options = [
-          pretty ? :pretty : nil,
-          declaration ? :declaration : nil,
-        ]
-
         schemas.to_h do |schema|
-          [schema.name, Shale.xml_adapter.dump(schema.as_xml, *options)]
+          [
+            schema.name,
+            Shale.xml_adapter.dump(schema.as_xml, pretty: pretty, declaration: declaration),
+          ]
         end
       end