datacite-mapping 0.1.17.2 → 0.2.0

data/lib/datacite/mapping/geo_location_node.rb

@@ -0,0 +1,68 @@
+require 'xml/mapping_extensions'
+
+module Datacite
+  module Mapping
+    # Abstract superclass of GeoLocation parsing nodes
+    class GeoLocationNode < XML::Mapping::SingleAttributeNode
+
+      attr_reader :geom_class
+      attr_reader :coord_elements
+
+      def initialize(*args)
+        fail 'No geometry class provided' unless @geom_class
+        fail 'No coordinate elements provided' unless @coord_elements
+        path, *args = super(*args)
+        @path = ::XML::XXPath.new(path)
+        args
+      end
+
+      def datacite_3?
+        mapping == :datacite_3
+      end
+
+      def extract_attr_value(xml)
+        return from_text(xml) || from_children(xml)
+      rescue => e
+        raise e, "#{@owner}.#{@attrname}: Can't extract #{self.class} from #{xml}: #{e.message}"
+      end
+
+      def set_attr_value(xml, value) # rubocop:disable Metrics/AbcSize
+        fail "Invalid value: expected #{geom_class} instance, was #{value || 'nil'}" unless value && value.is_a?(geom_class)
+        element = @path.first(xml, ensure_created: true)
+
+        if datacite_3?
+          element.text = value.to_s
+        else
+          coord_elements.each do |getter, element_name|
+            child = element.elements << REXML::Element.new(element_name)
+            child.text = value.send(getter)
+          end
+        end
+      end
+
+      private
+
+      # Parses Datacite 3.x text coordinates
+      def from_text(xml)
+        xml_text = default_when_xpath_err { @path.first(xml).text }
+        return unless xml_text
+
+        stripped = xml_text.strip
+        return if stripped.empty?
+
+        coords = stripped.split(/\s+/).map(&:to_f)
+        geom_class.new(*coords)
+      end
+
+      # Parses Datacite 4.x child-element coordinates
+      def from_children(xml)
+        elem = @path.first(xml)
+        coords_hash = coord_elements.map do |key, element_name|
+          value = elem.elements[element_name].text
+          [key, value && value.to_f]
+        end.to_h
+        geom_class.new(coords_hash)
+      end
+    end
+  end
+end

data/lib/datacite/mapping/geo_location_point.rb

@@ -1,4 +1,5 @@
 require 'xml/mapping'
+require 'datacite/mapping/geo_location_node'
 
 module Datacite
   module Mapping
@@ -63,7 +64,7 @@ module Datacite
         return nil unless other.class == self.class
         [:latitude, :longitude].each do |c|
           order = send(c) <=> other.send(c)
-          return order if order != 0
+          return order if order.nonzero?
         end
         0
       end
@@ -87,13 +88,12 @@ module Datacite
     end
 
     # XML mapping node for `<geoLocationPoint/>`
-    class GeoLocationPointNode < XML::MappingExtensions::NodeBase
-      # Converts a whitespace-separated pair of coordinates to a {GeoLocationPoint}.
-      # @param xml_text [String] the coordinates, in the order `lat` `long`.
-      def to_value(xml_text)
-        stripped = xml_text.strip
-        coords = stripped.split(/\s+/).map(&:to_f)
-        GeoLocationPoint.new(*coords)
+    class GeoLocationPointNode < GeoLocationNode
+      def initialize(*args)
+        @geom_class = GeoLocationPoint
+        @coord_elements = { latitude: 'pointLatitude',
+                            longitude: 'pointLongitude' }.freeze
+        super
       end
     end
     XML::Mapping.add_node_class GeoLocationPointNode

data/lib/datacite/mapping/geo_location_polygon.rb

