mods_display 0.10.1 → 1.0.0.alpha1

data/spec/fields/access_condition_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-
-def mods_display_access_condition(mods_record)
-  ModsDisplay::AccessCondition.new(
-    mods_record,
-    ModsDisplay::Configuration::AccessCondition.new,
-    double('controller')
-  )
-end
-
-def mods_display_non_ignore_access_condition(mods_record)
-  ModsDisplay::AccessCondition.new(
-    mods_record,
-    ModsDisplay::Configuration::AccessCondition.new { display! },
-    double('controller')
-  )
-end
-
-describe ModsDisplay::AccessCondition do
-  include AccessConditionFixtures
-  before :all do
-    @access_condition = Stanford::Mods::Record.new.from_str(simple_access_condition_fixture, false).accessCondition
-    @restrict_condition = Stanford::Mods::Record.new.from_str(restricted_access_fixture, false).accessCondition
-    @copyright_note = Stanford::Mods::Record.new.from_str(copyright_access_fixture, false).accessCondition
-    @cc_license_note = Stanford::Mods::Record.new.from_str(cc_license_fixture, false).accessCondition
-    @odc_license_note = Stanford::Mods::Record.new.from_str(odc_license_fixture, false).accessCondition
-    @no_link_license_note = Stanford::Mods::Record.new.from_str(no_license_fixture, false).accessCondition
-    @garbage_license_fixture = Stanford::Mods::Record.new.from_str(garbage_license_fixture, false).accessCondition
-  end
-  describe 'labels' do
-    it 'should normalize types and assign proper labels' do
-      fields = mods_display_access_condition(@restrict_condition).fields
-      expect(fields.length).to eq(1)
-      expect(fields.first.label).to eq('Restriction on access:')
-      fields.first.values.each_with_index do |value, index|
-        expect(value).to match(/^Restrict Access Note#{index + 1}/)
-      end
-    end
-  end
-  describe 'fields' do
-    describe 'copyright' do
-      it "should replace instances of '(c) copyright' with the HTML copyright entity" do
-        fields = mods_display_access_condition(@copyright_note).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values.length).to eq(1)
-        expect(fields.first.values.first).to eq(
-          'This is a © Note.  Single instances of © should also be replaced in these notes.'
-        )
-      end
-    end
-    describe 'licenses' do
-      it 'should add the appropriate classes to the html around the license' do
-        fields = mods_display_access_condition(@no_link_license_note).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values.length).to eq(1)
-        expect(fields.first.values.first).to match(%r{^<div class='unknown-something'>.*</div>$})
-      end
-      it 'should identify and link CreativeCommons licenses properly' do
-        fields = mods_display_access_condition(@cc_license_note).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values.length).to eq(1)
-        expect(fields.first.values.first).to include("<a href='http://creativecommons.org/licenses/by-sa/3.0/'>")
-        expect(fields.first.values.first).to include(
-          'This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License'
-        )
-      end
-      it 'should identify and link OpenDataCommons licenses properly' do
-        fields = mods_display_access_condition(@odc_license_note).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values.length).to eq(1)
-        expect(fields.first.values.first).to include("<a href='http://opendatacommons.org/licenses/pddl/'>")
-        expect(fields.first.values.first).to include(
-          'This work is licensed under a Open Data Commons Public Domain Dedication and License (PDDL)'
-        )
-      end
-
-      it 'should not attempt unknown license types' do
-        fields = mods_display_access_condition(@no_link_license_note).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values.length).to eq(1)
-        expect(fields.first.values.first).to include(
-          'This work is licensed under an Unknown License and will not be linked'
-        )
-        expect(fields.first.values.first).not_to include('<a.*>')
-      end
-
-      it 'returns the license text if it does not look like our expected format' do
-        fields = mods_display_access_condition(@garbage_license_fixture).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values.length).to eq(1)
-        expect(fields.first.values.first).to include(
-          'Unknown garbage that does not look like a license'
-        )
-        expect(fields.first.values.first).not_to include('<a.*>')
-      end
-    end
-  end
-  describe 'to_html' do
-    it 'should ignore access conditions by default' do
-      expect(mods_display_access_condition(@access_condition).to_html).to be_nil
-    end
-    it 'should not ignore the access condition when ignore is set to false' do
-      html = mods_display_non_ignore_access_condition(@access_condition).to_html
-      expect(html).to match %r{<dt.*>Access condition:</dt><dd>Access Condition Note</dd>}
-    end
-  end
-end

