geo_combine 0.4.0 → 0.6.0

data/spec/helpers.rb

@@ -1,17 +1,17 @@
+# frozen_string_literal: true
+
 require 'json'
 
 module Helpers
   # From https://gist.github.com/ascendbruce/7070951
   def valid_json?(json)
-    begin
-      JSON.parse(json)
-      return true
-    rescue Exception => e
-      return false
-    end
+    JSON.parse(json)
+    true
+  rescue Exception => e
+    false
   end
 
   def trim(text)
-    %r/\A\s+#{text}\s+\Z/
+    /\A\s+#{text}\s+\Z/
   end
 end

data/spec/lib/geo_combine/bounding_box_spec.rb

@@ -1,58 +1,76 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe GeoCombine::BoundingBox do
   subject(:valid) do
     described_class.new(west: -180, east: 180, north: 90, south: -90)
   end
+
   describe '#to_envelope' do
     it 'returns a valid envelope syntax' do
       expect(valid.to_envelope).to eq 'ENVELOPE(-180.0, 180.0, 90.0, -90.0)'
     end
   end
+
   describe '#valid?' do
     context 'when valid' do
       it { valid.valid? }
     end
+
     context 'when south > north' do
       subject(:invalid) do
         described_class.new(west: -180, east: 180, north: 33, south: 34)
       end
+
       it { expect { invalid.valid? }.to raise_error GeoCombine::Exceptions::InvalidGeometry }
     end
+
     context 'when west > east' do
       subject(:invalid) do
         described_class.new(west: 10, east: -20, north: 90, south: -90)
       end
+
       it { expect { invalid.valid? }.to raise_error GeoCombine::Exceptions::InvalidGeometry }
     end
+
     context 'when west out of range' do
       subject(:invalid) do
         described_class.new(west: -181, east: 180, north: 90, south: -90)
       end
+
       it { expect { invalid.valid? }.to raise_error GeoCombine::Exceptions::InvalidGeometry }
     end
+
     context 'when east out of range' do
       subject(:invalid) do
         described_class.new(west: -180, east: 181, north: 90, south: -90)
       end
+
       it { expect { invalid.valid? }.to raise_error GeoCombine::Exceptions::InvalidGeometry }
     end
+
     context 'when north out of range' do
       subject(:invalid) do
         described_class.new(west: -180, east: 180, north: 91, south: -90)
       end
+
       it { expect { invalid.valid? }.to raise_error GeoCombine::Exceptions::InvalidGeometry }
     end
+
     context 'when south out of range' do
       subject(:invalid) do
         described_class.new(west: -180, east: 180, north: 90, south: -91)
       end
+
       it { expect { invalid.valid? }.to raise_error GeoCombine::Exceptions::InvalidGeometry }
     end
   end
+
   describe '.from_envelope' do
     it { expect(described_class.from_envelope(valid.to_envelope).to_envelope).to eq valid.to_envelope }
   end
+
   describe '.from_string_delimiter' do
     it { expect(described_class.from_string_delimiter('-180, -90, 180, 90').to_envelope).to eq valid.to_envelope }
   end

data/spec/lib/geo_combine/ckan_metadata_spec.rb

@@ -1,63 +1,79 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe GeoCombine::CkanMetadata do
   include JsonDocs
-  let(:ckan_sample) { GeoCombine::CkanMetadata.new(ckan_metadata) }
+  let(:ckan_sample) { described_class.new(ckan_metadata) }
+
   describe '#to_geoblacklight' do
     it 'returns a GeoCombine::Geoblacklight' do
       expect(ckan_sample.to_geoblacklight).to be_an GeoCombine::Geoblacklight
     end
   end
+
   describe '#geoblacklight_terms' do
     describe 'builds a hash which maps metadata' do
       let(:metadata) { ckan_sample.instance_variable_get(:@metadata) }
+
       it 'with dc_identifier_s' do
         expect(ckan_sample.geoblacklight_terms).to include(dc_identifier_s: metadata['id'])
       end
+
       it 'with dc_title_s' do
         expect(ckan_sample.geoblacklight_terms).to include(dc_title_s: metadata['title'])
       end
