ddex 0.0.3 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 150517e6ad7e3e4b1d1459510a1821bc763f56f5
-  data.tar.gz: a358625bc61cd33c7ebe536833a81d4bea84fecb
+SHA256:
+  metadata.gz: 4bdfafd4654d53de0fdf4e54fe13e9ea4905a49fdaedd7b5a0959e9285710421
+  data.tar.gz: e9491cd2e2bc6ad0dffeee9a017c98cb4dd861f0a57bea1d4ef896b3c75b3ea1
 SHA512:
-  metadata.gz: 22890ce0fb8f9bda77e1871e84ea7d4aee5679133969f84b2ea99cc73125c9add58d3ae275bb42205947ab7105693fc1922a3d6c85d03902c77a770d198a6d03
-  data.tar.gz: 929cad35948bd35c3a6cb25cab646bbd18256ed601e3f4bdd6c2e9acf2e564c63bafd97d7786447b8e7881bb8c98f2717831cea8f63349db8f499045e03cc8be
+  metadata.gz: ae66a3b38b68f93e0b928e43894b8f78e3f33b4d31c359774b8b9e3fd8220bce182c82a46f995c6f4206a70a69646815769a937e9676f45eb795e7bbde67a4dd
+  data.tar.gz: 1462c5a7d3c4a37985ad9b84eeb360eca90cb9e6d43b723d7b2b26408e0191f7a060ccbc29755cb66e8c9d3a98c91fa4acf115dfd0225d4b482b4ad5bfdaf7f7

data/README.rdoc

@@ -44,7 +44,7 @@ Bundler:
 
 === Supported Versions
 
-Currently just ERN 3.3 - 3.7, DSR soon!
+See: https://github.com/sshaw/ddex/tree/master/lib/ddex
 
 === How This Differs From the Spec
 
@@ -107,17 +107,28 @@ For example, <code>SoundRecording/IsArtistRelated</code>:
 
 These changes only affect the object model, the resulting XML will conform to the appropriate DDEX schema.
 
-===== ERN >= v3.6
+===== ERN >= v3.6 < v4.0
 
 <code>PriceInformation/@PriceType</code> has been renamed to <code>PriceInformation#type</code> to avoid conflicting with the
 element of the same name (<code>PriceInformation/PriceType</code>).
 
 === Specification Version Detection
 
-The specification version is determined by the <code>MessageSchemaVersionId</code>, which can be:
+An attempt is made to detect the version. How this is done varies by spec and version. See below for details.
 
-1. Detected based on the root element's value i.e., <code>/node()/@MessageSchemaVersionId</code> (the root element varies by specification)
-2. Explicitly given to DDEX.read via the <code>:version</code> option
+The version can always be explicitly given to <code>DDEX.read</code> via the <code>:version</code> option.
+
+==== ERN >= 4
+
+Version is determined by the DDEX XML namespace associated with the doc.
+
+For example, given a namespace of: <code>http://ddex.net/xml/ern/41</code> we'll try to match the end, either
+<code>"ern/41"</code> or <code>"ern/41/"</code>. The values used to match the come from
+<code>DDEX::ERN.config[V][:message_schema_version_id]</code> where <code>V</code> is a version string, e.g., <code>"V41"</code>.
+
+==== ERN < 4
+
+The version is detected based on the root element's value i.e., <code>/node()/@MessageSchemaVersionId</code>.
 
 By default the <code>MessageSchemaVersionId</code> is assumed to be in <code>SPEC/VERSION</code> or <code>VERSION</code> format
 (any leading, trailing, or duplicate slashes will be stripped), as this seems to be the convention used by most instance docs -though the DDEX specifications
@@ -130,9 +141,6 @@ that vary from this format, and explicitly setting the version is not practical,
 
 Note that the version key must match the version's module name.
 