data/spec/fields/audience_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-def mods_display_audience(mods_record)
-  ModsDisplay::Audience.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
-end
-
-describe ModsDisplay::Contents do
-  before(:all) do
-    @audience = Stanford::Mods::Record.new.from_str(
-      '<mods><targetAudience>Audience Note</targetAudience></mods>', false
-    ).targetAudience
-    @display_label = Stanford::Mods::Record.new.from_str(
-      "<mods><targetAudience displayLabel='Special Label'>Audience Note</tableOfContents></mods>", false
-    ).targetAudience
-  end
-  describe 'label' do
-    it 'should have a default label' do
-      expect(mods_display_audience(@audience).label).to eq('Target audience:')
-    end
-    it 'should use the displayLabel attribute when one is available' do
-      expect(mods_display_audience(@display_label).label).to eq('Special Label:')
-    end
-  end
-end

data/spec/fields/cartographics_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'fixtures/cartographics_fixtures'
-include CartographicsFixtures
-
-def mods_display_cartographics(mods)
-  ModsDisplay::Cartographics.new(mods, ModsDisplay::Configuration::Base.new, double('controller'))
-end
-
-describe ModsDisplay::Cartographics do
-  before(:all) do
-    @cart = Stanford::Mods::Record.new.from_str(full_cartographic, false).subject
-    @scale_only = Stanford::Mods::Record.new.from_str(scale_only, false).subject
-    @no_scale = Stanford::Mods::Record.new.from_str(no_scale_cartographic, false).subject
-    @coordinates = Stanford::Mods::Record.new.from_str(coordinates_only, false).subject
-  end
-  describe 'values' do
-    it 'should get the full cartographic note' do
-      values = mods_display_cartographics(@cart).fields
-      expect(values.length).to eq(1)
-      expect(values.first.values).to eq(['The scale ; the projection the coordinates'])
-    end
-    it 'should put a scale not given note if no scale is present' do
-      values = mods_display_cartographics(@no_scale).fields
-      expect(values.length).to eq(1)
-      expect(values.first.values).to eq(['Scale not given ; the projection the coordinates'])
-    end
-    it 'should handle when there is only a scale note' do
-      values = mods_display_cartographics(@scale_only).fields
-      expect(values.length).to eq(1)
-      expect(values.first.values).to eq(['The scale'])
-    end
-    it 'should handle when only one post-scale piece of the data is available' do
-      values = mods_display_cartographics(@coordinates).fields
-      expect(values.length).to eq(1)
-      expect(values.first.values).to eq(['Scale not given ; the coordinates'])
-    end
-  end
-end

data/spec/fields/collection_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-def mods_display_collection(mods_record)
-  ModsDisplay::Collection.new(
-    mods_record,
-    ModsDisplay::Configuration::Base.new,
-    double('controller')
-  )
-end
-
-describe ModsDisplay::Collection do
-  let(:collection) do
-    Stanford::Mods::Record.new.from_str(
-      '<mods>
-        <relatedItem>
-          <titleInfo><title>The Collection</title></titleInfo><typeOfResource collection="yes" />
-        </relatedItem>
-      </mods>',
-      false
-    ).related_item
-  end
-  let(:non_collection) do
-    Stanford::Mods::Record.new.from_str(
-      '<mods><relatedItem><titleInfo><title>Not a Collection</title></titleInfo></relatedItem></mods>',
-      false
-    ).related_item
-  end
-  let(:display_label) do
-    Stanford::Mods::Record.new.from_str(
-      '<mods>
-         <relatedItem displayLabel="Special Collection">
-           <titleInfo><title>Not a Collection</title></titleInfo>
-         </relatedItem>
-       </mods>',
-      false
-    ).related_item
-  end
-  let(:multiple_related_items) do
-    Stanford::Mods::Record.new.from_str(
-      '<mods>
-        <relatedItem displayLabel="Special Collection">
-          <titleInfo><title>Not a Collection</title></titleInfo>
-        </relatedItem>
-        <relatedItem>
-          <titleInfo><title>The Collection</title></titleInfo><typeOfResource collection="yes" />
-        </relatedItem>
-      </mods>',
-      false
-    ).related_item
-  end
-
-  describe 'label' do
-    it 'should default to Collection' do
-      expect(mods_display_collection(collection).fields.first.label).to eq('Collection:')
-    end
-
-    it 'should get the displayLabel if available' do
-      expect(mods_display_collection(display_label).label).to eq('Special Collection:')
-    end
-
-    it 'should get the proper titles of all items when there is a displayLabel present' do
-      expect(mods_display_collection(multiple_related_items).fields.first.label).to eq 'Collection:'
-    end
-  end
-
-  describe 'fields' do
-    it 'should get a collection title if there is an appropriate typeOfResource field with the collection attribute' do
-      fields = mods_display_collection(collection).fields
-      expect(fields.length).to eq(1)
-      expect(fields.first.values).to eq(['The Collection'])
-    end
-
-    it 'should be blank if the there is not an appropriate typeOfResource field with the collection attribute' do
-      expect(mods_display_collection(non_collection).fields).to eq([])
-    end
-  end
-end