@@ -0,0 +1,76 @@
+require 'xml/mapping'
+
+module Datacite
+  module Mapping
+    class GeoLocationPolygon
+      include Comparable
+      include XML::Mapping
+
+      # Creates a new `GeoLocationPolygon`.
+      #
+      # @param points [Array<GeoLocationPoint>] an array of points defining the polygon area.
+      #   Per the spec, the array should contain at least four points, the first and last being
+      #   identical to close the polygon.
+      def initialize(points:) # TODO: allow simple array of point args, array of hashes
+        self.points = points
+        warn "Polygon should contain at least 4 points, but has #{points.size}" if points.size < 4
+        warn "Polygon is not closed; last and first point should be identical, but were: [#{points[0]}], [#{points[-1]}]" if points.size > 1 unless points[0] == points[-1]
+      end
+
+      def points=(value)
+        @points = value || []
+      end
+
+      def <=>(other)
+        return nil unless other.class == self.class
+        points <=> other.points
+      end
+
+      def hash
+        points.hash
+      end
+
+      def to_s
+        point_hashes = points.map { |p| "{ latitude: #{p.latitude}, longitude: #{p.longitude} }" }.join(', ')
+        "[ #{point_hashes} ]"
+      end
+
+      # # @!attribute [rw] polygon
+      # #   @return [Array<GeoLocationPoint>] an array of points defining the polygon area.
+      array_node :points, 'polygonPoint',
+                 default_value: [],
+                 marshaller: (proc { |xml, value| marshal_point(xml, value) }),
+                 unmarshaller: (proc { |xml| unmarshal_point(xml) })
+
+      use_mapping :datacite_3
+
+      # TODO: does this ever get called?
+      read_only_array_node :points, 'polygonPoint', class: GeoLocationPoint, default_value: [], warn_reason: 'not available in Datacite 3'
+
+      fallback_mapping :datacite_3, :_default
+
+      # TODO: Figure out how to DRY this with GeoLocationPointNode
+
+      COORD_ELEMENTS = { longitude: 'pointLongitude',
+                         latitude: 'pointLatitude' }.freeze
+
+      def self.marshal_point(element, value)
+        COORD_ELEMENTS.each do |getter, element_name|
+          v = value.send(getter)
+          puts "adding #{element_name}: #{v}"
+          child = element.elements << REXML::Element.new(element_name)
+          child.text = v
+        end
+      end
+
+      def self.unmarshal_point(elem)
+        coords_hash = COORD_ELEMENTS.map do |key, element_name|
+          value = elem.elements[element_name].text
+          [key, value && value.to_f]
+        end.to_h
+        GeoLocationPoint.new(coords_hash)
+      end
+
+    end
+  end
+end

data/lib/datacite/mapping/identifier.rb

@@ -2,7 +2,7 @@ require 'xml/mapping'
 
 module Datacite
   module Mapping
-    DOI_PATTERN = %r{10\..+/.+}
+    DOI_PATTERN = %r{10\.\S+/\S+}
 
     # The persistent identifier that identifies the resource.
     #
@@ -24,9 +24,10 @@ module Datacite
       end
 
       def value=(v)
-        fail ArgumentError, 'Identifier must have a non-nil value' unless v
-        fail ArgumentError, "Identifier value '#{v}' is not a valid DOI" unless v.match(DOI_PATTERN)
-        @value = v
+        new_value = v && v.strip
+        fail ArgumentError, 'Identifier must have a non-nil value' unless new_value
+        fail ArgumentError, "Identifier value '#{new_value}' is not a valid DOI" unless new_value.match(DOI_PATTERN)
+        @value = new_value
       end
 
       # Sets the identifier type. Should only be called by the XML mapping engine.
@@ -50,16 +51,27 @@ module Datacite
         Identifier.new(value: match[0])
       end
 
-      def self.extract_and_set_value(obj, xml)
-        obj.value = xml.text
+      text_node :value, 'text()'
+      text_node :identifier_type, '@identifierType'
+
+      fallback_mapping :datacite_3, :_default
+    end
+
+    # Custom node to warn (but not blow up) if we read an XML `<resource/>` that's
+    # missing its `<identifier/>`.
+    class IdentifierNode < XML::Mapping::ObjectNode
+      def xml_to_obj(_obj, xml)
+        super if has_element?(xml)
       end
