xsd-reader 0.0.1 → 0.1.0

data/spec/extension_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe XsdReader::Extension do
+  let(:reader){
+    XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-v32', 'ern-main.xsd')))
+  }
+
+  let(:element){
+    reader['NewReleaseMessage']['ResourceList']['SoundRecording']['SoundRecordingDetailsByTerritory']
+  }
+
+  let(:extension){
+    element.complex_type.complex_content.extension
+  }
+
+  describe "#linked_complex_type" do
+    it "finds linked complex typesfom imported schemas" do
+      expect(extension.base).to eq 'ddexC:SoundRecordingDetailsByTerritory'
+      expect(extension.linked_complex_type.name).to eq 'SoundRecordingDetailsByTerritory'
+      expect(extension.linked_complex_type.schema).to be extension.schema.imports[1].reader.schema
+    end
+  end
+
+  describe "#ordered_elements" do
+    it "includes elements at the start from imported linked comlex type" do
+      expect(extension.ordered_elements.map(&:name)).to eq ["TerritoryCode", "ExcludedTerritoryCode", "Title", "DisplayArtist", "ResourceContributor", "IndirectResourceContributor", "RightsAgreementId", "LabelName", "RightsController", "RemasteredDate", "OriginalResourceReleaseDate", "PLine", "CourtesyLine", "SequenceNumber", "HostSoundCarrier", "MarketingComment", "Genre", "ParentalWarningType", "AvRating", "TechnicalSoundRecordingDetails", "FulfillmentDate", "Keywords", "Synopsis"]
+    end
+  end
+end # describe XsdReader::Extension

data/spec/import_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe XsdReader::Import do
+  let(:reader){
+    XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-v36', 'ddex-ern-v36.xsd')))
+  }
+
+  let(:import){
+    reader.imports[0]
+  }
+
+  it "gives the namespace" do
+    expect(import.namespace).to eq 'http://ddex.net/xml/avs/avs'
+  end
+
+  it "gives the schema location" do
+    expect(import.schema_location).to eq 'avs.xsd'
+  end
+
+  it "gives a download uri" do
+    expect(import.uri).to eq 'http://ddex.net/xml/avs/avs.xsd'
+  end
+
+  it "gives a reader for the external XSD" do
+    expect(import.reader.class).to eq XsdReader::XML
+  end
+
+  it "gives a download_path to save the imported xsd file to, if an xsd_file options is provided, containing the path to the parent xsd" do
+    expect(import.options[:xsd_file]).to eq reader.options[:xsd_file]
+    expect(import.download_path).to eq File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-v36', 'avs.xsd'))
+  end
+
+  it "downloads related xsd files" do
+    r1 = XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-v36', 'avs.xsd')))
+    r2 = import.reader
+    expect(r1.elements.map(&:name)).to eq r2.elements.map(&:name)
+    expect(r1.simple_types.map(&:name)).to eq r2.simple_types.map(&:name)
+  end
+
+  it "automatically saves related xsd content" do
+    skip 'downloading test disabled for efficiency'
+    FileUtils.rm(import.download_path) if File.exist?(import.download_path)
+    # To get the reaed, the import object has to download the XSD data first,
+    # which is automatically saved locally
+    expect(import.reader.options[:xsd_file]).to eq File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'avs.xsd'))
+    expect(File.file?(import.download_path)).to eq true
+  end
+end # describe XsdReader::Import

data/spec/schema_spec.rb

@@ -1,17 +1,71 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe XsdReader do
-  before :all do
-    @reader ||= XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-ern-v36.xsd')))
+describe XsdReader::Schema do
+  let(:reader){
+    XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-v36', 'ddex-ern-v36.xsd')))
+  }
+
+  let(:schema){
+    reader.schema
+  }
+
+  describe "#elements" do
+    it "gives a element readers" do
+      expect(schema.elements.map(&:class)).to eq [XsdReader::Element]*2
+    end
+  end
+
+  describe '#target_namespace' do
+    it "gives the target namespace" do
+      expect(schema.target_namespace).to eq 'http://ddex.net/xml/ern/36'
+    end
   end
 
