datacite-mapping 0.1.17.2 → 0.2.0

data/spec/unit/datacite/mapping/date_value_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+module Datacite
+  module Mapping
+    describe DateValue do
+
+      before(:all) do
+        @values = {
+          with_date_time: DateTime.new(1914, 8, 4, 11, 1, 6.0123, '+1'),
+          with_date: ::Date.new(1914, 8, 4),
+          with_year: 1914,
+          with_year_str: '1914',
+          with_year_month: '1914-08',
+          iso8601: '1914-08-04T11:01+01:00',
+          iso8601_secs: '1914-08-04T11:01:06+01:00',
+          iso8601_frac: '1914-08-04T11:01:06.0123+01:00'
+        }
+        @dates = @values.map { |format, v| [format, DateValue.new(v)] }.to_h
+      end
+
+      describe '#initialize' do
+        it 'accepts a DateTime' do
+          d = @dates[:with_date_time]
+          expect(d).to be_a(DateValue)
+          expect(d.year).to eq(1914)
+          expect(d.month).to eq(8)
+          expect(d.day).to eq(4)
+          expect(d.date).to eq(::Date.new(1914, 8, 4))
+          expect(d.hour).to eq(11)
+          expect(d.minute).to eq(1)
+          expect(d.sec).to eq(6)
+          expect(d.nsec).to eq(12_300_000)
+        end
+
+        it 'accepts a DateValue' do
+          d = @dates[:with_date]
+          expect(d).to be_a(DateValue)
+          expect(d.year).to eq(1914)
+          expect(d.month).to eq(8)
+          expect(d.day).to eq(4)
+          expect(d.date).to eq(::Date.new(1914, 8, 4))
+        end
+
+        it 'accepts a year as an integer' do
+          d = @dates[:with_year]
+          expect(d).to be_a(DateValue)
+          expect(d.year).to eq(1914)
+        end
+
+        it 'accepts a year as a string' do
+          d = @dates[:with_year_str]
+          expect(d).to be_a(DateValue)
+          expect(d.year).to eq(1914)
+        end
+
+        it 'accepts a year-month string' do
+          d = @dates[:with_year_month]
+          expect(d).to be_a(DateValue)
+          expect(d.year).to eq(1914)
+          expect(d.month).to eq(8)
+        end
+
+        it 'accepts an ISO 8601 DateValue string with hours and minutes' do
+          d = @dates[:iso8601]
+          expect(d).to be_a(DateValue)
+          expect(d.year).to eq(1914)
+          expect(d.month).to eq(8)
+          expect(d.day).to eq(4)
+          expect(d.date).to eq(::Date.new(1914, 8, 4))
+          expect(d.hour).to eq(11)
+          expect(d.minute).to eq(1)
+        end
+
+        it 'accepts an ISO 8601 DateValue string with hours, minutes, and seconds' do
+          d = @dates[:iso8601_secs]
+          expect(d).to be_a(DateValue)
+          expect(d.year).to eq(1914)
+          expect(d.month).to eq(8)
+          expect(d.day).to eq(4)
+          expect(d.date).to eq(::Date.new(1914, 8, 4))
+          expect(d.hour).to eq(11)
+          expect(d.minute).to eq(1)
+          expect(d.sec).to eq(6)
+        end
+
+        it 'accepts an ISO 8601 DateValue string with hours, minutes, seconds, and fractional seconds' do
+          d = @dates[:iso8601_frac]
+          expect(d).to be_a(DateValue)
+          expect(d.year).to eq(1914)
+          expect(d.month).to eq(8)
+          expect(d.day).to eq(4)
+          expect(d.date).to eq(::Date.new(1914, 8, 4))
+          expect(d.hour).to eq(11)
+          expect(d.minute).to eq(1)
+          expect(d.sec).to eq(6)
+          expect(d.nsec).to eq(12_300_000)
+        end
+
+        it 'rejects invalid dates' do
+          expect { DateValue.new(value: 'elvis') }.to raise_error(ArgumentError)
+        end
+
+        it 'rejects nil' do
+          expect { DateValue.new(value: nil) }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#<=>' do
+        it 'reports equal values as equal' do
+          d1 = DateValue.new(DateTime.new(1914, 8, 4, 11, 0o1, 6.0123, '+1'))
+          d2 = DateValue.new(DateTime.new(1914, 8, 4, 11, 0o1, 6.0123, '+1'))
+          expect(d1).to eq(d2)
+          expect(d1.hash).to eq(d2.hash)
+        end
+
+        it 'reports equal values initialized differently as equal' do
+          d1 = DateValue.new('1914-08-04T11:01:06.0123+01:00')
+          d2 = DateValue.new(DateTime.new(1914, 8, 4, 11, 0o1, 6.0123, '+1'))
+          expect(d1).to eq(d2)
+          expect(d1.hash).to eq(d2.hash)
+        end
+
+        it 'reports unequal values as unequal' do
+          d1 = DateValue.new('1914-08-04T11:01+01:00')
+          d2 = DateValue.new(DateTime.new(1914, 8, 4, 11, 0o1, 6.0123, '+1'))
+          expect(d1).not_to eq(d2)
+          expect(d1.hash).not_to eq(d2.hash)
+        end
+      end
+
+      describe '#to_s' do
+        it 'includes all relevant fields' do
+          val = '1914-08-04T11:01:06.0123+01:00'
+          str = DateValue.new(val).to_s
+          val.split(/[-T:+.]/).each do |v|
+            v = 12_300_000.to_s if v == '0123' # special case nanos
+            expect(str).to include(v)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/datacite/mapping/description_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 module Datacite
   module Mapping
     describe Description do