-      private_class_method :extract_and_set_value
 
-      text_node :identifier_type, '@identifierType'
+      private
 
-      # The default reader throws an opaque XPath error if there's no element text,
-      # so we extract it manually and let the accessor raise an error instead
-      text_node :value, 'text()', reader: method(:extract_and_set_value)
+      def has_element?(xml) # rubocop:disable Style/PredicateName
+        @path.first(xml)
+      rescue XML::XXPathError
+        warn '<identifier/> not found; add a valid Identifier to the Resource before saving'
+      end
     end
+    XML::Mapping.add_node_class IdentifierNode
   end
 end

data/lib/datacite/mapping/module_info.rb

@@ -1,12 +1,12 @@
 module Datacite
   module Mapping
     # The name of this gem
-    NAME = 'datacite-mapping'
+    NAME = 'datacite-mapping'.freeze
 
     # The version of this gem
-    VERSION = '0.1.17.2'
+    VERSION = '0.2.0'.freeze
 
     # The copyright notice for this gem
-    COPYRIGHT = 'Copyright (c) 2016 The Regents of the University of California'
+    COPYRIGHT = 'Copyright (c) 2016 The Regents of the University of California'.freeze
   end
 end

data/lib/datacite/mapping/name_identifier.rb

@@ -38,6 +38,7 @@ module Datacite
       #   @return [String] the identifier value. Cannot be nil.
       text_node :value, 'text()'
 
+      fallback_mapping :datacite_3, :_default
     end
   end
 end

data/lib/datacite/mapping/namespace_extensions.rb

@@ -0,0 +1,12 @@
+require 'xml/mapping_extensions'
+
+# TODO: port this to xml-mapping_extensions
+module XML
+  module MappingExtensions
+    class Namespace
+      def with_prefix(new_prefix)
+        Namespace.new(uri: uri, prefix: new_prefix, schema_location: schema_location)
+      end
+    end
+  end
+end

data/lib/datacite/mapping/read_only_nodes.rb

@@ -0,0 +1,65 @@
+require 'xml/mapping'
+
+module XML
+  class XXPath
+    attr_reader :xpathstr
+  end
+end
+
+module Datacite
+  module Mapping
+
+    module ReadOnlyNodes
+      def warn_reason
+        @warn_reason ||= @options[:warn_reason]
+      end
+
+      def value_from(obj)
+        obj.send(@attrname)
+      end
+
+      def value_str(val)
+        return "[ #{val.map(&:to_s).join(', ')} ]" if val.is_a?(Array)
+        "'#{val}'"
+      end
+
+      def obj_to_xml(obj, _xml)
+        val = value_from(obj)
+        return unless val
+        warn_ignored(val)
+      end
+
+      def warn_ignored(val)
+        warning = "ignoring #{@attrname} #{value_str(val)}"
+        warning.prepend("#{warn_reason}; ") if warn_reason
+        ReadOnlyNodes.warn(warning)
+      end
+
+      # public to allow testing
+      def self.warn(warning)
+        super
+      end
+    end
+
+    class ReadOnlyTextNode < XML::Mapping::TextNode
+      def warn_ignored(val)
+        fail ArgumentError, "Expected string, got #{val}" unless val.respond_to?(:strip)
+        return if val.strip.empty?
+        super
+      end
+      include ReadOnlyNodes
+    end
+    XML::Mapping.add_node_class ReadOnlyTextNode
+
+    class ReadOnlyArrayNode < XML::Mapping::ArrayNode
+      def warn_ignored(val)
+        fail ArgumentError, "Expected array, got #{val}" unless val.respond_to?(:empty?)
+        return if val.empty?
+        super
+      end
+      include ReadOnlyNodes
+    end
+    XML::Mapping.add_node_class ReadOnlyArrayNode
+
+  end
+end