-  describe XsdReader::Schema do
-    before :each do
-      @schema = @reader.schema
+  describe '#namespaces' do
+    it 'returns a hash of namespace shortcuts' do
+      expect(schema.namespaces).to eq({
+        'xmlns:xs' => "http://www.w3.org/2001/XMLSchema",
+        'xmlns:ern' => "http://ddex.net/xml/ern/36",
+        'xmlns:avs' => "http://ddex.net/xml/avs/avs"
+      })
     end
+  end
 
-    it "gives a element readers" do
-      expect(@schema.elements.map(&:class)).to eq [XsdReader::Element]*2
+  describe "#import_by_namespace" do
+    it "returns import objects for the given namespace" do
+      import = schema.import_by_namespace('http://ddex.net/xml/avs/avs')
+      expect(import.class).to eq XsdReader::Import
+      expect(import.namespace).to eq 'http://ddex.net/xml/avs/avs'
+      expect(import.reader.schema.target_namespace).to eq 'http://ddex.net/xml/avs/avs'
+      expect(import).to be schema.imports[0]
     end
+
+    it "returns import objects for given namespace codes" do
+      import = schema.import_by_namespace('avs')
+      expect(import.class).to eq XsdReader::Import
+      expect(import.namespace).to eq 'http://ddex.net/xml/avs/avs'
+      expect(import.reader.schema.target_namespace).to eq 'http://ddex.net/xml/avs/avs'
+      expect(import).to be schema.imports[0]
+    end
+
+    it "returns import objects for given namespace codes with xmlns prefix" do
+      import = schema.import_by_namespace('xmlns:avs')
+      expect(import.class).to eq XsdReader::Import
+      expect(import.namespace).to eq 'http://ddex.net/xml/avs/avs'
+      expect(import.reader.schema.target_namespace).to eq 'http://ddex.net/xml/avs/avs'
+      expect(import).to be schema.imports[0]
+    end
+
+    it "returns nil when no matching import is found" do
+      expect(schema.import_by_namespace('foo')).to eq nil
+    end
+
+    it "returns nil when a nil namespace is given" do
+      expect(schema.import_by_namespace(nil)).to eq nil
+    end
+  end
+
+  it "includes imported definitions as if they were local" do
+    expect(schema.simple_types.map(&:name)).to eq ["ddex_LocalCollectionAnchorReference", "ddex_LocalResourceAnchorReference", "AccessLimitation", "AdministratingRecordCompanyRole", "AllTerritoryCode", "ArtistRole", "AudioCodecType", "BinaryDataType", "BusinessContributorRole", "CalculationType", "CarrierType", "CdProtectionType", "CharacterType", "CodingType", "CollectionType", "CommercialModelType", "CompilationType", "ContainerFormat", "CreationType", "CreativeContributorRole", "CueOrigin", "CueSheetType", "CueUseType", "CurrencyCode", "CurrentTerritoryCode", "DataMismatchResponseType", "DataMismatchStatus", "DataMismatchType", "DdexTerritoryCode", "DeductionRateType", "DeliveryActionType", "DeliveryMessageType", "DeprecatedCurrencyCode", "DeprecatedIsoTerritoryCode", "DigitizationMode", "DisputeReason", "DistributionChannelType", "DpidStatus", "DrmEnforcementType", "DrmPlatformType", "DsrMessageType", "EquipmentType", "ErnMessageType", "ErncFileStatus", "ErncProposedActionType", "ExpressionType", "ExternallyLinkedResourceType", "FileStatus", "FingerprintAlgorithmType", "GoverningAgreementType", "HashSumAlgorithmType", "ImageCodecType", "ImageType", "InvoiceAvailabilityStatus", "IsoCurrencyCode", "IsoLanguageCode", "IsoTerritoryCode", "LabelNameType", "LicenseOrClaimRefusalReason", "LicenseOrClaimRequestUpdateReason", "LicenseOrClaimUpdateReason", "LicenseRejectionReason", "LicenseStatus", "LicensingProcessStatus", "LodFileStatus", "LodProposedActionType", "MembershipType", "MessageActionType", "MessageContentRevenueType", "MessageContextType", "MessageControlType", "MidiType", "MlcMessageType", "MusicalWorkContributorRole", "MusicalWorkRightsClaimType", "MusicalWorkType", "MwlCaCMessageInBatchType", "MwnMessageType", "NewReleaseMessageStatus", "OperatingSystemType", "OrderType", "PLineType", "ParentalWarningType", "PartyRelationshipType", "PercentageType", "PriceInformationType", "PriceRangeType", "PriceType", "Priority", "ProductType", "ProjectContributorRelationshipType", "Purpose", "RateModificationType", "RatingAgency", "ReasonType", "RecipientRevenueType", "RecordingMode", "RedeliveryReasonType", "ReferenceUnit", "RelationalRelator", "ReleaseAvailabilityStatus", "ReleaseRelationshipType", "ReleaseResourceType", "ReleaseType", "ReportFormat", "ReportType", "RequestReason", "RequestedActionType", "ResourceContributorRole", "ResourceOmissionReason", "ResourceType", "RevenueSourceType", "RightShareRelationshipType", "RightShareType", "RightsClaimPolicyType", "RightsControllerRole", "RightsControllerType", "RightsCoverage", "RoyaltyRateCalculationType", "RoyaltyRateType", "SalesReportAvailabilityStatus", "Sex", "SheetMusicCodecType", "SheetMusicType", "SoftwareType", "SoundProcessorType", "SoundRecordingType", "SupplyChainStatus", "TaxScope", "TaxType", "TerritoryCodeType", "TerritoryCodeTypeIncludingDeprecatedCodes", "TextCodecType", "TextType", "ThemeType", "TisTerritoryCode", "TitleType", "TrackContributorRelationshipType", "UnitOfBitRate", "UnitOfConditionValue", "UnitOfExtent", "UnitOfFrameRate", "UnitOfFrequency", "UpdateIndicator", "UseType", "UserInterfaceType", "ValueType", "VideoCodecType", "VideoContentType", "VideoDefinitionType", "VideoType", "VisualPerceptionType", "VocalType", "WsMessageStatus", "TerritoryCode"]
   end