+
       it 'with dc_rights_s' do
         expect(ckan_sample.geoblacklight_terms).to include(dc_rights_s: 'Public')
       end
+
       it 'with dct_provenance_s' do
         expect(ckan_sample.geoblacklight_terms).to include(dct_provenance_s: metadata['organization']['title'])
       end
+
       it 'with layer_slug_s' do
         expect(ckan_sample.geoblacklight_terms).to include(layer_slug_s: metadata['name'])
       end
+
       it 'with solr_geom' do
         expect(ckan_sample.geoblacklight_terms).to include(solr_geom: 'ENVELOPE(-158.2, -105.7, 59.2, 8.9)')
       end
+
       it 'with dc_subject_sm' do
         expect(ckan_sample.geoblacklight_terms[:dc_subject_sm].length).to eq 63
       end
+
       context 'with no information resources' do
         let(:ckan_sample) do
-          ckan = GeoCombine::CkanMetadata.new(ckan_metadata)
+          ckan = described_class.new(ckan_metadata)
           metadata = ckan.instance_variable_get('@metadata')
           metadata['resources'].delete_if { |resource| resource['resource_locator_function'] == 'information' }
           ckan
         end
+
         it 'has no url (home page) in dct_references_s' do
           expect(JSON.parse(ckan_sample.geoblacklight_terms[:dct_references_s])).not_to include('http://schema.org/url')
         end
       end
+
       context 'with no download resources' do
         let(:ckan_sample) do
-          ckan = GeoCombine::CkanMetadata.new(ckan_metadata)
+          ckan = described_class.new(ckan_metadata)
           metadata = ckan.instance_variable_get('@metadata')
           metadata['resources'].delete_if { |resource| resource['resource_locator_function'] == 'download' }
           ckan
         end
+
         it 'has no downloadUrl in dct_references_s' do
-          expect(ckan_sample.downloadable?).to be_falsey
+          expect(ckan_sample).not_to be_downloadable
           expect(JSON.parse(ckan_sample.geoblacklight_terms[:dct_references_s])).not_to include('http://schema.org/downloadUrl')
         end
       end
+
       context 'with a ZIP download' do
         let(:ckan_sample) do