+
       describe '#load_from_xml' do
         it 'reads XML' do
           xml_text = '<description xml:lang="en-us" descriptionType="Abstract">
@@ -16,7 +17,7 @@ module Datacite
 
           expect(desc.language).to eq(expected_lang)
           expect(desc.type).to eq(expected_type)
-          expect(desc.value.strip).to eq(expected_value)
+          expect(desc.value).to eq(expected_value)
         end
 
         it 'handles escaped HTML' do
@@ -55,12 +56,12 @@ module Datacite
         end
         it 'escapes HTML' do
           desc = Description.new(type: DescriptionType::ABSTRACT, value: '<p>This is HTML text</p>')
-          expected_xml = '<description xml:lang="en" descriptionType="Abstract">&lt;p&gt;This is HTML text&lt;/p&gt;</description>'
+          expected_xml = '<description descriptionType="Abstract">&lt;p&gt;This is HTML text&lt;/p&gt;</description>'
           expect(desc.save_to_xml).to be_xml(expected_xml)
         end
         it 'preserves <br/> and <br></br> tags' do
           desc = Description.new(type: DescriptionType::ABSTRACT, value: '<br/> &lt;br/&gt; abstract <br></br> full <br /> of <br> </br>s')
-          expected_xml = '<description xml:lang="en" descriptionType="Abstract"><br/> &amp;lt;br/&amp;gt; abstract <br/> full <br/> of <br/>s</description>'
+          expected_xml = '<description descriptionType="Abstract"><br/> &amp;lt;br/&amp;gt; abstract <br/> full <br/> of <br/>s</description>'
           expect(desc.save_to_xml).to be_xml(expected_xml)
         end
       end

data/spec/unit/datacite/mapping/funding_reference_spec.rb

@@ -42,11 +42,11 @@ module Datacite
 
         before(:all) do
           @fref_xml = '<fundingReference>
-                                   <funderName>European Commission</funderName>
-                                   <funderIdentifier funderIdentifierType="Crossref Funder ID">http://doi.org/10.13039/501100000780</funderIdentifier>
-                                   <awardNumber awardURI="http://cordis.europa.eu/project/rcn/100180_en.html">282625</awardNumber>
-                                   <awardTitle>MOTivational strength of ecosystem services and alternative ways to express the value of BIOdiversity</awardTitle>
-                                 </fundingReference>'.freeze
+                         <funderName>European Commission</funderName>
+                         <funderIdentifier funderIdentifierType="Crossref Funder ID">http://doi.org/10.13039/501100000780</funderIdentifier>
+                         <awardNumber awardURI="http://cordis.europa.eu/project/rcn/100180_en.html">282625</awardNumber>
+                         <awardTitle>MOTivational strength of ecosystem services and alternative ways to express the value of BIOdiversity</awardTitle>
+                       </fundingReference>'.freeze
 
           @fref = FundingReference.parse_xml(fref_xml)
         end

data/spec/unit/datacite/mapping/geo_location_box_spec.rb

@@ -201,41 +201,5 @@ module Datacite
         end
       end
     end