data/lib/datacite/mapping/related_identifier.rb

@@ -135,8 +135,31 @@ module Datacite
       # @!parse URN = URN
       new :URN, 'URN'
 
+      # @!parse IGSN = IGSN
+      new :IGSN, 'IGSN'
     end
 
+    class Datacite3RidTypeNode < XML::MappingExtensions::TypesafeEnumNode
+      def to_xml_text(enum_instance)
+        return super unless enum_instance == RelatedIdentifierType::IGSN
+        super(RelatedIdentifierType::HANDLE)
+      end
+    end
+    XML::Mapping.add_node_class(Datacite3RidTypeNode)
+
+    class Datacite3RidValueNode < XML::Mapping::TextNode
+      def obj_to_xml(obj, xml)
+        return super unless obj.identifier_type == RelatedIdentifierType::IGSN
+        igsn_value = obj.value
+        handle_value = "10273/#{igsn_value}"
+        # TODO: move this somewhere more general
+        ReadOnlyNodes.warn("IGSN identifiers not directly supported in Datacite 3; converting IGSN #{igsn_value} to Handle #{handle_value}")
+        set_attr_value(xml, handle_value)
+        true
+      end
+    end
+    XML::Mapping.add_node_class(Datacite3RidValueNode)
+
     # Globally unique identifier of a related resource.
     class RelatedIdentifier
       include XML::Mapping
@@ -198,6 +221,11 @@ module Datacite
       #   @return [String, nil] the type of the metadata scheme. Used only with `HasMetadata`/`IsMetadataFor`. Optional.
       text_node :scheme_type, '@schemeType', default_value: nil
 
+      use_mapping :datacite_3
+      datacite3_rid_type_node :identifier_type, '@relatedIdentifierType', class: RelatedIdentifierType
+      datacite3_rid_value_node :value, 'text()'
+
+      fallback_mapping :datacite_3, :_default
     end
   end
 end

data/lib/datacite/mapping/resource.rb

@@ -1,29 +1,40 @@
 require 'xml/mapping_extensions'
-require 'datacite/mapping/alternate_identifier'
-require 'datacite/mapping/creator'
+
 require 'datacite/mapping/identifier'
-require 'datacite/mapping/nonvalidating'
-require 'datacite/mapping/related_identifier'
+require 'datacite/mapping/creator'
+require 'datacite/mapping/title'
+require 'datacite/mapping/subject'
+require 'datacite/mapping/contributor'
+require 'datacite/mapping/date'
 require 'datacite/mapping/resource_type'
+require 'datacite/mapping/alternate_identifier'
 require 'datacite/mapping/rights'
-require 'datacite/mapping/subject'
-require 'datacite/mapping/title'
+require 'datacite/mapping/geo_location'
+require 'datacite/mapping/read_only_nodes'
 
 module Datacite
   module Mapping
 
-    DATACITE_3_NAMESPACE = XML::MappingExtensions::Namespace.new(
-      uri: 'http://datacite.org/schema/kernel-3',
-      schema_location: 'http://schema.datacite.org/meta/kernel-3/metadata.xsd'
-    )
-
     # A collection of metadata properties chosen for the accurate and consistent identification
     # of a resource for citation and retrieval purposes, along with recommended use instructions.
     # The resource that is being identified can be of any kind, but it is typically a dataset.
     class Resource # rubocop:disable Metrics/ClassLength
       include XML::MappingExtensions::Namespaced
 
-      namespace DATACITE_3_NAMESPACE
+      # Shadows Namespaced::ClassMethods.namespace
+      def namespace
+        @namespace ||= DATACITE_4_NAMESPACE
+      end
+
+      # Overrides Namespaced::InstanceMethods.fill_into_xml to check mapping
+      def fill_into_xml(xml, options = { mapping: :_default })
+        if options[:mapping] == :datacite_3
+          unless namespace.uri == DATACITE_3_NAMESPACE.uri
+            @namespace = DATACITE_3_NAMESPACE.with_prefix(namespace.prefix)
+          end
+        end
+        super
+      end
 
       # Initialies a new {Resource}
       #