-          ckan = GeoCombine::CkanMetadata.new(ckan_metadata)
+          ckan = described_class.new(ckan_metadata)
           metadata = ckan.instance_variable_get('@metadata')
           metadata['resources'] = [
             {
@@ -68,43 +84,50 @@ RSpec.describe GeoCombine::CkanMetadata do
           ]
           ckan
         end
+
         it 'has a format and a download URL' do
-          expect(ckan_sample.downloadable?).to be_truthy
+          expect(ckan_sample).to be_downloadable
           expect(ckan_sample.geoblacklight_terms).to include(dc_format_s: 'ZIP')
           expect(JSON.parse(ckan_sample.geoblacklight_terms[:dct_references_s])).to include('http://schema.org/downloadUrl' => 'https://example.com/layer.zip')
         end
       end
+
       context 'without any resources' do
         let(:ckan_sample) do
-          ckan = GeoCombine::CkanMetadata.new(ckan_metadata)
+          ckan = described_class.new(ckan_metadata)
           metadata = ckan.instance_variable_get('@metadata')
           metadata.delete('resources')
           ckan
         end
+
         it 'has no urls in dct_references_s' do
-          expect(ckan_sample.downloadable?).to be_falsey
+          expect(ckan_sample).not_to be_downloadable
           expect(JSON.parse(ckan_sample.geoblacklight_terms[:dct_references_s])).not_to include('http://schema.org/url')
           expect(JSON.parse(ckan_sample.geoblacklight_terms[:dct_references_s])).not_to include('http://schema.org/downloadUrl')
         end
       end
+
       context 'with very long descriptions' do
         let(:ckan_sample) do
-          ckan = GeoCombine::CkanMetadata.new(ckan_metadata)
+          ckan = described_class.new(ckan_metadata)
           metadata = ckan.instance_variable_get('@metadata')
-          metadata['notes'] = 'x' * 50000
+          metadata['notes'] = 'x' * 50_000
           ckan
         end
+
         it 'restricts the size' do
           expect(ckan_sample.geoblacklight_terms[:dc_description_s].length).to eq GeoCombine::CkanMetadata::MAX_STRING_LENGTH + 1
         end
       end
+
       context 'with no descriptions' do
         let(:ckan_sample) do
-          ckan = GeoCombine::CkanMetadata.new(ckan_metadata)
+          ckan = described_class.new(ckan_metadata)
           metadata = ckan.instance_variable_get('@metadata')
           metadata['notes'] = nil
           ckan
         end
+
         it 'omits the description' do
           expect(ckan_sample.geoblacklight_terms).not_to include(:dc_description_s)
         end

data/spec/lib/geo_combine/esri_open_data_spec.rb

@@ -1,83 +1,104 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe GeoCombine::EsriOpenData do
   include JsonDocs
-  let(:esri_sample) { GeoCombine::EsriOpenData.new(esri_opendata_metadata) }
+  let(:esri_sample) { described_class.new(esri_opendata_metadata) }
   let(:metadata) { esri_sample.instance_variable_get(:@metadata) }
+
   describe '#initialize' do
     it 'parses metadata argument JSON to Hash' do
       expect(esri_sample.instance_variable_get(:@metadata)).to be_an Hash
     end
+
     it 'puts extend data into @geometry' do
       expect(esri_sample.instance_variable_get(:@geometry)).to be_an Array
     end
   end
+
   describe '#to_geoblacklight' do
     it 'calls geoblacklight_terms to create a GeoBlacklight object' do
       expect(esri_sample).to receive(:geoblacklight_terms).and_return({})
       expect(esri_sample.to_geoblacklight).to be_an GeoCombine::Geoblacklight
     end
   end
+
   describe '#geoblacklight_terms' do
     describe 'builds a hash which maps metadata' do
       let(:metadata) { esri_sample.instance_variable_get(:@metadata) }
+
       it 'with dc_identifier_s' do
         expect(esri_sample.geoblacklight_terms).to include(dc_identifier_s: metadata['id'])
       end
+
       it 'with dc_title_s' do
         expect(esri_sample.geoblacklight_terms).to include(dc_title_s: metadata['name'])
       end
+
       it 'with dc_description_s sanitized' do
         expect(esri_sample).to receive(:sanitize_and_remove_lines).and_return 'sanitized'
         expect(esri_sample.geoblacklight_terms).to include(dc_description_s: 'sanitized')
       end
+
       it 'with dc_rights_s' do
         expect(esri_sample.geoblacklight_terms).to include(dc_rights_s: 'Public')
       end
+
       it 'with dct_provenance_s' do
         expect(esri_sample.geoblacklight_terms).to include(dct_provenance_s: metadata['owner'])
       end
+
       it 'with dct_references_s' do
         expect(esri_sample).to receive(:references).and_return ''
         expect(esri_sample.geoblacklight_terms).to include(:dct_references_s)
       end
+
       it 'with layer_id_s that is blank' do
         expect(esri_sample.geoblacklight_terms).to include(layer_id_s: '')
       end
+
       it 'with layer_geom_type_s' do
         expect(esri_sample.geoblacklight_terms).to include(layer_geom_type_s: metadata['geometry_type'])
       end
+
       it 'with layer_modified_dt' do
         expect(esri_sample.geoblacklight_terms).to include(layer_modified_dt: metadata['updated_at'])
       end
+
       it 'with layer_slug_s' do
         expect(esri_sample.geoblacklight_terms).to include(layer_slug_s: metadata['id'])
       end
+
       it 'with solr_geom' do
         expect(esri_sample).to receive(:envelope).and_return ''
         expect(esri_sample.geoblacklight_terms).to include(solr_geom: '')
       end
+
       it 'with dc_subject_sm' do
         expect(esri_sample.geoblacklight_terms).to include(dc_subject_sm: metadata['tags'])
       end
     end
   end
+
   describe '#references' do
     it 'converts references to a JSON string' do
       expect(esri_sample).to receive(:references_hash).and_return({})
       expect(esri_sample.references).to be_an String
     end
   end
+
   describe '#references_hash' do
     it 'builds out references' do
       expect(esri_sample.references_hash).to include('http://schema.org/url' => metadata['landing_page'])
       expect(esri_sample.references_hash).to include('http://resources.arcgis.com/en/help/arcgis-rest-api' => metadata['url'])
     end
   end
+
   describe '#envelope' do
     it 'creates an envelope for use in Solr' do
       expect(esri_sample.envelope).to be_an String
-      expect(esri_sample.envelope).to match /ENVELOPE\(.+,.+,.+,.+\)/
+      expect(esri_sample.envelope).to match(/ENVELOPE\(.+,.+,.+,.+\)/)
     end
   end
 end

data/spec/lib/geo_combine/fgdc_spec.rb

@@ -1,103 +1,134 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe GeoCombine::Fgdc do
   include XmlDocs
-  let(:fgdc_object){ GeoCombine::Fgdc.new(tufts_fgdc) }
+  let(:fgdc_object) { described_class.new(tufts_fgdc) }
+
   describe '#initialize' do
     it 'returns an instantiated Fgdc object' do
-      expect(fgdc_object).to be_an GeoCombine::Fgdc
+      expect(fgdc_object).to be_an described_class
     end
   end
+
   describe '#xsl_geoblacklight' do
-    it 'should be defined' do
+    it 'is defined' do
       expect(fgdc_object.xsl_geoblacklight).to be_an Nokogiri::XSLT::Stylesheet
     end
   end
-  describe '#xsl_html'do
-    it 'should be defined' do
+
+  describe '#xsl_html' do
+    it 'is defined' do
       expect(fgdc_object.xsl_html).to be_an Nokogiri::XSLT::Stylesheet
     end
   end
+
   describe '#to_geoblacklight' do
     let(:fgdc_geobl) { fgdc_object.to_geoblacklight }
+
     it 'returns a GeoCombine::Geoblacklight object' do
       expect(fgdc_geobl).to be_an GeoCombine::Geoblacklight
     end
+
     it 'is not valid due to bad modification date but valid otherwise' do
       expect { fgdc_geobl.valid? }.to raise_error(JSON::Schema::ValidationError, /layer_modified_dt/)
       fgdc_geobl.metadata.delete 'layer_modified_dt'
-      expect(fgdc_geobl.valid?).to be_truthy
+      expect(fgdc_geobl).to be_valid
     end
+
     describe 'with GeoBlacklight-Schema fields' do
       it 'geoblacklight_version' do
         expect(fgdc_geobl.metadata['geoblacklight_version']).to eq '1.0'
       end
+
       it 'dc_identifier_s' do
         expect(fgdc_geobl.metadata['dc_identifier_s']).to eq 'http://www.geoportaligm.gob.ec/portal/'
       end
+
       it 'dc_title_s' do
         expect(fgdc_geobl.metadata['dc_title_s']).to eq 'Drilling Towers 50k Scale Ecuador 2011'
       end
+
       it 'dc_description_s' do
-        expect(fgdc_geobl.metadata['dc_description_s']).to match /Ecuador created from/
+        expect(fgdc_geobl.metadata['dc_description_s']).to match(/Ecuador created from/)
       end
+
       it 'dc_rights_s' do
         expect(fgdc_geobl.metadata['dc_rights_s']).to eq 'Public'
       end
+
       it 'dct_provenance_s' do
         expect(fgdc_geobl.metadata['dct_provenance_s']).to eq 'Tufts'
       end
+
       it 'layer_id_s' do
         expect(fgdc_geobl.metadata['layer_id_s']).to eq 'urn:Ecuador50KDrillingTower11'
       end
+
       it 'layer_slug_s' do
         expect(fgdc_geobl.metadata['layer_slug_s']).to eq 'Tufts-Ecuador50KDrillingTower11'
       end
+
       it 'layer_modified_dt' do
         expect(fgdc_geobl.metadata['layer_modified_dt']).to eq '2013-08-13'
       end
+
       it 'dc_creator_sm' do
         expect(fgdc_geobl.metadata['dc_creator_sm']).to be_an Array
         expect(fgdc_geobl.metadata['dc_creator_sm']).to include 'Instituto Geografico Militar (Ecuador)'
       end
+
       it 'dc_format_s' do
         expect(fgdc_geobl.metadata['dc_format_s']).to eq 'Shapefile'
       end
+
       it 'dc_language_s' do
         expect(fgdc_geobl.metadata['dc_language_s']).to eq 'English'
       end
+
       it 'dc_type_s' do
         expect(fgdc_geobl.metadata['dc_type_s']).to eq 'Dataset'
       end
+
       it 'dc_subject_sm' do
         expect(fgdc_geobl.metadata['dc_subject_sm']).to be_an Array
-        expect(fgdc_geobl.metadata['dc_subject_sm']).to include 'point', 'structure', 'economy', 'Drilling platforms', 'Oil well drilling'
+        expect(fgdc_geobl.metadata['dc_subject_sm']).to include 'point', 'structure', 'economy', 'Drilling platforms',
+                                                                'Oil well drilling'
       end
+
       it 'dc_spatial_sm' do
         expect(fgdc_geobl.metadata['dc_spatial_sm']).to be_an Array
-        expect(fgdc_geobl.metadata['dc_spatial_sm']).to include 'Ecuador', 'República del Ecuador', 'Northern Hemisphere', 'Southern Hemisphere', 'Western Hemisphere', 'South America'
+        expect(fgdc_geobl.metadata['dc_spatial_sm']).to include 'Ecuador', 'República del Ecuador',
+                                                                'Northern Hemisphere', 'Southern Hemisphere', 'Western Hemisphere', 'South America'
       end
+
       it 'dct_issued_s' do
         expect(fgdc_geobl.metadata['dct_issued_s']).to eq '2011'
       end
+
       it 'dct_temporal_sm' do
         expect(fgdc_geobl.metadata['dct_temporal_sm']).to be_an Array
         expect(fgdc_geobl.metadata['dct_temporal_sm']).to include '2011'
       end
+
       it 'dct_isPartOf_sm' do
         expect(fgdc_geobl.metadata['dct_isPartOf_sm']).to be_an Array
         expect(fgdc_geobl.metadata['dct_isPartOf_sm']).to include 'Ecuador', 'Instituto Geografico Militar Data'
       end
+
       it 'solr_geom' do
         expect(fgdc_geobl.metadata['solr_geom']).to eq 'ENVELOPE(-79.904768, -79.904768, -1.377743, -1.377743)'
       end
+
       it 'solr_year_i' do
         expect(fgdc_geobl.metadata['solr_year_i']).to eq 2011
       end
     end
   end
+
   describe '#to_html' do
-    it 'should create a transformation of the metadata as a String' do
+    it 'creates a transformation of the metadata as a String' do
       expect(fgdc_object.to_html).to be_an String
     end
   end

data/spec/lib/geo_combine/formatting_spec.rb

@@ -1,26 +1,34 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe GeoCombine::Formatting do
+  subject { Object.new.extend(described_class) }
+
   let(:dirty) { "<p>paragraph</p> \n on a new line" }
-  subject { Object.new.extend(GeoCombine::Formatting) }
+
   describe '#sanitize' do
     it 'sanitizes a fragment' do
-      expect(subject.sanitize(dirty)).to_not match('<p>')
+      expect(subject.sanitize(dirty)).not_to match('<p>')
     end
   end
+
   describe '#remove_lines' do
     it 'removes new lines' do
-      expect(subject.remove_lines(dirty)).to_not match(/\n/)
+      expect(subject.remove_lines(dirty)).not_to match(/\n/)
     end
   end
+
   describe '#sanitize_and_remove_lines' do
     it 'returns a corrected string' do
-      expect(subject.sanitize_and_remove_lines(dirty)).to_not match('<p>')
-      expect(subject.sanitize_and_remove_lines(dirty)).to_not match(/\n/)
+      expect(subject.sanitize_and_remove_lines(dirty)).not_to match('<p>')
+      expect(subject.sanitize_and_remove_lines(dirty)).not_to match(/\n/)
     end
   end
+
   describe '#sluggify' do
     let(:preslug) { 'HARVARD...Co_0l' }
+
     it 'handles multiple . and _ and uppercase' do
       expect(subject.sluggify(preslug)).to eq 'harvard-co-0l'
     end