-
-    describe GeoLocationBoxNode do
-
-      class SomeElement
-        include XML::Mapping
-      end
-
-      describe '#to_value' do
-        it 'parses the value' do
-          xml_text = '-33.45 -122.33 47.61 -70.67'
-          node = GeoLocationBoxNode.new(SomeElement, :box, 'box')
-          expected_box = GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67)
-          expect(node.to_value(xml_text)).to eq(expected_box)
-        end
-        it 'deals with flipped east/west coordinates' do
-          xml_text = '-33.45 -70.67 47.61 -122.33'
-          node = GeoLocationBoxNode.new(SomeElement, :box, 'box')
-          expected_box = GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67)
-          expect(node.to_value(xml_text)).to eq(expected_box)
-        end
-        it 'deals with flipped north/south coordinates' do
-          xml_text = '47.61 -122.33 -33.45 -70.67'
-          node = GeoLocationBoxNode.new(SomeElement, :box, 'box')
-          expected_box = GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67)
-          expect(node.to_value(xml_text)).to eq(expected_box)
-        end
-        it 'deals with weird whitespace' do
-          node = GeoLocationBoxNode.new(SomeElement, :box, 'box')
-          xml_text = %(
-                        -33.45 -122.33\t47.61 -70.67
-                     )
-          expected = GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67)
-          expect(node.to_value(xml_text)).to eq(expected)
-        end
-      end
-    end
   end
 end

data/spec/unit/datacite/mapping/geo_location_point_spec.rb

@@ -119,30 +119,5 @@ module Datacite
         end
       end
     end
-
-    describe GeoLocationPointNode do
-
-      class SomeElement
-        include XML::Mapping
-      end
-
-      describe '#to_value' do
-        it 'parses the value' do
-          node = GeoLocationPointNode.new(SomeElement, :point, 'point')
-          xml_text = '-33.45 -122.33'
-          expected = GeoLocationPoint.new(-33.45, -122.33)
-          expect(node.to_value(xml_text)).to eq(expected)
-        end
-        it 'deals with weird whitespace' do
-          node = GeoLocationPointNode.new(SomeElement, :point, 'point')
-          xml_text = %(
-                        -33.45\t-122.33
-                     )
-          expected = GeoLocationPoint.new(-33.45, -122.33)
-          expect(node.to_value(xml_text)).to eq(expected)
-        end
-      end
-    end
-
   end
 end

data/spec/unit/datacite/mapping/geo_location_polygon_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module Datacite
+  module Mapping
+    describe GeoLocationPolygon do
+      describe '#==' do
+        it 'reports equal values as equal' do
+          polygon1 = GeoLocationPolygon.new(points: [
+            GeoLocationPoint.new(-33.45, -122.33),
+            GeoLocationPoint.new(33.45, -122.33),
+            GeoLocationPoint.new(33.45, 122.33),
+            GeoLocationPoint.new(-33.45, -122.33)
+          ])
+          polygon2 = GeoLocationPolygon.new(points: [
+            GeoLocationPoint.new(-33.45, -122.33),
+            GeoLocationPoint.new(33.45, -122.33),
+            GeoLocationPoint.new(33.45, 122.33),
+            GeoLocationPoint.new(-33.45, -122.33)
+          ])
+          expect(polygon1).to eq(polygon2)
+          expect(polygon1.hash).to eq(polygon2.hash)
+          expect(polygon2).to eq(polygon1)
+          expect(polygon2.hash).to eq(polygon1.hash)
+        end
+
+        it 'reports unequal values as unequal' do
+          polygon1 = GeoLocationPolygon.new(points: [
+            GeoLocationPoint.new(-33.45, -122.33),
+            GeoLocationPoint.new(33.45, -122.33),
+            GeoLocationPoint.new(33.45, 122.33),
+            GeoLocationPoint.new(-33.45, -122.33)
+          ])
+          polygon2 = GeoLocationPolygon.new(points: [
+            GeoLocationPoint.new(33.45, 122.33),
+            GeoLocationPoint.new(-33.45, 122.33),
+            GeoLocationPoint.new(-33.45, -122.33),
+            GeoLocationPoint.new(33.45, 122.33)
+          ])
+          expect(polygon1).not_to eq(polygon2)
+          expect(polygon1.hash).not_to eq(polygon2.hash)
+          expect(polygon2).not_to eq(polygon1)
+          expect(polygon2.hash).not_to eq(polygon1.hash)
+        end
+      end
+    end
+  end
+end