@@ -36,8 +47,7 @@ module Datacite
       # @param funding_references [Array<FundingReference>] information about financial support (funding) for the resource being registered.
       # @param contributors [Array<Contributor>] institutions or persons responsible for collecting, creating, or otherwise contributing to the developement of the dataset.
       # @param dates [Array<Date>] different dates relevant to the work.
-      # @param language [String] Primary language of the resource: an IETF BCP 47, ISO 639-1 language code.
-      #   It's unclear from the spec whether language is required; to play it safe, if it's missing, we default to 'en'.
+      # @param language [String, nil] Primary language of the resource: an IETF BCP 47, ISO 639-1 language code.
       # @param resource_type [ResourceType, nil] the type of the resource
       # @param alternate_identifiers [Array<AlternateIdentifier>] an identifier or identifiers other than the primary {Identifier} applied to the resource being registered.
       # @param related_identifiers [Array<RelatedIdentifier>] identifiers of related resources.
@@ -47,7 +57,7 @@ module Datacite
       # @param rights_list [Array<Rights>] rights information for this resource.
       # @param descriptions [Array<Description>] all additional information that does not fit in any of the other categories.
       # @param geo_locations [Array<GeoLocations>] spatial region or named place where the data was gathered or about which the data is focused.
-      def initialize(identifier:, creators:, titles:, publisher:, publication_year:, subjects: [], funding_references: [], contributors: [], dates: [], language: 'en', resource_type: nil, alternate_identifiers: [], related_identifiers: [], sizes: [], formats: [], version: nil, rights_list: [], descriptions: [], geo_locations: []) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists, Metrics/AbcSize
+      def initialize(identifier:, creators:, titles:, publisher:, publication_year:, subjects: [], contributors: [], dates: [], language: nil, funding_references: [], resource_type: nil, alternate_identifiers: [], related_identifiers: [], sizes: [], formats: [], version: nil, rights_list: [], descriptions: [], geo_locations: []) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists, Metrics/AbcSize
         self.identifier = identifier
         self.creators = creators
         self.titles = titles
@@ -72,17 +82,9 @@ module Datacite
       # Sets the namespace prefix to be used when writing out XML (defaults to nil)
       # @param prefix [String, nil] The new prefix, or nil to use the default,
       #   unprefixed namespace
-      def self.namespace_prefix=(prefix)
+      def namespace_prefix=(prefix)
         old_namespace = namespace
-        namespace ::XML::MappingExtensions::Namespace.new(uri: old_namespace.uri, schema_location: old_namespace.schema_location, prefix: prefix)
-      end
-
-      def language
-        @language || 'en'
-      end
-
-      def language=(value)
-        @language = value.strip if value
+        @namespace = ::XML::MappingExtensions::Namespace.new(uri: old_namespace.uri, schema_location: old_namespace.schema_location, prefix: prefix)
       end
 
       def identifier=(value)
@@ -91,18 +93,19 @@ module Datacite
       end
 
       def creators=(value)
-        fail ArgumentError, 'Resource must have at least one creator' unless value && value.size > 0
+        fail ArgumentError, 'Resource must have at least one creator' unless value && !value.empty?
         @creators = value
       end
 
       def titles=(value)
-        fail ArgumentError, 'Resource must have at least one title' unless value && value.size > 0
+        fail ArgumentError, 'Resource must have at least one title' unless value && !value.empty?
         @titles = value
       end
 
       def publisher=(value)
-        fail ArgumentError, 'Resource must have at least one publisher' unless value && value.size > 0
-        @publisher = value.strip
+        new_value = value && value.strip
+        fail ArgumentError, 'Resource must have a publisher' unless new_value && !new_value.empty?
+        @publisher = new_value.strip
       end
 
       def publication_year=(value)