-Feel free to {open an issue}[https://github.com/sshaw/ddex/issues] if you feel this arrangement is problematic or should
-be modified to accommodate something else.
-
 === Validation
 
 Not yet!
@@ -192,10 +200,19 @@ See CONTRIBUTING.md
 
   Raised here: https://github.com/Empact/roxml/blob/v2.5.1/lib/roxml/xml/references.rb#L262
 
+=== See Also
+
+* {grid-number}[https://github.com/ScreenStaring/grid-number] - Class for managing Global Release Identifiers
+* {iTunes Store Transporter: GUI}[http://transportergui.com] - GUI and workflow automation for the iTunes Store’s Transporter (+iTMSTransporter+)
+
 === Author
 
 Skye Shaw  [skye.shaw {AT} gmail.com]
 
 === License
 
-Copyright (c) 2013 Skye Shaw. Released under the {MIT License}[www.opensource.org/licenses/MIT].
+Copyright (c) 2013-2020 Skye Shaw. Released under the {MIT License}[www.opensource.org/licenses/MIT].
+
+---
+
+Made by {ScreenStaring}[http://screenstaring.com]

data/lib/ddex/element.rb

@@ -75,7 +75,7 @@ module DDEX
           value.respond_to?(:to_hash) ? value.to_hash : value
         end
 
-        hash[attr.attr_name.to_sym] = value unless value.nil?
+        hash[attr.attr_name.to_sym] = value if value.present?
       end
 
       hash
@@ -89,7 +89,9 @@ module DDEX
       eql?(other)
     end
 
-    # TODO: hash()
+    def hash
+      to_hash.hash
+    end
 
     private
     def roxml_attributes

data/lib/ddex/ern.rb

@@ -3,20 +3,58 @@ require "nokogiri"
 
 module DDEX
   module ERN
+    autoload :V32,  "ddex/ern/v32"
     autoload :V33,  "ddex/ern/v33"
     autoload :V34,  "ddex/ern/v34"
     autoload :V341, "ddex/ern/v341"
     autoload :V35,  "ddex/ern/v35"
     autoload :V351, "ddex/ern/v351"
     autoload :V36,  "ddex/ern/v36"
+    autoload :V371,  "ddex/ern/v371"
+    autoload :V37D2,  "ddex/ern/v37_d2"
     autoload :V37,  "ddex/ern/v37"
     autoload :V38,  "ddex/ern/v38"
     autoload :V381,  "ddex/ern/v381"
+    autoload :V382,  "ddex/ern/v382"
+    autoload :V383,  "ddex/ern/v383"
+    autoload :V41,  "ddex/ern/v41"
+    autoload :V411,  "ddex/ern/v411"
+    autoload :V42,  "ddex/ern/v42"
 
     ROOT_ELEMENT = "NewReleaseMessage".freeze
     VERSION_ATTR = "MessageSchemaVersionId".freeze
 
     DEFAULT_CONFIG  = {
+      "V42" => {
+        :schema => "http://ddex.net/xml/ern/42/release-notification.xsd",
+        :version => "4.2",
+        :message_schema_version_id => "ern/42"
+      },
+
+      "V411" => {
+        :schema => "http://service.ddex.net/xml/ern/411/release-notification.xsd",
+        :version => "4.1.1",
+        :message_schema_version_id => "ern/411"
+      },
+
+      "V41" => {
+        :schema => "http://service.ddex.net/xml/ern/41/release-notification.xsd",
+        :version => "4.1",
+        :message_schema_version_id => "ern/41"
+      },
+
+      "V383" => {
+        :schema => "http://ddex.net/xml/ern/383/release-notification.xsd",
+        :version => "3.8.3",
+        :message_schema_version_id => "ern/383"
+      },
+
+      "V382" => {
+        :schema => "http://ddex.net/xml/ern/382/release-notification.xsd",
+        :version => "3.8.2",
+        :message_schema_version_id => "ern/382"
+      },
+
       "V381" => {
         :schema => "http://ddex.net/xml/ern/381/release-notification.xsd",
         :version => "3.8.1",
@@ -29,6 +67,18 @@ module DDEX
         :message_schema_version_id => "ern/38"
       },
 
+      "V371" => {
+        :schema => "http://ddex.net/xml/ern/371/release-notification.xsd",
+        :version => "3.7.1",
+        :message_schema_version_id => "ern/371"
+      },
+
+      "V37D2" => {
+        :schema => "http://ddex.net/xml/ern/37D2/release-notification.xsd",
+        :version => "3.7D2",
+        :message_schema_version_id => "ern/37D2"
+      },
+
       "V37" => {
         :schema => "http://ddex.net/xml/ern/37/release-notification.xsd",
         :version => "3.7",
@@ -69,106 +119,130 @@ module DDEX
         :schema => "http://ddex.net/xml/2011/ern-main/33/ern-main.xsd",
         :version => "3.3",
         :message_schema_version_id => "2011/ern-main/33"
+      },
+
+      "V32" => {
+        :schema => "http://ddex.net/xml/2010/ern-main/32/ern-main.xsd",
+        :version => "3.2",
+        :message_schema_version_id => "2010/ern-main/32"
       }
     }.freeze
 
     mattr_reader :config
     @@config = DEFAULT_CONFIG
 
-    def self.supported_versions
-      config.values.map { |cfg| cfg[:version].dup }.sort
-    end
+    class << self
+      def supported_versions
+        config.values.map { |cfg| cfg[:version].dup }.sort
+      end
 
-    def self.supports?(version)
-      version = version.downcase.strip
-      config.any? { |name,cfg| name == version || cfg[:version] == version || cfg[:message_schema_version_id] == version }
-    end
+      def supports?(version)
+        version = version.to_s.downcase.strip
+        config.any? { |name,cfg| name == version || cfg[:version] == version || cfg[:message_schema_version_id] == version }
+      end
 
-    # options[:validate] ???
-    def self.read(xml, options = nil)
-      options ||= {}
-      raise ArgumentError, "options must be a Hash" unless options.is_a?(Hash)
-
-      doc   = parse(xml, options)
-      ver   = options[:version] || doc.root[VERSION_ATTR]
-      klass = load_version(ver)
-
-      begin
-        klass.from_xml(doc)
-      rescue NoMethodError => e         # Yes, fo real... this is from ROXML
-        raise unless e.name == :root    # It's legit
-        raise XMLLoadError, "XML is not well-formed"
-      # This is a subclass of Exception(!) so we must name it
-      rescue ROXML::RequiredElementMissing => e
-        raise XMLLoadError, "missing required element: #{e}"
+      # options[:validate] ???
+      def read(xml, options = nil)
+        options ||= {}
+        raise ArgumentError, "options must be a Hash" unless options.is_a?(Hash)
+
+        doc   = parse(xml, options)
+        ver   = options[:version] || find_version(doc)
+        klass = load_version(ver)
+
+        begin
+          klass.from_xml(doc)
+        rescue NoMethodError => e         # Yes, 4 real... this is from ROXML
+          raise unless e.name == :root    # It's legit
+          raise XMLLoadError, "XML is not well-formed"
+        # This is a subclass of Exception(!) so we must name it
+        rescue ROXML::RequiredElementMissing => e
+          raise XMLLoadError, "missing required element: #{e}"
+        end
       end
-    end
 
-    def self.write(object, options = nil)
-      raise ArgumentError, "not a DDEX object" unless object.is_a?(DDEX::Element)
+      def write(object, options = nil)
+        raise ArgumentError, "not a DDEX object" unless object.is_a?(DDEX::Element)
 
-      options ||= {}
-      raise ArgumentError, "options must be a Hash" unless options.is_a?(Hash)
+        options ||= {}
+        raise ArgumentError, "options must be a Hash" unless options.is_a?(Hash)
 
-      xmlopts = options.reject { |k, _| k == :schema }
+        xmlopts = options.reject { |k, _| k == :schema }
 
-      node = object.to_xml
-      return node.to_xml(xmlopts) unless object.respond_to?(:message_schema_version_id) # Is it the root element?
+        node = object.to_xml
+        return node.to_xml(xmlopts) unless object.class.name.demodulize == ROOT_ELEMENT
 
-      schema = schema_location(object, options[:schema])
-      if schema
-        node.add_namespace_definition(XML_SCHEMA_INSTANCE_PREFIX, XML_SCHEMA_INSTANCE_NS)
-        node[XML_SCHEMA_INSTANCE_ATTR] = schema
+        schema = schema_location(object, options[:schema])
+        if schema
+          node.add_namespace_definition(XML_SCHEMA_INSTANCE_PREFIX, XML_SCHEMA_INSTANCE_NS)
+          node[XML_SCHEMA_INSTANCE_ATTR] = schema
+        end
+
+        doc = Nokogiri::XML::Document.new
+        doc.root = node
+        doc.to_xml(xmlopts)
       end
 
-      doc = Nokogiri::XML::Document.new
-      doc.root = node
-      doc.to_xml(xmlopts)
-    end
+      private
 
-    private
-    def self.schema_location(object, schema)
-      # extract version from namespace e.g., DDEX::ERN::V36::NewReleaseMessage
-      ver = object.class.name.split("::")[-2]
-      return unless schema or config.include?(ver)
-
-      # Check if it's "NS schema"
-      if schema && schema.strip.include?(" ")
-        schema
-      else
-        sprintf "%s %s", object.class.ns[1], schema || config[ver][:schema]
+      def schema_location(object, schema)
+        # extract version from namespace e.g., DDEX::ERN::V36::NewReleaseMessage
+        ver = object.class.name.split("::")[-2]
+        return unless schema or config.include?(ver)
+
+        # Check if it's "NS schema"
+        if schema && schema.strip.include?(" ")
+          schema
+        else
+          sprintf "%s %s", object.class.ns[1], schema || config[ver][:schema]
+        end
       end
-    end
 
-    def self.parse(xml, options)
-      xml = File.read(xml) if xml.is_a?(String) and xml !~ /\A\s*<[?\w]/
-      Nokogiri::XML(xml, nil, options[:encoding]) { |cfg| cfg.strict }
-    # ArgumentError means there was a problem with types, expected an int, got a str
-    rescue IOError, SystemCallError, ArgumentError => e
-      raise XMLLoadError, "cannot load XML: #{e}"
-    rescue Nokogiri::XML::SyntaxError => e
-      raise XMLLoadError, "XML parsing error: #{e}"
-    end
+      def find_version(doc)
+        return doc.root[VERSION_ATTR] if doc.root[VERSION_ATTR]
 
-    def self.raise_unknown_version(version)
-      message = "ERN version %s" % (version ? "'#{version}'" : "attribute missing")
-      raise UnknownVersionError, message
-    end
+        # Versions >= 4 don't have VERSION_ATTR so we resort to looking at namespaces.
+        # For example, given: http://ddex.net/xml/ern/41
+        # We'll try to match the end: "ern/41" or "ern/41/"
+        names = doc.collect_namespaces.values
+        version = config.values.find do |cfg|
+          names.any? { |name| name =~ %r|#{ Regexp.quote(cfg[:message_schema_version_id]) }/?\z|i }
+        end
+
+        return unless version
+        version[:message_schema_version_id]
+      end
 
-    def self.load_version(version)
-      raise_unknown_version(version) if version.nil?
+      def parse(xml, options)
+        xml = File.read(xml) if xml.is_a?(String) and xml !~ /\A\s*<[?\w]/
+        Nokogiri::XML(xml, nil, options[:encoding]) { |cfg| cfg.strict }
+      # ArgumentError means there was a problem with types, expected an int, got a str
+      rescue IOError, SystemCallError, ArgumentError => e
+        raise XMLLoadError, "cannot load XML: #{e}"
+      rescue Nokogiri::XML::SyntaxError => e
+        raise XMLLoadError, "XML parsing error: #{e}"
+      end
 
-      # Some normalization
-      v = version.strip.gsub(%r{//+}, "/").gsub(%r{\A/|/\Z}, "")
-      klass, _ = config.find do |name, cfg|
-        cfg[:message_schema_version_id] == v || cfg[:version] == v
+      def raise_unknown_version(version)
+        message = "ERN version %s" % (version ? "'#{version}' is unsupported" : "attribute missing")
+        raise UnknownVersionError, message
       end
-      raise_unknown_version(version) unless klass
 
-      # >= 2.0 allows for one call
-      DDEX::ERN.const_get(klass).const_get(ROOT_ELEMENT)
-    rescue LoadError, NameError => e
-      raise_unknown_version(version)
+      def load_version(version)
+        raise_unknown_version(version) if version.nil?
+
+        # Some normalization
+        v = version.strip.gsub(%r{//+}, "/").gsub(%r{\A/|/\Z}, "")
+        klass, _ = config.find do |name, cfg|
+          cfg[:message_schema_version_id] == v || cfg[:version] == v
+        end
+        raise_unknown_version(version) unless klass
+
+        # >= 2.0 allows for one call
+        DDEX::ERN.const_get(klass).const_get(ROOT_ELEMENT)
+      rescue LoadError, NameError => e
+        raise_unknown_version(version)
+      end
     end
   end
 end

data/lib/ddex/ern/v312/collection.rb

@@ -0,0 +1,62 @@
+#
+# Auto-generated by jaxb2ruby v0.0.1 on 2018-05-21 00:10:12 -0400
+# https://github.com/sshaw/jaxb2ruby
+#
+#
+# DO NOT MODIFY
+# Automatically generated by jaxb2ruby v0.0.1 (https://github.com/sshaw/jaxb2ruby)
+#
+
+require "roxml"
+require "ddex/element"
+
+require "ddex/ern/v312/collection_details_by_territory"
+require "ddex/ern/v312/collection_resource_reference_list"
+require "ddex/ern/v312/collection_work_reference_list"
+require "ddex/v20100121/ddexc/c_line"
+require "ddex/v20100121/ddexc/character"
+require "ddex/v20100121/ddexc/collection_collection_reference_list"
+require "ddex/v20100121/ddexc/collection_id"
+require "ddex/v20100121/ddexc/collection_type"
+require "ddex/v20100121/ddexc/event_date"
+require "ddex/v20100121/ddexc/p_line"
+require "ddex/v20100121/ddexc/resource_contributor"
+require "ddex/v20100121/ddexc/title"
+
+module DDEX module ERN module V312  # :nodoc: all
+
+class DDEX::ERN::V312::Collection < Element
+  include ROXML
+
+
+  xml_name "Collection"
+
+      xml_accessor :collection_ids, :as => [DDEX::V20100121::DDEXC::CollectionId], :from => "CollectionId", :required => true
+      xml_accessor :collection_types, :as => [DDEX::V20100121::DDEXC::CollectionType], :from => "CollectionType", :required => false
+      xml_accessor :collection_reference, :from => "CollectionReference", :required => true
+      xml_accessor :titles, :as => [DDEX::V20100121::DDEXC::Title], :from => "Title", :required => false
+      xml_accessor :contributors, :as => [DDEX::V20100121::DDEXC::ResourceContributor], :from => "Contributor", :required => false
+      xml_accessor :characters, :as => [DDEX::V20100121::DDEXC::Character], :from => "Character", :required => false
+      xml_accessor :collection_collection_reference_list, :as => DDEX::V20100121::DDEXC::CollectionCollectionReferenceList, :from => "CollectionCollectionReferenceList", :required => false
+      xml_accessor :complete?, :from => "IsComplete", :required => false
+      xml_accessor :duration, :from => "Duration", :required => false
+      xml_accessor :duration_of_musical_content, :from => "DurationOfMusicalContent", :required => false
+      xml_accessor :creation_date, :as => DDEX::V20100121::DDEXC::EventDate, :from => "CreationDate", :required => false
+      xml_accessor :original_release_date, :as => DDEX::V20100121::DDEXC::EventDate, :from => "OriginalReleaseDate", :required => false
+      xml_accessor :original_language, :from => "OriginalLanguage", :required => false
+      xml_accessor :collection_details_by_territories, :as => [DDEX::ERN::V312::CollectionDetailsByTerritory], :from => "CollectionDetailsByTerritory", :required => false
+      xml_accessor :collection_resource_reference_list, :as => DDEX::ERN::V312::CollectionResourceReferenceList, :from => "CollectionResourceReferenceList", :required => false
+      xml_accessor :collection_work_reference_list, :as => DDEX::ERN::V312::CollectionWorkReferenceList, :from => "CollectionWorkReferenceList", :required => false
+      xml_accessor :representative_image_reference, :from => "RepresentativeImageReference", :required => false
+      xml_accessor :p_line, :as => DDEX::V20100121::DDEXC::PLine, :from => "PLine", :required => false
+      xml_accessor :c_line, :as => DDEX::V20100121::DDEXC::CLine, :from => "CLine", :required => false
+
+
+  
+      xml_accessor :language_and_script_code, :from => "@LanguageAndScriptCode", :required => false
+    
+  
+
+end
+
+end end end