data/spec/fields/contact_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-def mods_display_contact(mods_record)
-  ModsDisplay::Contact.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
-end
-
-describe ModsDisplay::Contact do
-  before(:all) do
-    @contact_note = Stanford::Mods::Record.new.from_str(
-      "<mods><note type='contact'>jdoe@example.com</note><note>Note Field</note></mods>", false
-    ).note
-  end
-  it 'should only get contact fields' do
-    fields = mods_display_contact(@contact_note).fields
-    expect(fields.length).to eq(1)
-    expect(fields.first.values).to include('jdoe@example.com')
-  end
-  it 'should not get any non-contact fields' do
-    fields = mods_display_contact(@contact_note).fields
-    expect(fields.length).to eq(1)
-    expect(fields.first.values).not_to include('Note Field')
-  end
-end

data/spec/fields/contents_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-def mods_display_contents(mods_record)
-  ModsDisplay::Contents.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
-end
-
-describe ModsDisplay::Contents do
-  before(:all) do
-    @contents = Stanford::Mods::Record.new.from_str(
-      '<mods><tableOfContents>Content Note</tableOfContents></mods>', false
-    ).tableOfContents
-    @display_label = Stanford::Mods::Record.new.from_str(
-      "<mods><tableOfContents displayLabel='Special Label'>Content Note</tableOfContents></mods>", false
-    ).tableOfContents
-  end
-  describe 'label' do
-    it 'should have a default label' do
-      expect(mods_display_contents(@contents).label).to eq('Table of contents:')
-    end
-    it 'should use the displayLabel attribute when one is available' do
-      expect(mods_display_contents(@display_label).label).to eq('Special Label:')
-    end
-  end
-  context 'multi-valued contents' do
-    let(:toc) do
-      Stanford::Mods::Record.new.from_str(
-              '<mods><tableOfContents>Content Note 1 -- Content Note 2</tableOfContents></mods>', false
-            ).tableOfContents
-    end
-    it 'should have one value with "--" marker' do
-      mdc = mods_display_contents(toc)
-      expect(mdc.fields.first.values).to eq ['Content Note 1 -- Content Note 2']
-    end
-    it 'should render as a list' do
-      html = mods_display_contents(toc).to_html
-      expect(html).to include '<dd><ul><li>Content Note 1</li><li>Content Note 2</li></ul></dd>'
-    end
-  end
-end