-end # describe XsdReader
+end # describe XsdReader::Schema

data/spec/xml_spec.rb

@@ -2,22 +2,22 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe XsdReader do
 
-  before :all do
-    @reader ||= XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-ern-v36.xsd')))
-  end
+  let(:reader){
+    XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-v36', 'ddex-ern-v36.xsd')))
+  }
 
   describe XsdReader::XML do
     it "gives a schema_node" do
-      expect(@reader.schema_node.name).to eq 'schema'
-      expect(@reader.schema_node.namespaces).to eq({"xmlns:xs"=>"http://www.w3.org/2001/XMLSchema", "xmlns:ern"=>"http://ddex.net/xml/ern/36", "xmlns:avs"=>"http://ddex.net/xml/avs/avs"})
+      expect(reader.schema_node.name).to eq 'schema'
+      expect(reader.schema_node.namespaces).to eq({"xmlns:xs"=>"http://www.w3.org/2001/XMLSchema", "xmlns:ern"=>"http://ddex.net/xml/ern/36", "xmlns:avs"=>"http://ddex.net/xml/avs/avs"})
     end
 
     it "gives a schema reader" do
-      expect(@reader.schema.class).to eq XsdReader::Schema
+      expect(reader.schema.class).to eq XsdReader::Schema
     end
 
     it "gives an elements shortcut to its schema's shortcuts" do
