pbcore 0.2.0

data/lib/pbcore/errors.rb

@@ -0,0 +1,55 @@
+# PBCore Error classes and methods.
+#
+# The classes and methods in this file intend to serve the following purposes:
+#
+#  1) Provide a base class for all PBCore errors, to that host applications can
+#     easily rescue from all errors thrown by this gem.
+#  2) Provide specific error classes, with specific error messages, for specific
+#     situations. This helps developers of host applications to quickly solve
+#     bugs they may encounter when using the gem.
+#  3) Provide module specific module methods that will:
+#     a) encapsulate conditional logic for specific situaitons
+#     b) raise specific errors
+#
+# New error classes should be created as new error conditions for specific
+# situations arise. The pattern to follow should be:
+#
+#   1) Create a new error class that extends PBCore::Error.
+#   2) The error class should be named in a way that indicates the specific
+#      situation.
+#   3) The constructor of the error class should use named arguments, and include
+#      all information necessary to provide a detailed error message to
+#      developers, ideally with some kind of instruction on how to correct the
+#      problem.
+#   3) A module method should be created to encapsulate the logic need to
+#      determine if an error should be raised.
+#   4) The module name should beging with "fail_if_" or "fail_unless_", followed
+#      by the snake-case name of the specific error class to be raised.
+#   5) The module method should test the condition, and raise the specific
+#      error. This implies that the module method must also receive all
+#      information necessary to pass along to the constructor of the error
+#      class.
+
+module PBCore
+  class Error < StandardError; end
+
+  class BaseIsNotPBCoreElement < Error
+    def initialize(included_module:, base:)
+      super("#{included_module} should only be included in PBCore::Element, but was included in #{base} (ancestors are: #{base.ancestors.join(', ')})")
+    end
+  end
+
+  def self.fail_if_base_is_not_pbcore_element(included_module:, base:)
+    raise BaseIsNotPBCoreElement.new(included_module: included_module, base: base) unless base.ancestors.include? PBCore::Element
+  end
+
+  class ElementMissingBuildXMLBlock < Error
+    def initialize(element_class:)
+      super("Element class #{element_class} does not have a block for building xml. Create one by passing a block to #{element_class}.build_xml")
+    end
+  end
+
+  def self.fail_if_missing_build_xml_block(element_class:)
+    raise ElementMissingBuildXMLBlock.new(element_class: element_class) unless element_class.build_block
+  end
+end

data/lib/pbcore/extension.rb

@@ -0,0 +1,19 @@
+require 'pbcore/element'
+
+module PBCore
+  class Extension < Element
+    autoload :Wrap,      'pbcore/extension/wrap'
+    autoload :Embedded,  'pbcore/extension/embedded'
+
+    element :pbcoreExtension, as: :value
+    element :extensionWrap, as: :wrap, class: PBCore::Extension::Wrap
+    element :extensionEmbedded, as: :embedded, class: PBCore::Extension::Embedded
+
+    build_xml do |xml|
+      xml.pbcoreExtension(xml_attributes.compact) do |xml|
+        wrap.build(xml) if wrap
+        embedded.build(xml) if embedded
+      end
+    end
+  end
+end

data/lib/pbcore/extension/embedded.rb

