datacite-mapping 0.1.0

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

@@ -0,0 +1,89 @@
+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">
+                        XML example of all DataCite Metadata Schema v3.1 properties.
+                      </description>'
+          xml = REXML::Document.new(xml_text).root
+          desc = Description.load_from_xml(xml)
+
+          expected_lang = 'en-us'
+          expected_type = DescriptionType::ABSTRACT
+          expected_value = 'XML example of all DataCite Metadata Schema v3.1 properties.'
+
+          expect(desc.language).to eq(expected_lang)
+          expect(desc.type).to eq(expected_type)
+          expect(desc.value.strip).to eq(expected_value)
+        end
+
+        it 'handles escaped HTML' do
+          xml_text = '<description xml:lang="en-us" descriptionType="Abstract">
+                        &lt;p&gt;This is HTML text&lt;/p&gt;&lt;p&gt;&lt;small&gt;despite the advice in the standard&lt;/small&gt;&lt;/p&gt;
+                      </description>'
+          xml = REXML::Document.new(xml_text).root
+          desc = Description.load_from_xml(xml)
+
+          expected_value = '<p>This is HTML text</p><p><small>despite the advice in the standard</small></p>'
+          expect(desc.value).to eq(expected_value)
+        end
+
+        it 'strips extra whitespace' do
+          xml_text = '<description xml:lang="en-us" descriptionType="Abstract">
+                        This is the value
+                      </description>'
+          xml = REXML::Document.new(xml_text).root
+          desc = Description.load_from_xml(xml)
+          expect(desc.value).to eq('This is the value')
+        end
+
+        it 'allows un-escaped <br/> and <br></br> tags' do
+          xml_text = '<description descriptionType="Abstract">
+                        I am an <br></br> abstract <br/> full <br/> of &lt;br/&gt;s
+                      </description>'
+          xml = REXML::Document.new(xml_text).root
+          desc = Description.load_from_xml(xml)
+          expected_value = 'I am an <br/> abstract <br/> full <br/> of <br/>s'
+          expect(desc.value.strip).to eq(expected_value)
+        end
+      end
+
+      describe '#save_to_xml' do
+        it 'writes XML' do
+          desc = Description.new(language: 'en-us', type: DescriptionType::ABSTRACT, value: 'foo')
+          expected_xml = '<description xml:lang="en-us" descriptionType="Abstract">foo</description>'
+          expect(desc.save_to_xml).to be_xml(expected_xml)
+        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>'
+          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>'
+          expect(desc.save_to_xml).to be_xml(expected_xml)
+        end
+      end
+
+      it 'round-trips to XML' do
+        xml_text = '<description xml:lang="en-us" descriptionType="Abstract">foo</description>'
+        xml = REXML::Document.new(xml_text).root
+        desc = Description.load_from_xml(xml)
+        expect(desc.save_to_xml).to be_xml(xml_text)
+      end
+
+      it 'un-escapes <br/> tags when round-tripping' do
+        xml_text = '<description xml:lang="en-us" descriptionType="Abstract"><br/> &lt;br/&gt; abstract <br></br> full <br /> of <br> </br>s</description>'
+        xml = REXML::Document.new(xml_text).root
+        desc = Description.load_from_xml(xml)
+        expected_xml = '<description xml:lang="en-us" descriptionType="Abstract"><br/> <br/> abstract <br></br> full <br /> of <br> </br>s</description>'
+        expect(desc.save_to_xml).to be_xml(expected_xml)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,241 @@
+require 'spec_helper'
+
+module Datacite
+  module Mapping
+    describe GeoLocationBox do
+      describe '#initialize' do
+        it 'accepts a lat/long/lat/long quad' do
+          box = GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67)
+          expect(box.south_latitude).to eq(-33.45)
+          expect(box.west_longitude).to eq(-122.33)
+          expect(box.north_latitude).to eq(47.61)
+          expect(box.east_longitude).to eq(-70.67)
+        end
+
+        it 'accepts a quad with flipped east/west coordinates' do
+          box = GeoLocationBox.new(-33.45, -70.67, 47.61, -122.33)
+          expect(box.south_latitude).to eq(-33.45)
+          expect(box.west_longitude).to eq(-122.33)
+          expect(box.north_latitude).to eq(47.61)
+          expect(box.east_longitude).to eq(-70.67)
+        end
+
+        it 'accepts a quad with flipped north/south coordinates' do
+          box = GeoLocationBox.new(47.61, -122.33, -33.45, -70.67)
+          expect(box.south_latitude).to eq(-33.45)
+          expect(box.west_longitude).to eq(-122.33)
+          expect(box.north_latitude).to eq(47.61)
+          expect(box.east_longitude).to eq(-70.67)
+        end
+
+        it 'accepts :south_latitude, :west_longitude, :north_latitude, :east_longitude' do
+          box = GeoLocationBox.new(
+            south_latitude: -33.45,
+            west_longitude: -122.33,
+            north_latitude: 47.61,
+            east_longitude: -70.67
+          )
+          expect(box.south_latitude).to eq(-33.45)
+          expect(box.west_longitude).to eq(-122.33)
+          expect(box.north_latitude).to eq(47.61)
+          expect(box.east_longitude).to eq(-70.67)
+        end
+
+        it 'requires all four coordinates with hash arguments' do
+          all_args = {
+            south_latitude: -33.45,
+            west_longitude: -122.33,
+            north_latitude: 47.61,
+            east_longitude: -70.67
+          }
+          all_args.each_key do |k|
+            bad_args = all_args.select { |k2, _v2| k2 == k }
+            expect { GeoLocationBox.new(bad_args) }.to raise_error(ArgumentError)
+          end
+        end
+
+        it 'requires all four coordinates with array arguments' do
+          expect { GeoLocationBox.new(-33.45, -122.33, 47.61) }.to raise_error(ArgumentError)
+        end
+
+        it 'rejects extra array arguments' do
+          expect { GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67, -33.45) }.to raise_error(ArgumentError)
+        end
+
+        it 'rejects extra hash arguments' do
+          expect do
+            GeoLocationBox.new(
+              south_latitude: -33.45,
+              west_longitude: -122.33,
+              north_latitude: 47.61,
+              east_longitude: -70.67,
+              latitude: 47.61,
+              longitude: -122.33
+            )
+          end.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#south_latitude=' do
+        it 'sets the south_latitude' do
+          box = GeoLocationBox.allocate
+          box.south_latitude = 47.61
+          expect(box.south_latitude).to eq(47.61)
+        end
+        it 'requires a value' do
+          box = GeoLocationBox.allocate
+          expect { box.south_latitude = nil }.to raise_error(ArgumentError)
+        end
+        it 'rejects bad values' do
+          box = GeoLocationBox.allocate
+          expect { box.south_latitude = 91 }.to raise_error(ArgumentError)
+          expect { box.south_latitude = -91 }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#west_longitude=' do
+        it 'sets the west_longitude' do
+          box = GeoLocationBox.allocate
+          box.west_longitude = 47.61
+          expect(box.west_longitude).to eq(47.61)
+        end
+        it 'requires a value' do
+          box = GeoLocationBox.allocate
+          expect { box.west_longitude = nil }.to raise_error(ArgumentError)
+        end
+        it 'rejects bad values' do
+          box = GeoLocationBox.allocate
+          expect { box.west_longitude = 181 }.to raise_error(ArgumentError)
+          expect { box.west_longitude = -181 }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#north_latitude=' do
+        it 'sets the north_latitude' do
+          box = GeoLocationBox.allocate
+          box.north_latitude = 47.61
+          expect(box.north_latitude).to eq(47.61)
+        end
+        it 'requires a value' do
+          box = GeoLocationBox.allocate
+          expect { box.north_latitude = nil }.to raise_error(ArgumentError)
+        end
+        it 'rejects bad values' do
+          box = GeoLocationBox.allocate
+          expect { box.north_latitude = 91 }.to raise_error(ArgumentError)
+          expect { box.north_latitude = -91 }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#east_longitude=' do
+        it 'sets the east_longitude' do
+          box = GeoLocationBox.allocate
+          box.east_longitude = 47.61
+          expect(box.east_longitude).to eq(47.61)
+        end
+        it 'requires a value' do
+          box = GeoLocationBox.allocate
+          expect { box.east_longitude = nil }.to raise_error(ArgumentError)
+        end
+        it 'rejects bad values' do
+          box = GeoLocationBox.allocate
+          expect { box.east_longitude = 181 }.to raise_error(ArgumentError)
+          expect { box.east_longitude = -181 }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#==' do
+        it 'reports equal values as equal' do
+          box1 = GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67)
+          box2 = GeoLocationBox.new(
+            south_latitude: -33.45,
+            west_longitude: -122.33,
+            north_latitude: 47.61,
+            east_longitude: -70.67
+          )
+          expect(box1).to eq(box2)
+          expect(box2).to eq(box1)
+        end
+        it 'reports unequal values as unequal' do
+          box1 = GeoLocationBox.new(-47.61, -70.67, -33.45, 122.33)
+          box2 = GeoLocationBox.new(
+            south_latitude: -33.45,
+            west_longitude: -122.33,
+            north_latitude: 47.61,
+            east_longitude: -70.67
+          )
+          expect(box1).not_to eq(box2)
+          expect(box2).not_to eq(box1)
+        end
+      end
+
+      describe '#hash' do
+        it 'reports equal values as having equal hashes' do
+          box1 = GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67)
+          box2 = GeoLocationBox.new(
+            south_latitude: -33.45,
+            west_longitude: -122.33,
+            north_latitude: 47.61,
+            east_longitude: -70.67
+          )
+          expect(box1.hash).to eq(box2.hash)
+          expect(box2.hash).to eq(box1.hash)
+        end
+        it 'reports unequal values as having unequal hashes' do
+          box1 = GeoLocationBox.new(-47.61, -70.67, -33.45, 122.33)
+          box2 = GeoLocationBox.new(
+            south_latitude: -33.45,
+            west_longitude: -122.33,
+            north_latitude: 47.61,
+            east_longitude: -70.67
+          )
+          expect(box1.hash).not_to eq(box2.hash)
+          expect(box2.hash).not_to eq(box1.hash)
+        end
+      end
+
+      describe '#to_s' do
+        it 'returns the coordinates' do
+          box = GeoLocationBox.new(-33.45, -122.33, 47.61, -70.67)
+          expect(box.to_s).to eq('-33.45 -122.33 47.61 -70.67')
+        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

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+module Datacite
+  module Mapping
+    describe GeoLocationPoint do
+      describe '#initialize' do
+        it 'accepts a lat/long pair' do
+          point = GeoLocationPoint.new(47.61, -122.33)
+          expect(point.latitude).to eq(47.61)
+          expect(point.longitude).to eq(-122.33)
+        end
+
+        it 'accepts :latitude and :longitude' do
+          point = GeoLocationPoint.new(latitude: 47.61, longitude: -122.33)
+          expect(point.latitude).to eq(47.61)
+          expect(point.longitude).to eq(-122.33)
+        end
+
+        it 'requires both latitude and longitude' do
+          expect { GeoLocationPoint.new(47.61) }.to raise_error(ArgumentError)
+          expect { GeoLocationPoint.new(latitude: 47.61) }.to raise_error(ArgumentError)
+          expect { GeoLocationPoint.new(longitude: -122.33) }.to raise_error(ArgumentError)
+        end
+
+        it 'rejects extra array arguments' do
+          expect { GeoLocationPoint.new(47.61, -122.33, -70.67) }.to raise_error(ArgumentError)
+        end
+
+        it 'rejects extra hash arguments' do
+          expect { GeoLocationPoint.new(latitude: 47.61, longitude: -122.33, south_latitude: -70.67) }.to raise_error(ArgumentError)
+        end
+
+        it 'rejects bad values' do
+          expect { GeoLocationPoint.new(91, -122.33) }.to raise_error(ArgumentError)
+          expect { GeoLocationPoint.new(-91, -122.33) }.to raise_error(ArgumentError)
+          expect { GeoLocationPoint.new(47.61, 181) }.to raise_error(ArgumentError)
+          expect { GeoLocationPoint.new(47.61, -181) }.to raise_error(ArgumentError)
+          expect { GeoLocationPoint.new(latitude: 91, longitude: -122.33) }.to raise_error(ArgumentError)
+          expect { GeoLocationPoint.new(latitude: -91, longitude: -122.33) }.to raise_error(ArgumentError)
+          expect { GeoLocationPoint.new(latitude: 47.61, longitude: 181) }.to raise_error(ArgumentError)
+          expect { GeoLocationPoint.new(latitude: 47.61, longitude: -181) }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#latitude=' do
+        it 'sets the latitude' do
+          point = GeoLocationPoint.allocate
+          point.latitude = 47.61
+          expect(point.latitude).to eq(47.61)
+        end
+        it 'requires a value' do
+          point = GeoLocationPoint.allocate
+          expect { point.latitude = nil }.to raise_error(ArgumentError)
+        end
+        it 'rejects bad values' do
+          point = GeoLocationPoint.allocate
+          expect { point.latitude = 91 }.to raise_error(ArgumentError)
+          expect { point.latitude = -91 }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#longitude=' do
+        it 'sets the longitude' do
+          point = GeoLocationPoint.allocate
+          point.longitude = 47.61
+          expect(point.longitude).to eq(47.61)
+        end
+        it 'requires a value' do
+          point = GeoLocationPoint.allocate
+          expect { point.longitude = nil }.to raise_error(ArgumentError)
+        end
+        it 'rejects bad values' do
+          point = GeoLocationPoint.allocate
+          expect { point.longitude = 181 }.to raise_error(ArgumentError)
+          expect { point.longitude = -181 }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#==' do
+        it 'reports equal values as equal' do
+          point1 = GeoLocationPoint.new(-33.45, -122.33)
+          point2 = GeoLocationPoint.new(
+            latitude: -33.45,
+            longitude: -122.33
+          )
+          expect(point1).to eq(point2)
+          expect(point2).to eq(point1)
+        end
+        it 'reports unequal values as unequal' do
+          point1 = GeoLocationPoint.new(-47.61, -70.67)
+          point2 = GeoLocationPoint.new(-33.45, -122.33)
+          expect(point1).not_to eq(point2)
+          expect(point2).not_to eq(point1)
+        end
+      end
+
+      describe '#hash' do
+        it 'reports equal values as having equal hashes' do
+          point1 = GeoLocationPoint.new(-33.45, -122.33)
+          point2 = GeoLocationPoint.new(
+            latitude: -33.45,
+            longitude: -122.33
+          )
+          expect(point1.hash).to eq(point2.hash)
+          expect(point2.hash).to eq(point1.hash)
+        end
+        it 'reports unequal values as having unequal hashes' do
+          point1 = GeoLocationPoint.new(-47.61, -70.67)
+          point2 = GeoLocationPoint.new(-33.45, -122.33)
+          expect(point1.hash).not_to eq(point2.hash)
+          expect(point2.hash).not_to eq(point1.hash)
+        end
+      end
+
+      describe '#to_s' do
+        it 'returns the coordinates' do
+          point = GeoLocationPoint.new(-33.45, -122.33)
+          expect(point.to_s).to eq('-33.45 -122.33')
+        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