-      expect(@reader.elements.map(&:name)).to eq @reader.schema.elements.map(&:name)
+      expect(reader.elements.map(&:name)).to eq reader.schema.elements.map(&:name)
     end
   end
 

data/spec/xsd_reader_spec.rb

@@ -1,62 +1,195 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe XsdReader do
+  let(:logger){
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::DEBUG
+    logger
+  }
 
-  before :all do
-    @reader ||= XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-ern-v36.xsd')))
+  let(:reader){
+    XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-v36', 'ddex-ern-v36.xsd')), :logger => logger)
+  }
+
+  let(:v32){
+    XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-v32', 'ern-main.xsd')))
+  }
+
+  # do caching tests first, so they can show the initial -cacheless- situation 
+  describe 'caching' do
+    it 'start with caches empty' do
+      cache_names = [:direct_elements, :attributes, :all_elements, :sequences, :choices, :complex_types, :linked_complex_type, :simple_contents, :extensions]
+      expect(cache_names.map{|name| "#{name}: #{reader.instance_variable_get("@#{name}").inspect}"}).to eq cache_names.map{|name| "#{name}: #{nil.inspect}"}
+    end
+
+    it 'caches some relationships to improve performance' do
+      expect(reader.instance_variable_get('@schema')).to eq nil
+      expect(reader.instance_variable_get('@elements')).to eq nil
+      # the next line causes new caches to be created
+      expect(reader['NewReleaseMessage'].instance_variable_get('@all_elements')).to eq nil
+      expect(reader.instance_variable_get('@schema').class).to eq XsdReader::Schema
+      expect(reader.schema.instance_variable_get('@direct_elements').length).to eq 2
+      # the next line causes new caches to be created
+      expect(reader['NewReleaseMessage']['NewReleaseMessage'].instance_variable_get('@all_elements')).to eq nil
+      expect(reader['NewReleaseMessage'].instance_variable_get('@all_elements').first.name).to eq 'MessageHeader'
+      # etc.
+    end
+  end
+
+  describe "#elements" do
+    it "gives all child element definitions" do
+      expect(reader.elements.map(&:name)).to eq ['NewReleaseMessage', 'CatalogListMessage']
+      expect(reader.elements[0].elements[0].name).to eq 'MessageHeader'
+    end
   end
 
-  it "gives all child element definitions for a certain node through the `elements` method" do
-    expect(@reader.elements.map(&:name)).to eq ['NewReleaseMessage', 'CatalogListMessage']
-    expect(@reader.elements[0].elements[0].name).to eq 'MessageHeader'
+  describe "#all_elements" do
+    it "includes elements from linked complex types fmor an imported schema" do
+      el = v32['NewReleaseMessage']['CollectionList']['Collection']['Title']
+      expect(el.all_elements.map(&:name)).to eq ['TitleText', 'SubTitle']
+    end
+
+    it "includes elements from extensions in linked complex types" do
+      el = v32['NewReleaseMessage']['ResourceList']['SoundRecording']['SoundRecordingDetailsByTerritory']
+      expect(el.elements.map(&:name)).to eq ["TerritoryCode", "ExcludedTerritoryCode", "Title", "DisplayArtist", "ResourceContributor", "IndirectResourceContributor", "RightsAgreementId", "LabelName", "RightsController", "RemasteredDate", "OriginalResourceReleaseDate", "PLine", "CourtesyLine", "SequenceNumber", "HostSoundCarrier", "MarketingComment", "Genre", "ParentalWarningType", "AvRating", "TechnicalSoundRecordingDetails", "FulfillmentDate", "Keywords", "Synopsis"]
+    end
+  end
+
+  describe "[] operator" do
+    it "gives a child element object (matching by name)" do
+      expect(reader['NewReleaseMessage'].name).to eq 'NewReleaseMessage'
+    end
+
+    it "supports linking" do
+      # this supports linking:
+      expect(reader['NewReleaseMessage']['ReleaseList']['Release'].attributes.map(&:name)).to eq ["LanguageAndScriptCode", "IsMainRelease"]
+    end
+
+    it "gives a specific element in the hierarchy when passing an array argument" do
+      expect(reader[['NewReleaseMessage', 'ResourceList', 'SoundRecording']].name).to eq 'SoundRecording'
+      expect(reader[['NewReleaseMessage', 'ResourceList', 'SoundRecording']].multiple_allowed?).to eq true
+    end
+
+    it "automatically turns symbol arguments into strings" do
+      expect(reader[:NewReleaseMessage].name).to eq 'NewReleaseMessage'
+      # this supports linking:
+      expect(reader[:NewReleaseMessage]['ReleaseList'][:Release].attributes.map(&:name)).to eq ["LanguageAndScriptCode", "IsMainRelease"]
+      expect(reader[:NewReleaseMessage, 'ReleaseList', :Release].attributes.map(&:name)).to eq ["LanguageAndScriptCode", "IsMainRelease"]
+    end
+
+    it "return nil and doesn't raise an exceptions when getting invalid input" do
+      expect{
+        expect(reader[:NewReleaseMessage, 'Nothing', '@Whatever', 'Foo']).to eq nil
+      }.to_not raise_error
+    end
   end
 
-  it "gives a child element object through the square brackets ([]) operator (matching by name)" do
-    expect(@reader['NewReleaseMessage'].name).to eq 'NewReleaseMessage'
-    # this supports linking:
-    expect(@reader['NewReleaseMessage']['ReleaseList']['Release'].attributes.map(&:name)).to eq ["LanguageAndScriptCode", "IsMainRelease"]
+  describe "#child_elements?" do
+    it "returns wether an element has child element definitions or not" do
+      expect(reader['NewReleaseMessage'].child_elements?).to eq true
+      expect(reader['NewReleaseMessage']['MessageHeader']['MessageThreadId'].child_elements?).to eq false
+    end
+  end    
+
+  describe "#min_occurs" do
+    it "gives the minOccurs attribute as an integer" do
+      expect(reader['NewReleaseMessage']['ResourceList']['SoundRecording'].min_occurs).to eq 0
+    end
+
+    it "returns nil when an element has no minOccurs attribute specified" do
+      expect(reader['NewReleaseMessage']['ResourceList'].min_occurs).to eq nil
+    end
   end
 
-  it "gives a specific element in the hierarchy when passing an array argument to the square brackets ([]) operator" do
-    # this supports linking:
-    expect(@reader[['NewReleaseMessage', 'ResourceList', 'SoundRecording']].name).to eq 'SoundRecording'
-    expect(@reader[['NewReleaseMessage', 'ResourceList', 'SoundRecording']].multiple_allowed?).to eq true
+  describe "#max_occurs" do
+    it "returns the :unbounded symbol when there's no limit to the number of occurences of an element" do
+      expect(reader['NewReleaseMessage']['ResourceList']['SoundRecording'].max_occurs).to eq :unbounded
+    end
   end
 
-  it "provides a `child_elements?` convenience method" do
-    expect(@reader['NewReleaseMessage'].child_elements?).to be true
-    expect(@reader['NewReleaseMessage']['MessageHeader']['MessageThreadId'].child_elements?).to be false
+  describe "#multiple_allowed?" do
+    it "indicates if multiple instances of an element are allowed" do
+      expect(reader['NewReleaseMessage']['ResourceList'].multiple_allowed?).to be false
+      expect(reader['NewReleaseMessage']['ResourceList']['SoundRecording'].multiple_allowed?).to be true
+    end
   end
 
-  it "provides `min_occurs` and `max_occurs` reader methods" do
-    expect(@reader['NewReleaseMessage']['ResourceList'].min_occurs).to eq nil
-    expect(@reader['NewReleaseMessage']['ResourceList']['SoundRecording'].min_occurs).to eq 0
-    expect(@reader['NewReleaseMessage']['ResourceList']['SoundRecording'].max_occurs).to eq :unbounded
+  describe "#required?" do
+    it "indicates if an element is required" do
+      expect(reader['NewReleaseMessage'].required?).to be true
+      expect(reader['NewReleaseMessage']['ResourceList'].required?).to be true
+      expect(reader['NewReleaseMessage']['CollectionList'].required?).to be false
+    end
+
+    it "indicates if an attribute is required" do
+      expect(reader['NewReleaseMessage']['@MessageSchemaVersionId'].required?).to eq true
+      expect(reader['NewReleaseMessage']['@LanguageAndScriptCode'].required?).to eq false
+    end
   end
 
-  it "provides a boolean `multiple_allowed?` method, indicating if multiple instances of this element are allowed" do
-    # byebug
-    expect(@reader['NewReleaseMessage']['ResourceList'].multiple_allowed?).to be false
-    expect(@reader['NewReleaseMessage']['ResourceList']['SoundRecording'].multiple_allowed?).to be true
+  describe "#optional?" do
+    it "indicates if an element is optonal (opposite of required)" do
+      expect(reader['NewReleaseMessage'].optional?).to be false
+      expect(reader['NewReleaseMessage']['ResourceList'].optional?).to be false
+      expect(reader['NewReleaseMessage']['CollectionList'].optional?).to be true
+    end
   end
 
-  it "provides a `required?` method, indicating if an element is required to be there" do
-    expect(@reader['NewReleaseMessage'].required?).to be true
-    expect(@reader['NewReleaseMessage']['ResourceList'].required?).to be true
-    expect(@reader['NewReleaseMessage']['CollectionList'].required?).to be false
+  describe "imports"  do
+    it "finds imported types for elements" do
+      simple_type = reader['NewReleaseMessage']['DealList']['ReleaseDeal']['Deal']['DealTerms']['WebPolicy']['AccessLimitation'].linked_simple_type
+      expect(simple_type.class).to eq XsdReader::SimpleType
+      expect(simple_type.name).to eq 'AccessLimitation'
+      # byebug
+      expect(simple_type.schema).to be reader.imports[0].reader.schema
+    end
   end
 
-  it "provides an `optional?` convenience method, as an opposite of `required?`" do
-    expect(@reader['NewReleaseMessage'].optional?).to be false
-    expect(@reader['NewReleaseMessage']['ResourceList'].optional?).to be false
-    expect(@reader['NewReleaseMessage']['CollectionList'].optional?).to be true
+  describe "#schema_for_namespace" do
+    let(:v32){
+      XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-v32', 'ern-main.xsd')))
+    }
+
+    it "returns the schema object for a specified namespace" do
+      expect(v32.schema_for_namespace('http://ddex.net/xml/2010/ern-main/32').target_namespace).to eq 'http://ddex.net/xml/2010/ern-main/32'
+      expect(v32.schema_for_namespace('http://ddex.net/xml/2010/ern-main/32')).to be v32.schema
+      expect(v32.schema.schema_for_namespace('http://ddex.net/xml/2010/ern-main/32')).to be v32.schema
+      expect(v32['NewReleaseMessage'].schema_for_namespace('http://ddex.net/xml/2010/ern-main/32')).to be v32.schema
+    end
+
+    it "returns the schema object for a specified namespace code" do
+      expect(v32.schema_for_namespace('ernm').target_namespace).to eq 'http://ddex.net/xml/2010/ern-main/32'
+      expect(v32.schema_for_namespace('ernm')).to be v32.schema
+      expect(v32.schema.schema_for_namespace('ernm')).to be v32.schema
+      expect(v32['NewReleaseMessage']['ResourceList'].schema_for_namespace('ernm')).to be v32.schema
+    end
+
+    it "finds imported schemas" do
+      expect(v32.schema_for_namespace('http://ddex.net/xml/20100712/ddexC').target_namespace).to eq 'http://ddex.net/xml/20100712/ddexC'
+      expect(v32.schema_for_namespace('http://ddex.net/xml/20100712/ddexC')).to be v32.imports[1].reader.schema
+      expect(v32.schema.schema_for_namespace('ddex').target_namespace).to eq 'http://ddex.net/xml/20100712/ddex'
+      expect(v32.schema.schema_for_namespace('ddex')).to be v32.imports[0].reader.schema
+      expect(v32.schema_for_namespace('ddexC').target_namespace).to eq 'http://ddex.net/xml/20100712/ddexC'
+      expect(v32.schema_for_namespace('ddexC')).to be v32.imports[1].reader.schema
+    end
   end
 
-  # it "gives an array recursive parent names `ancestors` method" do
-  #   skip 'Not yet (properly) imlemented'
-  #   # byebug
-  #   expect(@reader.ancestors).to eq []
-  #   expect(@reader['NewReleaseMessage'].ancestors).to eq []
-  #   expect(@reader['NewReleaseMessage']['DealList']['ReleaseDeal'].ancestors.map(&:name)).to eq ['NewReleasMessage', 'DealList']
-  # end
+  describe "#linked_complex_type" do
+    it "finds complex types for elements within the same schema" do
+      el = reader['NewReleaseMessage']['MessageHeader']
+      ct = el.linked_complex_type
+      expect(ct.class).to eq XsdReader::ComplexType
+      expect(ct.name).to eq 'MessageHeader'
+      expect(ct.schema).to be el.schema
+    end
+
+    it "finds complex types for elements on imported schemas based on namespace prefix" do
+      el = v32['NewReleaseMessage']['CollectionList']['Collection']['Title']
+      ct = el.linked_complex_type
+      expect(ct.class).to eq XsdReader::ComplexType
+      expect(ct.name).to eq 'Title'
+      expect(ct.schema).to be el.schema.imports[1].reader.schema
+      expect(el.complex_type).to be ct
+    end
+  end
 end

data/xsd-reader.gemspec

@@ -1,5 +1,5 @@
 GEM_NAME="xsd-reader"
-PKG_VERSION='0.0.1'
+PKG_VERSION='0.1.0'
 
 Gem::Specification.new do |s|
   s.name = GEM_NAME
@@ -8,6 +8,7 @@ Gem::Specification.new do |s|
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
 
   s.add_dependency 'nokogiri'
+  s.add_dependency 'rest-client'
   s.add_development_dependency 'rspec'
 
   s.author = "Mark van de Korput"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xsd-reader
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Mark van de Korput
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -53,17 +67,29 @@ files:
 - lib/xsd_reader.rb
 - lib/xsd_reader/attribute.rb
 - lib/xsd_reader/choice.rb
+- lib/xsd_reader/complex_content.rb
 - lib/xsd_reader/complex_type.rb
 - lib/xsd_reader/element.rb
 - lib/xsd_reader/extension.rb
+- lib/xsd_reader/import.rb
 - lib/xsd_reader/schema.rb
 - lib/xsd_reader/sequence.rb
 - lib/xsd_reader/shared.rb
 - lib/xsd_reader/simple_content.rb
+- lib/xsd_reader/simple_type.rb
 - lib/xsd_reader/xml.rb
 - spec/attribute_spec.rb
 - spec/element_spec.rb
-- spec/examples/ddex-ern-v36.xsd
+- spec/examples/ddex-v32/ddex.xsd
+- spec/examples/ddex-v32/ddexC.xsd
+- spec/examples/ddex-v32/ern-main.xsd
+- spec/examples/ddex-v32/iso3166a2.xsd
+- spec/examples/ddex-v32/iso4217a.xsd
+- spec/examples/ddex-v32/iso639a2.xsd
+- spec/examples/ddex-v36/avs.xsd
+- spec/examples/ddex-v36/ddex-ern-v36.xsd
+- spec/extension_spec.rb
+- spec/import_spec.rb
 - spec/schema_spec.rb
 - spec/spec_helper.rb
 - spec/xml_spec.rb