data/spec/unit/datacite/mapping/geo_location_spec.rb

@@ -4,6 +4,29 @@ module Datacite
   module Mapping
 
     describe GeoLocation do
+
+      attr_reader :warnings
+
+      def warnings_including(substring)
+        warnings.select { |w| w.include?(substring) }
+      end
+
+      def expect_warning(substring, count, include_matches = false)
+        matches = warnings_including(substring)
+        found_count = matches.size
+        msg = "expected #{count} warnings including '#{substring}', found #{found_count}"
+        msg << ": #{matches}" if include_matches
+        expect(found_count).to eq(count), msg
+      end
+
+      before(:each) do
+        @warnings = []
+        allow(ReadOnlyNodes).to receive(:warn) do |w|
+          warnings << w
+          Kernel.warn(w) # for debugging
+        end
+      end
+
       describe '#initialize' do
         it 'accepts a point' do
           point = GeoLocationPoint.new(47.61, -122.33)
@@ -20,6 +43,16 @@ module Datacite
           loc = GeoLocation.new(place: place)
           expect(loc.place).to eq(place)
         end
+        it 'accepts a polygon' do
+          polygon = GeoLocationPolygon.new(points: [
+            GeoLocationPoint.new(47.61, -122.33),
+            GeoLocationPoint.new(-33.45, -122.33),
+            GeoLocationPoint.new(47.61, -70.67),
+            GeoLocationPoint.new(47.61, -122.33)
+          ])
+          loc = GeoLocation.new(polygon: polygon)
+          expect(loc.polygon).to eq(polygon)
+        end
         it 'allows an empty location' do
           loc = GeoLocation.new
           expect(loc.point).to be_nil
@@ -70,17 +103,77 @@ module Datacite
         end
       end
 
+      describe '#polygon=' do
+        it 'sets the polygon' do
+          polygon = GeoLocationPolygon.new(points: [
+            GeoLocationPoint.new(47.61, -122.33),
+            GeoLocationPoint.new(-33.45, -122.33),
+            GeoLocationPoint.new(47.61, -70.67),
+            GeoLocationPoint.new(47.61, -122.33)
+          ])
+          loc = GeoLocation.new
+          loc.polygon = polygon
+          expect(loc.polygon).to eq(polygon)
+        end
+      end
+
       describe '#load_from_xml' do
-        it 'parses XML' do
+        it 'parses DC3' do
           xml_text = '<geoLocation>
+                        <geoLocationPlace>Atlantic Ocean</geoLocationPlace>
                         <geoLocationPoint>31.233 -67.302</geoLocationPoint>
                         <geoLocationBox>41.090 -71.032 42.893 -68.211</geoLocationBox>
+                      </geoLocation>'
+          loc = GeoLocation.parse_xml(xml_text)
+          expect(loc.point).to eq(GeoLocationPoint.new(31.233, -67.302))
+          expect(loc.box).to eq(GeoLocationBox.new(41.09, -71.032, 42.893, -68.211))
+          expect(loc.place).to eq('Atlantic Ocean')
+        end
+
+        it 'parses DC4' do
+          xml_text = '<geoLocation>
                         <geoLocationPlace>Atlantic Ocean</geoLocationPlace>
+                        <geoLocationPoint>
+                          <pointLatitude>31.233</pointLatitude>
+                          <pointLongitude>-67.302</pointLongitude>
+                        </geoLocationPoint>
+                        <geoLocationBox>
+                          <southBoundLatitude>41.090</southBoundLatitude>
+                          <westBoundLongitude>-71.032</westBoundLongitude>
+                          <northBoundLatitude>42.893</northBoundLatitude>
+                          <eastBoundLongitude>-68.211</eastBoundLongitude>
+                        </geoLocationBox>
+                        <geoLocationPolygon>
+                          <polygonPoint>
+                            <pointLongitude>-67.302</pointLongitude>
+                            <pointLatitude>31.233</pointLatitude>
+                          </polygonPoint>
+                          <polygonPoint>
+                            <pointLongitude>-71.032</pointLongitude>
+                            <pointLatitude>-68.211</pointLatitude>
+                          </polygonPoint>
+                          <polygonPoint>
+                            <pointLongitude>41.09</pointLongitude>
+                            <pointLatitude>42.893</pointLatitude>
+                          </polygonPoint>
+                          <polygonPoint>
+                            <pointLongitude>-67.302</pointLongitude>
+                            <pointLatitude>31.233</pointLatitude>
+                          </polygonPoint>
+                        </geoLocationPolygon>
                       </geoLocation>'
           loc = GeoLocation.parse_xml(xml_text)
           expect(loc.point).to eq(GeoLocationPoint.new(31.233, -67.302))
           expect(loc.box).to eq(GeoLocationBox.new(41.09, -71.032, 42.893, -68.211))
           expect(loc.place).to eq('Atlantic Ocean')