data/spec/fields/description_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-def mods_display_description(mods)
-  ModsDisplay::Description.new(mods, ModsDisplay::Configuration::Base.new, double('controller'))
-end
-
-describe ModsDisplay::Description do
-  before(:all) do
-    @form = Stanford::Mods::Record.new.from_str(
-      '<mods><physicalDescription><note>Description Note</note></physicalDescription></mods>', false
-    ).physical_description
-    @display_label = Stanford::Mods::Record.new.from_str(
-      "<mods>
-        <physicalDescription displayLabel='SpecialLabel'><note>Description Note</note></physicalDescription>
-       </mods>", false
-    ).physical_description
-    @child_display_label = Stanford::Mods::Record.new.from_str(
-      "<mods><physicalDescription><note displayLabel='Note Label'>Description Note</note></physicalDescription></mods>",
-      false
-    ).physical_description
-    @mixed = Stanford::Mods::Record.new.from_str(
-      '<mods>
-        <physicalDescription>
-          <note>Description Note</note>
-          <digitalOrigin>Digital Origin Note</digitalOrigin>
-        </physicalDescription>
-       </mods>', false
-    ).physical_description
-  end
-  describe 'labels' do
-    it 'should use the displayLabel if one is provided' do
-      expect(mods_display_description(@display_label).fields.first.label).to eq('SpecialLabel:')
-    end
-    it 'should get the default label for a child element' do
-      expect(mods_display_description(@form).fields.first.label).to eq('Note:')
-    end
-    it 'should get multiple lables for mixed content' do
-      expect(mods_display_description(@mixed).fields.map(&:label)).to eq(['Note:', 'Digital origin:'])
-    end
-    it 'should get the display label from child elements' do
-      expect(mods_display_description(@child_display_label).fields.map(&:label)).to eq(['Note Label:'])
-    end
-  end
-
-  describe 'fields' do
-    it 'should get the value from a field in physicalDescription' do
-      expect(mods_display_description(@form).fields.first.values).to eq(['Description Note'])
-    end
-    it 'should get multiple values for mixed content' do
-      expect(mods_display_description(@mixed).fields.map(&:values)).to eq(
-        [['Description Note'], ['Digital Origin Note']]
-      )
-    end
-  end
-end

data/spec/fields/extent_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe ModsDisplay::Extent do
-  let(:mods) do
-    <<-XML
-      <mods>
-        <physicalDescription>
-          <extent>Extent Value</extent>
-          <extent>Extent Value 2</extent>
-        </physicalDescription>
-      </mods>
-    XML
-  end
-
-  subject do
-    parsed_mods = Stanford::Mods::Record.new.from_str(mods, false).physical_description
-    described_class.new(parsed_mods, ModsDisplay::Configuration::Base.new, double('controller')).fields
-  end
-
-  describe 'label' do
-    it 'is "Extent"' do
-      expect(subject.first.label).to eq 'Extent:'
-    end
-  end
-
-  describe 'values' do
-    it 'returns the text of the extent element' do
-      expect(subject.first.values).to eq ['Extent Value', 'Extent Value 2']
-    end
-  end
-end

data/spec/fields/form_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe ModsDisplay::Form do
-  let(:mods) do
-    <<-XML
-      <mods>
-        <physicalDescription>
-          <form>Form Value</form>
-          <form>Form Value 2</form>
-        </physicalDescription>
-      </mods>
-    XML
-  end
-
-  subject do
-    parsed_mods = Stanford::Mods::Record.new.from_str(mods, false).physical_description
-    described_class.new(parsed_mods, ModsDisplay::Configuration::Base.new, double('controller')).fields
-  end
-
-  describe 'label' do
-    it 'is "Form"' do
-      expect(subject.first.label).to eq 'Form:'
-    end
-  end
-
-  describe 'values' do
-    it 'returns the text of the form element' do
-      expect(subject.first.values).to eq ['Form Value', 'Form Value 2']
-    end
-
-    context 'duplicated data' do
-      let(:mods) do
-        <<-XML
-          <mods>
-            <physicalDescription>
-              <form authority="gmd">electronic resource.</form>
-              <form authority="zxy">electronicresource!</form>
-              <form authority="marccategory">electronic Resource</form>
-            </physicalDescription>
-          </mods>
-        XML
-      end
-
-      it 'uses only unique form values, ignore differences in case, punctuation or whitespace' do
-        expect(subject.first.values).to match_array ['electronic resource.']
-      end
-    end
-  end
-end

data/spec/fields/genre_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-def mods_display_genre(mods_record)
-  ModsDisplay::Genre.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
-end
-
-describe ModsDisplay::Abstract do
-  before(:all) do
-    @genre = Stanford::Mods::Record.new.from_str('<mods><genre>Map Data</genre></mods>', false).genre
-    @downcase = Stanford::Mods::Record.new.from_str('<mods><genre>map data</genre></mods>', false).genre
-    @display_label = Stanford::Mods::Record.new.from_str(
-      "<mods><genre displayLabel='Special label'>Catographic</genre></mods>", false
-    ).genre
-  end
-  describe 'labels' do
-    it "should return a default 'Genre' label" do
-      fields = mods_display_genre(@genre).fields
-      expect(fields.length).to eq(1)
-      expect(fields.first.label).to eq('Genre:')
-    end
-    it 'should use a display label when one is available' do
-      fields = mods_display_genre(@display_label).fields
-      expect(fields.length).to eq(1)
-      expect(fields.first.label).to eq('Special label:')
-    end
-  end
-  describe 'fields' do
-    it 'should capitalize the first letter in a genre' do
-      fields = mods_display_genre(@downcase).fields
-      expect(fields.length).to eq(1)
-      expect(fields.first.values).to eq(['Map data'])
-    end
-  end
-end