@@ -0,0 +1,15 @@
+# NOTE: This class doesn't actually work like you might expect it to.
+# The <extensionEmbedded> element is supposed to contain XML from a different
+# (non-PBCore) schema. However, currently the SAXMachine parser will proceed
+# to parse the embedded XML rather than capture it and provide an accessor to
+# it, which is what we want to happen.
+require 'pbcore/element'
+
+module PBCore
+  class Extension::Embedded < Element
+    element :extensionEmbedded, as: :value
+    build_xml do |xml|
+      xml.extensionEmbedded(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/extension/wrap.rb

@@ -0,0 +1,26 @@
+require 'pbcore/element'
+
+module PBCore
+  class Extension::Wrap < Element
+    autoload :AuthorityUsed,      'pbcore/extension/wrap/authority_used'
+    autoload :Element,            'pbcore/extension/wrap/element'
+    autoload :Value,              'pbcore/extension/wrap/value'
+
+    element :extensionWrap, as: :value
+    # We set the accessors here to be extension_element and extension_value
+    # rather than just `extension` and `value` as the naming convention would
+    # suggest, because both `value` and `element` have special meaning for
+    # SAXMachine and we want to avoid conflict and confusion.
+    element :extensionElement, as: :extension_element, class: PBCore::Extension::Wrap::Element
+    element :extensionValue, as: :extension_value, class: PBCore::Extension::Wrap::Value
+    element :extensionAuthorityUsed, as: :authority_used, class: PBCore::Extension::Wrap::AuthorityUsed
+
+    build_xml do |xml|
+      xml.extensionWrap(xml_attributes.compact) do |xml|
+        extension_element.build(xml) if extension_element
+        extension_value.build(xml) if extension_value
+        authority_used.build(xml) if authority_used
+      end
+    end
+  end
+end

data/lib/pbcore/extension/wrap/authority_used.rb

@@ -0,0 +1,11 @@
+require 'pbcore/element'
+
+module PBCore
+  class Extension::Wrap::AuthorityUsed < Element
+    element :extensionAuthorityUsed, as: :value
+
+    build_xml do |xml|
+      xml.extensionAuthorityUsed(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/extension/wrap/element.rb

@@ -0,0 +1,11 @@
+require 'pbcore/element'
+
+module PBCore
+  class Extension::Wrap::Element < Element
+    element :extensionElement, as: :value
+
+    build_xml do |xml|
+      xml.extensionElement(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/extension/wrap/value.rb

@@ -0,0 +1,11 @@
+require 'pbcore/element'
+
+module PBCore
+  class Extension::Wrap::Value < Element
+    element :extensionValue, as: :value
+
+    build_xml do |xml|
+      xml.extensionValue(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/factories.rb

@@ -0,0 +1,6 @@
+require 'factory_bot'
+
+GEM_ROOT = File.dirname(File.dirname(File.dirname(__FILE__)))
+
+require File.join(GEM_ROOT, 'spec', 'support', 'date_time_helpers')
+Dir.glob(File.join(GEM_ROOT, 'spec', 'factories', '**', '*.rb')).each { |file| require(file) }

data/lib/pbcore/genre.rb

@@ -0,0 +1,11 @@
+require 'pbcore/element'
+
+module PBCore
+  class Genre < Element
+    element :pbcoreGenre, as: :value
+
+    build_xml do |xml|
+      xml.pbcoreGenre(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/identifier.rb

@@ -0,0 +1,11 @@
+require 'pbcore/element'
+
+module PBCore
+  class Identifier < Element
+    element :pbcoreIdentifier, as: :value
+
+    build_xml do |xml|
+      xml.pbcoreIdentifier(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/instantiation.rb

@@ -0,0 +1,87 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation < Element
+    autoload :Identifier,           'pbcore/instantiation/identifier'
+    autoload :Date,                 'pbcore/instantiation/date'
+    autoload :Dimensions,           'pbcore/instantiation/dimensions'
+    autoload :Physical,             'pbcore/instantiation/physical'
+    autoload :Digital,              'pbcore/instantiation/digital'
+    autoload :Standard,             'pbcore/instantiation/standard'
+    autoload :Location,             'pbcore/instantiation/location'
+    autoload :MediaType,            'pbcore/instantiation/media_type'
+    autoload :Generations,          'pbcore/instantiation/generations'
+    autoload :TimeStart,            'pbcore/instantiation/time_start'
+    autoload :FileSize,             'pbcore/instantiation/file_size'
+    autoload :Duration,             'pbcore/instantiation/duration'
+    autoload :DataRate,             'pbcore/instantiation/data_rate'
+    autoload :Colors,               'pbcore/instantiation/colors'
+    autoload :Tracks,               'pbcore/instantiation/tracks'
+    autoload :ChannelConfiguration, 'pbcore/instantiation/channel_configuration'
+    autoload :Language,             'pbcore/instantiation/language'
+    autoload :AlternativeModes,     'pbcore/instantiation/alternative_modes'
+    autoload :EssenceTrack,         'pbcore/instantiation/essence_track'
+    autoload :Extension,            'pbcore/instantiation/extension'
+    autoload :Relation,             'pbcore/instantiation/relation'
+    autoload :Rights,               'pbcore/instantiation/rights'
+    autoload :Annotation,           'pbcore/instantiation/annotation'
+
+    element :pbcoreInstantiation, as: :value
+    elements :instantiationIdentifier, as: :identifiers, class: PBCore::Instantiation::Identifier
+    elements :instantiationDate, as: :dates, class: PBCore::Instantiation::Date
+    elements :instantiationDimensions, as: :dimensions, class: PBCore::Instantiation::Dimensions
+    element  :instantiationPhysical, as: :physical, class: PBCore::Instantiation::Physical
+    element  :instantiationDigital, as: :digital, class: PBCore::Instantiation::Digital
+    element  :instantiationStandard, as: :standard, class: PBCore::Instantiation::Standard
+    element  :instantiationLocation, as: :location, class: PBCore::Instantiation::Location
+    element  :instantiationMediaType, as: :media_type, class: PBCore::Instantiation::MediaType
+    elements :instantiationGenerations, as: :generations, class: PBCore::Instantiation::Generations
+    elements :instantiationTimeStart, as: :time_starts, class: PBCore::Instantiation::TimeStart
+    element  :instantiationFileSize, as: :file_size, class: PBCore::Instantiation::FileSize
+    element  :instantiationDuration, as: :duration, class: PBCore::Instantiation::Duration
+    element  :instantiationDataRate, as: :data_rate, class: PBCore::Instantiation::DataRate
+    element  :instantiationColors, as: :colors, class: PBCore::Instantiation::Colors
+    element  :instantiationTracks, as: :tracks, class: PBCore::Instantiation::Tracks
+    element  :instantiationChannelConfiguration, as: :channel_configuration, class: PBCore::Instantiation::ChannelConfiguration
+    elements :instantiationLanguage, as: :languages, class: PBCore::Instantiation::Language
+    element  :instantiationAlternativeModes, as: :alternative_modes, class: PBCore::Instantiation::AlternativeModes
+    elements :instantiationEssenceTrack, as: :essence_tracks, class: PBCore::Instantiation::EssenceTrack
+    elements :instantiationExtension, as: :extensions, class: PBCore::Instantiation::Extension
+    elements :instantiationRelation, as: :relations, class: PBCore::Instantiation::Relation
+    elements :instantiationRights, as: :rights, class: PBCore::Instantiation::Rights
+    elements :instantiationAnnotation, as: :annotations, class: PBCore::Instantiation::Annotation
+
+    include PBCore::Attributes::TimeInterval
+
+    build_xml do |xml|
+      xml.pbcoreInstantiation(xml_attributes.compact) do |xml|
+        identifiers.each { |identifier| identifier.build(xml) }
+        dates.each { |date| date.build(xml) }
+        dimensions.each { |dimensions_element| dimensions_element.build(xml) }
+        physical.build(xml) if physical
+        digital.build(xml) if digital
+        standard.build(xml) if standard
+        location.build(xml) if location
+        media_type.build(xml) if media_type
+        generations.each { |generations_element| generations_element.build(xml) }
+        file_size.build(xml) if file_size
+        time_starts.each { |time_start| time_start.build(xml) }
+        duration.build(xml) if duration
+        data_rate.build(xml) if data_rate
+        colors.build(xml) if colors
+        tracks.build(xml) if tracks
+        channel_configuration.build(xml) if channel_configuration
+        languages.each { |language| language.build(xml) }
+        alternative_modes.build(xml) if alternative_modes
+        essence_tracks.each { |essence_track| essence_track.build(xml) }
+        # TODO: no instrelation?!!
+
+        # ??? this seems to render correctly according to pbcore.org, but doesnt pass schema validation
+        rights.each { |right| right.build(xml) }
+        annotations.each { |annotation| annotation.build(xml) }
+        # TODO: no instpart?!?
+        extensions.each { |extension| extension.build(xml) }
+      end
+    end
+  end
+end

data/lib/pbcore/instantiation/alternative_modes.rb

@@ -0,0 +1,11 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation::AlternativeModes < Element
+    element :instantiationAlternativeModes, as: :value
+
+    build_xml do |xml|
+      xml.instantiationAlternativeModes(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/instantiation/annotation.rb

@@ -0,0 +1,12 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation::Annotation < Element
+    element :instantiationAnnotation, as: :value
+    attribute :annotationType, as: :type
+
+    build_xml do |xml|
+      xml.instantiationAnnotation(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/instantiation/channel_configuration.rb

@@ -0,0 +1,11 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation::ChannelConfiguration < Element
+    element :instantiationChannelConfiguration, as: :value
+
+    build_xml do |xml|
+      xml.instantiationChannelConfiguration(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/instantiation/colors.rb

@@ -0,0 +1,11 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation::Colors < Element
+    element :instantiationColors, as: :value
+
+    build_xml do |xml|
+      xml.instantiationColors(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/instantiation/data_rate.rb

@@ -0,0 +1,13 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation::DataRate < Element
+    element :instantiationDataRate, as: :value
+
+    attribute :unitsOfMeasure, as: :units_of_measure
+
+    build_xml do |xml|
+      xml.instantiationDataRate(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/instantiation/date.rb

@@ -0,0 +1,13 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation::Date < Element
+    element :instantiationDate, as: :value
+
+    attribute :dateType, as: :type
+
+    build_xml do |xml|
+      xml.instantiationDate(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/instantiation/digital.rb

@@ -0,0 +1,11 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation::Digital < Element
+    element :instantiationDigital, as: :value
+
+    build_xml do |xml|
+      xml.instantiationDigital(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/instantiation/dimensions.rb

@@ -0,0 +1,13 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation::Dimensions < Element
+    element :instantiationDimensions, as: :value
+
+    attribute :unitsOfMeasure, as: :units_of_measure
+
+    build_xml do |xml|
+      xml.instantiationDimensions(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/instantiation/duration.rb

@@ -0,0 +1,11 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation::Duration < Element
+    element :instantiationDuration, as: :value
+
+    build_xml do |xml|
+      xml.instantiationDuration(value, xml_attributes.compact)
+    end
+  end
+end

data/lib/pbcore/instantiation/essence_track.rb

@@ -0,0 +1,59 @@
+require 'pbcore/element'
+
+module PBCore
+  class Instantiation::EssenceTrack < Element
+    autoload :Type,           'pbcore/instantiation/essence_track/type'
+    autoload :Identifier,     'pbcore/instantiation/essence_track/identifier'
+    autoload :Standard,       'pbcore/instantiation/essence_track/standard'
+    autoload :Encoding,       'pbcore/instantiation/essence_track/encoding'
+    autoload :DataRate,       'pbcore/instantiation/essence_track/data_rate'
+    autoload :FrameRate,      'pbcore/instantiation/essence_track/frame_rate'
+    autoload :PlaybackSpeed,  'pbcore/instantiation/essence_track/playback_speed'
+    autoload :SamplingRate,   'pbcore/instantiation/essence_track/sampling_rate'
+    autoload :BitDepth,       'pbcore/instantiation/essence_track/bit_depth'
+    autoload :FrameSize,      'pbcore/instantiation/essence_track/frame_size'
+    autoload :Duration,       'pbcore/instantiation/essence_track/duration'
+    autoload :AspectRatio,    'pbcore/instantiation/essence_track/aspect_ratio'
+    autoload :TimeStart,      'pbcore/instantiation/essence_track/time_start'
+    autoload :Language,       'pbcore/instantiation/essence_track/language'
+    autoload :Annotation,     'pbcore/instantiation/essence_track/annotation'
+
+    element  :instantiationEssenceTrack, as: :value
+    element  :essenceTrackType, as: :type, class: PBCore::Instantiation::EssenceTrack::Type
+    elements :essenceTrackIdentifier, as: :identifiers, class: PBCore::Instantiation::EssenceTrack::Identifier
+    element  :essenceTrackStandard, as: :standard, class: PBCore::Instantiation::EssenceTrack::Standard
+    element  :essenceTrackEncoding, as: :encoding, class: PBCore::Instantiation::EssenceTrack::Encoding
+    element  :essenceTrackDataRate, as: :data_rate, class: PBCore::Instantiation::EssenceTrack::DataRate
+    element  :essenceTrackFrameRate, as: :frame_rate, class: PBCore::Instantiation::EssenceTrack::FrameRate
+    element  :essenceTrackPlaybackSpeed, as: :playback_speed, class: PBCore::Instantiation::EssenceTrack::PlaybackSpeed
+    element  :essenceTrackSamplingRate, as: :sampling_rate, class: PBCore::Instantiation::EssenceTrack::SamplingRate
+    element  :essenceTrackBitDepth, as: :bit_depth, class: PBCore::Instantiation::EssenceTrack::BitDepth
+    element  :essenceTrackFrameSize, as: :frame_size, class: PBCore::Instantiation::EssenceTrack::FrameSize
+    element  :essenceTrackDuration, as: :duration, class: PBCore::Instantiation::EssenceTrack::Duration
+    element  :essenceTrackAspectRatio, as: :aspect_ratio, class: PBCore::Instantiation::EssenceTrack::AspectRatio
+    element  :essenceTrackTimeStart, as: :time_start, class: PBCore::Instantiation::EssenceTrack::TimeStart
+    elements :essenceTrackLanguage, as: :languages, class: PBCore::Instantiation::EssenceTrack::Language
+    elements :essenceTrackAnnotation, as: :annotations, class: PBCore::Instantiation::EssenceTrack::Annotation
+
+    build_xml do |xml|
+      xml.instantiationEssenceTrack(xml_attributes.compact) do |xml|
+        type.build(xml) if type
+        identifiers.each { |identifier| identifier.build(xml) }
+        standard.build(xml) if standard
+        encoding.build(xml) if encoding
+        data_rate.build(xml) if data_rate
+        frame_rate.build(xml) if frame_rate
+        playback_speed.build(xml) if playback_speed
+        sampling_rate.build(xml) if sampling_rate
+        bit_depth.build(xml) if bit_depth
+        frame_size.build(xml) if frame_size
+        aspect_ratio.build(xml) if aspect_ratio
+        time_start.build(xml) if time_start
+        duration.build(xml) if duration
+        languages.each { |language| language.build(xml) }
+        annotations.each { |annotation| annotation.build(xml) }
+        # TODO: no essen extension!?!
+      end
+    end
+  end
+end