+          actual_polygon = loc.polygon
+          expected_polygon = GeoLocationPolygon.new(points: [
+            GeoLocationPoint.new(31.233, -67.302),
+            GeoLocationPoint.new(-68.211, -71.032),
+            GeoLocationPoint.new(42.893, 41.09),
+            GeoLocationPoint.new(31.233, -67.302)
+          ])
+          expect(actual_polygon).to eq(expected_polygon)
         end
 
         it 'trims place-name whitespace' do
@@ -95,18 +188,72 @@ module Datacite
       end
 
       describe '#save_to_xml' do
-        it 'writes XML' do
-          loc = GeoLocation.new(
+
+        attr_reader :loc
+
+        before(:each) do
+          @loc = GeoLocation.new(
             point: GeoLocationPoint.new(31.233, -67.302),
             box: GeoLocationBox.new(41.09, -71.032, 42.893, -68.211),
-            place: 'Atlantic Ocean'
+            place: 'Atlantic Ocean',
+            polygon: (GeoLocationPolygon.new(points: [
+              GeoLocationPoint.new(-67.302, 31.233),
+              GeoLocationPoint.new(-71.032, -68.211),
+              GeoLocationPoint.new(41.09, 42.893),
+              GeoLocationPoint.new(-67.302, 31.233)
+            ]))
           )
-          expected_xml = '<geoLocation>
+        end
+
+        describe 'DC4 mode' do
+          it 'writes DC4' do
+            expected_xml = '<geoLocation>
+                              <geoLocationPlace>Atlantic Ocean</geoLocationPlace>
+                              <geoLocationPoint>
+                                <pointLatitude>31.233</pointLatitude>
+                                <pointLongitude>-67.302</pointLongitude>
+                              </geoLocationPoint>
+                              <geoLocationBox>
+                                <westBoundLongitude>-71.032</westBoundLongitude>
+                                <eastBoundLongitude>-68.211</eastBoundLongitude>
+                                <southBoundLatitude>41.09</southBoundLatitude>
+                                <northBoundLatitude>42.893</northBoundLatitude>
+                              </geoLocationBox>
+                              <geoLocationPolygon>
+                                <polygonPoint>
+                                  <pointLongitude>31.233</pointLongitude>
+                                  <pointLatitude>-67.302</pointLatitude>
+                                </polygonPoint>
+                                <polygonPoint>
+                                  <pointLongitude>-68.211</pointLongitude>
+                                  <pointLatitude>-71.032</pointLatitude>
+                                </polygonPoint>
+                                <polygonPoint>
+                                  <pointLongitude>42.893</pointLongitude>
+                                  <pointLatitude>41.09</pointLatitude>
+                                </polygonPoint>
+                                <polygonPoint>
+                                  <pointLongitude>31.233</pointLongitude>
+                                  <pointLatitude>-67.302</pointLatitude>
+                                </polygonPoint>
+                              </geoLocationPolygon>
+                            </geoLocation>'
+            actual_xml = loc.save_to_xml
+            expect(actual_xml).to be_xml(expected_xml)
+          end
+        end
+
+        describe 'DC3 mapping' do
+          it 'writes DC3 points and boxes' do
+            expected_xml = '<geoLocation>
                             <geoLocationPoint>31.233 -67.302</geoLocationPoint>
                             <geoLocationBox>41.09 -71.032 42.893 -68.211</geoLocationBox>
                             <geoLocationPlace>Atlantic Ocean</geoLocationPlace>
                           </geoLocation>'
-          expect(loc.save_to_xml).to be_xml(expected_xml)
+            actual_xml = loc.save_to_xml(mapping: :datacite_3)
+            expect(actual_xml).to be_xml(expected_xml)
+            expect_warning(loc.polygon.to_s, 1)
+          end
         end
       end
     end