data/spec/fields/geo_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-def mods_display_geo(mods_record)
-  ModsDisplay::Geo.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
-end
-
-describe ModsDisplay::Geo do
-  let(:mods) do
-    <<-XML
-      <mods>
-        <extension displayLabel="geo">
-          <rdf:RDF xmlns:gml="http://www.opengis.net/gml/3.2/" xmlns:dc="http://purl.org/dc/elements/1.1/">
-            <rdf:Description>
-              <dc:format>image/tiff; format=ArcGRID</dc:format>
-              <dc:type>Dataset#Raster</dc:type>
-            </rdf:Description>
-          </rdf:RDF>
-        </extension>
-      </mods>
-    XML
-  end
-
-  subject do
-    mods_display_geo(Stanford::Mods::Record.new.from_str(mods, false).extension).fields
-  end
-
-  describe 'labels' do
-    it 'is Format' do
-      expect(subject.length).to eq(1)
-      expect(subject.first.label).to eq('Format:')
-    end
-  end
-
-  describe 'fields' do
-    it 'joins the normalized format and type with a semicolon' do
-      expect(subject.length).to eq(1)
-      expect(subject.first.values).to eq(['ArcGRID; Raster'])
-    end
-  end
-end

data/spec/fields/identifier_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-def mods_display_id(mods_record)
-  ModsDisplay::Identifier.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
-end
-
-describe ModsDisplay::Note do
-  before(:all) do
-    @id = Stanford::Mods::Record.new.from_str('<mods><identifier>12345</identifier></mods>', false).identifier
-    @display_label = Stanford::Mods::Record.new.from_str(
-      "<mods><identifier displayLabel='Special Label'>54321</identifier></mods>", false
-    ).identifier
-    @issue_label = Stanford::Mods::Record.new.from_str(
-      "<mods><identifier type='issue number'>Issue 1</identifier></mods>", false
-    ).identifier
-    @type_label = Stanford::Mods::Record.new.from_str(
-      "<mods><identifier type='Some other Type'>98765</identifier></mods>", false
-    ).identifier
-    @complex_label = Stanford::Mods::Record.new.from_str(
-      "<mods>
-        <identifier>12345</identifier>
-        <identifier>54321</identifier>
-        <identifier type='issue number'>12345</identifier>
-        <identifier>98765</identifier>
-      </mods>", false
-    ).identifier
-  end
-  describe 'label' do
-    it 'should have a default label' do
-      expect(mods_display_id(@id).fields.first.label).to eq('Identifier:')
-    end
-    it 'should use the displayLabel attribute when one is available' do
-      expect(mods_display_id(@display_label).fields.first.label).to eq('Special Label:')
-    end
-    it 'should use get a label from a list of translations' do
-      expect(mods_display_id(@issue_label).fields.first.label).to eq('Issue number:')
-    end
-    it 'should use use the raw type attribute if one is present' do
-      expect(mods_display_id(@type_label).fields.first.label).to eq('Some other Type:')
-    end
-  end
-
-  describe 'fields' do
-    it 'should handle matching adjacent labels' do
-      fields = mods_display_id(@complex_label).fields
-      expect(fields.length).to eq(3)
-
-      expect(fields.first.label).to eq('Identifier:')
-      expect(fields.first.values.length).to eq(2)
-      expect(fields.first.values).to eq(%w(12345 54321))
-
-      expect(fields[1].label).to eq('Issue number:')
-      expect(fields[1].values.length).to eq(1)
-      expect(fields[1].values).to eq(['12345'])
-
-      expect(fields.last.label).to eq('Identifier:')
-      expect(fields.last.values.length).to eq(1)
-      expect(fields.last.values).to eq(['98765'])
-    end
-  end
-end