@@ -110,17 +113,57 @@ module Datacite
         @publication_year = value.to_i
       end
 
-      def subjects
-        (@subjects ||= []).select(&:value)
+      def subjects=(value)
+        @subjects = (value && value.select(&:value)) || []
       end
 
-      def subjects=(value)
-        @subjects = (value || []).select(&:value)
+      def contributors=(value)
+        @contributors = value || []
+      end
+
+      def dates=(value)
+        @dates = value || []
+      end
+
+      def funding_references=(value)
+        @funding_references = value || []
+      end
+
+      def alternate_identifiers=(value)
+        @alternate_identifiers = value || []
+      end
+
+      def related_identifiers=(value)
+        @related_identifiers = value || []
+      end
+
+      def sizes=(value)
+        @sizes = value || []
+      end
+
+      def formats=(value)
+        @formats = value || []
+      end
+
+      def version=(value)
+        @version = value && value.strip
+      end
+
+      def rights_list=(value)
+        @rights_list = value || []
+      end
+
+      def descriptions=(value)
+        @descriptions = (value && value.select(&:value)) || []
+      end
+
+      def geo_locations=(value)
+        @geo_locations = (value && value.select(&:location?)) || []
       end
 
       # @!attribute [rw] identifier
       #   @return [Identifier] a persistent identifier that identifies a resource.
-      object_node :identifier, 'identifier', class: Identifier
+      identifier_node :identifier, 'identifier', class: Identifier
 
       # @!attribute [rw] creators
       #   @return [Array<Creator>] the main researchers involved working on the data, or the authors of the publication in priority order.
@@ -156,7 +199,6 @@ module Datacite
 
       # @!attribute [rw] language
       #   @return [String] Primary language of the resource: an IETF BCP 47, ISO 639-1 language code.
-      #   It's unclear from the spec whether language is required; to play it safe, if it's missing, we default to 'en'.
       text_node :language, 'language', default_value: nil
 
       # @!attribute [rw] resource_type
@@ -211,10 +253,11 @@ module Datacite
       # Convenience method to get the funding contributor.
       # @return [Contributor, nil] the contributor of type FUNDER, if any.
       def funder_contrib
-        @funder_contrib ||= contributors.find { |c| c.type == ContributorType::FUNDER }
+        contributors.find { |c| c.type == ContributorType::FUNDER }
       end
 
       # Convenience method to get the name of the funding contributor.
+      # @deprecated contributor type 'funder' is deprecated. Use {FundingReference} instead.
       # @return [String, nil] the name of the funding contributor, if any.
       def funder_name
         funder_contrib.name if funder_contrib
@@ -232,16 +275,18 @@ module Datacite
         funder_id.value if funder_id
       end
 
-      use_mapping :nonvalidating
+      extend Gem::Deprecate
+      deprecate(:funder_contrib, FundingReference, 2016, 9)
+      deprecate(:funder_name, FundingReference, 2016, 9)
+      deprecate(:funder_id, FundingReference, 2016, 9)
+      deprecate(:funder_id_value, FundingReference, 2016, 9)
 
-      # Ignore missing or invalid values
-      object_node :identifier, 'identifier', class: Nonvalidating::Identifier
-      array_node :subjects, 'subjects', 'subject', class: Nonvalidating::Subject, default_value: []
-      text_node :language, 'language', default_value: nil
+      use_mapping :datacite_3
 
-      # TODO: Handle nested contributors, date ranges (e.g. spec/data/dash1-datacite-xml/ucsf-ark+=b7272=q6bg2kwf-mrt-datacite.xml)
+      read_only_array_node :funding_references, 'fundingReferences', 'fundingReference', class: FundingReference, default_value: [], warn_reason: '<fundingReferences/> not supported in Datacite 3'
 
-      fallback_mapping :nonvalidating, :_default
+      fallback_mapping :datacite_3, :_default
     end
+
   end
 end