dwc-archive 0.9.10 → 1.1.2

data/spec/lib/core_spec.rb

@@ -1,97 +1,99 @@
-require_relative '../spec_helper'
+# frozen_string_literal: true
+
+require_relative "../spec_helper"
 
 describe DarwinCore::Core do
   subject(:dwca) { DarwinCore.new(file_path) }
   subject(:core) { DarwinCore::Core.new(dwca) }
-  let(:file_path) { File.join(File.expand_path('../../files', __FILE__), 
-                             file_name) }
-  let(:file_name) { 'data.tar.gz' }
-  
+  let(:file_path) do
+    File.join(File.expand_path("../files", __dir__), file_name)
+  end
+  let(:file_name) { "data.tar.gz" }
 
-  describe '.new' do
-    it 'creates new core' do
+  describe ".new" do
+    it "creates new core" do
       expect(core).to be_kind_of DarwinCore::Core
     end
   end
-  
-  describe '#id' do
 
-    it 'returns core id' do
+  describe "#id" do
+    it "returns core id" do
       expect(core.id[:index]).to eq 0
-      expect(core.id[:term]).to eq 'http://rs.tdwg.org/dwc/terms/TaxonID'
+      expect(core.id[:term]).to eq "http://rs.tdwg.org/dwc/terms/TaxonID"
     end
 
-    context 'no coreid' do
-      let(:file_name) { 'empty_coreid.tar.gz' }
+    context "no coreid" do
+      let(:file_name) { "empty_coreid.tar.gz" }
 
-      it 'does not return coreid' do
+      it "does not return coreid" do
         expect(core.id[:index]).to eq 0
         expect(core.id[:term]).to be_nil
       end
     end
   end
 
-  describe '#data' do
-    it 'gers core data' do
+  describe "#data" do
+    it "gers core data" do
       expect(core.data).to be_kind_of Hash
     end
   end
 
-  describe '#properties' do
-    it 'gers core properties' do
+  describe "#properties" do
+    it "gers core properties" do
       expect(core.properties).to be_kind_of Hash
-      expect(core.properties.keys).to match_array [:encoding, 
-        :fieldsTerminatedBy, :linesTerminatedBy, :fieldsEnclosedBy, 
-        :ignoreHeaderLines, :rowType ]
+      expect(core.properties.keys).to match_array %i[
+        encoding fieldsTerminatedBy linesTerminatedBy fieldsEnclosedBy
+        ignoreHeaderLines rowType
+      ]
     end
   end
-  
-  describe '#encoding' do
-    it 'returns encoding of the data' do
-      expect(core.encoding).to eq 'UTF-8'
+
+  describe "#encoding" do
+    it "returns encoding of the data" do
+      expect(core.encoding).to eq "UTF-8"
     end
   end
 
-  describe '#fields_separator' do
-    it 'returns separator of fields for csv files' do
+  describe "#fields_separator" do
+    it "returns separator of fields for csv files" do
       expect(core.fields_separator).to be_nil
     end
   end
 
-  describe '#size' do
-    it 'returns number of lines in the core' do
+  describe "#size" do
+    it "returns number of lines in the core" do
       expect(core.size).to eq 588
     end
   end
 
-  describe '#file_path' do
-    it 'returns file path of core file' do
-      expect(core.file_path).to match 'DarwinCore.txt'
+  describe "#file_path" do
+    it "returns file path of core file" do
+      expect(core.file_path).to match "DarwinCore.txt"
     end
   end
 
-  describe '#fields' do
-    it 'returns fields of the core file' do
+  describe "#fields" do
+    it "returns fields of the core file" do
       expect(core.fields.size).to eq 7
       expect(core.fields).to be_kind_of Array
       expect(core.fields[0]).to be_kind_of Hash
     end
   end
 
-  describe '#line_separator' do
-    it 'returns characters separating lines in csv file' do
+  describe "#line_separator" do
+    it "returns characters separating lines in csv file" do
       expect(core.line_separator).to eq "\\n"
     end
   end
 
-  describe '#quote_character' do
-    it 'returns quote character for the csv file' do
-      expect(core.quote_character).to eq ''
+  describe "#quote_character" do
+    it "returns quote character for the csv file" do
+      expect(core.quote_character).to eq ""
     end
   end
 
-  describe '#ignore headers' do
-    it 'returns true if headers should not be included into data' do
+  describe "#ignore headers" do
+    it "returns true if headers should not be included into data" do
       expect(core.ignore_headers).to eq true
     end
   end

data/spec/lib/darwin_core_spec.rb

@@ -1,279 +1,249 @@
-require_relative '../spec_helper'
+# frozen_string_literal: true
 
 describe DarwinCore do
   subject { DarwinCore }
-  let(:file_dir) { File.expand_path('../../files', __FILE__) }
+  let(:file_dir) { File.expand_path("../files", __dir__) }
 
-  it 'breaks for ruby 1.8 and older' do
-    stub_const('RUBY_VERSION', '1.8.7') 
-    expect{load File.expand_path('../../../lib/dwc-archive.rb', __FILE__)}.
-      to raise_error
+  it "has version" do
+    expect(DarwinCore::VERSION).to match(/\d+\.\d+\.\d/)
   end
 
-  it 'continues for ruby 1.9.1 and higher' do
-    stub_const('RUBY_VERSION', '1.9.2') 
-    expect{load File.expand_path('../../../lib/dwc-archive.rb', __FILE__)}.
-      to_not raise_error
-  end
-
-  describe 'redis connection' do
-    it 'redis is running' do
-      expect do
-        socket = TCPSocket.open('localhost', 6379)
-        socket.close
-      end.to_not raise_error
-    end
-  end
-
-  it 'has version' do
-    expect(DarwinCore::VERSION =~ /\d+\.\d+\.\d/).to be_true
-  end
-
-  describe '.nil_field?' do
-    it 'is true for nil fields' do
-      [nil, '/N', ''].each do |i|
-        expect(DarwinCore.nil_field?(i)).to be_true
+  describe ".nil_field?" do
+    it "is true for nil fields" do
+      [nil, "/N", ""].each do |i|
+        expect(DarwinCore.nil_field?(i)).to be true
       end
     end
 
-    it 'is false for non-nil  fields' do
-      [0, '0', '123', 123, 'dsdfs434343/N'].each do |i|
-        expect(subject.nil_field?(i)).to be_false
+    it "is false for non-nil  fields" do
+      [0, "0", "123", 123, "dsdfs434343/N"].each do |i|
+        expect(subject.nil_field?(i)).to be false
       end
     end
   end
 
-  describe '.clean_all' do
+  describe ".clean_all" do
     let(:tmp_dir) { DarwinCore::DEFAULT_TMP_DIR }
 
-    it 'cleans dwca directories' do
+    it "cleans dwca directories" do
       Dir.chdir(tmp_dir)
-      FileUtils.mkdir('dwc_123') unless File.exists?('dwc_123')
-      dwca_dirs =  Dir.entries(tmp_dir).select { |d| d.match(/^dwc_[\d]+$/) }
+      FileUtils.mkdir("dwc_123") unless File.exist?("dwc_123")
+      dwca_dirs = Dir.entries(tmp_dir).select { |d| d.match(/^dwc_\d+$/) }
       expect(dwca_dirs.size).to be > 0
       subject.clean_all
-      dwca_dirs =  Dir.entries(tmp_dir).select { |d| d.match(/^dwc_[\d]+$/) }
+      dwca_dirs = Dir.entries(tmp_dir).select { |d| d.match(/^dwc_\d+$/) }
       expect(dwca_dirs.size).to be 0
     end
 
-    context 'no dwc files exist' do
-      it 'does nothing' do
+    context "no dwc files exist" do
+      it "does nothing" do
         subject.clean_all
         subject.clean_all
-        dwca_dirs =  Dir.entries(tmp_dir).select { |d| d.match(/^dwc_[\d]+$/) }
+        dwca_dirs = Dir.entries(tmp_dir).select { |d| d.match(/^dwc_\d+$/) }
         expect(dwca_dirs.size).to be 0
       end
     end
   end
 
-  describe '.logger' do
+  describe ".logger" do
     it { expect(subject.logger).to be_kind_of Logger }
   end
 
-  describe '.logger=' do
-    it 'sets logger' do
-      expect(subject.logger = 'fake logger').to eq 'fake logger'
-      expect(subject.logger).to eq 'fake logger'
+  describe ".logger=" do
+    it "sets logger" do
+      expect(subject.logger = "fake logger").to eq "fake logger"
+      expect(subject.logger).to eq "fake logger"
     end
   end
 
-  describe '.logger_reset' do
-    it 'resets logger' do
-      subject.logger = 'fake logger'
-      expect(subject.logger).to eq 'fake logger'
+  describe ".logger_reset" do
+    it "resets logger" do
+      subject.logger = "fake logger"
+      expect(subject.logger).to eq "fake logger"
       subject.logger_reset
       expect(subject.logger).to be_kind_of Logger
     end
   end
 
-  describe '.new' do
+  describe ".new" do
     subject(:dwca) { DarwinCore.new(file_path) }
-   
-    context 'tar.gz and zip files supplied' do 
-      files = %w(data.zip data.tar.gz minimal.tar.gz junk_dir_inside.zip)
+
+    context "tar.gz and zip files supplied" do
+      files = %w[data.zip data.tar.gz minimal.tar.gz junk_dir_inside.zip]
       files.each do |file|
         let(:file_path) { File.join(file_dir, file) }
 
-        it "creates archive from  %s" % file do
-          expect(dwca.archive.valid?).to be_true
+        it "creates archive from  #{file}" do
+          expect(dwca.archive.valid?).to be true
         end
-
       end
     end
 
-    context 'when file does not exist' do
-      let(:file_path) { File.join(file_dir, 'no_file.gz') }
+    context "when file does not exist" do
+      let(:file_path) { File.join(file_dir, "no_file.gz") }
 
-      it 'raises not found' do
-         expect { dwca }.to raise_error DarwinCore::FileNotFoundError
+      it "raises not found" do
+        expect { dwca }.to raise_error DarwinCore::FileNotFoundError
       end
     end
 
-    context 'archive cannot unpack' do
+    context "archive cannot unpack" do
+      let(:file_path) { File.join(file_dir, "broken.tar.gz") }
 
-      let(:file_path) { File.join(file_dir, 'broken.tar.gz') }
-
-      it 'raises unpacking error' do
+      it "raises unpacking error" do
         expect { dwca }.to raise_error DarwinCore::UnpackingError
       end
     end
 
-    context 'archive is broken' do
-
-      let(:file_path) { File.join(file_dir, 'invalid.tar.gz') }
+    context "archive is broken" do
+      let(:file_path) { File.join(file_dir, "invalid.tar.gz") }
 
-      it 'raises error of invalid archive' do
+      it "raises error of invalid archive" do
         expect { dwca }.to raise_error DarwinCore::InvalidArchiveError
       end
-
     end
-    
-    context 'archive is not in utf-8 encoding' do
 
-      let(:file_path) { File.join(file_dir, 'latin1.tar.gz') }
-      
-      it 'raises wrong encoding error' do
+    context "archive is not in utf-8 encoding" do
+      let(:file_path) { File.join(file_dir, "latin1.tar.gz") }
+
+      it "raises wrong encoding error" do
         expect { dwca }.to raise_error DarwinCore::EncodingError
       end
-
     end
-    
-    context 'filename with spaces and non-alphanumeric chars' do
 
-      let(:file_path) { File.join(file_dir, 'file with characters(3).gz') }
-      
-      it 'creates archive' do
-        expect(dwca.archive.valid?).to be_true
-      end
+    context "filename with spaces and non-alphanumeric chars" do
+      let(:file_path) { File.join(file_dir, "file with characters(3).tar.gz") }
 
+      it "creates archive" do
+        expect(dwca.archive.valid?).to be true
+      end
     end
   end
 
-  describe 'file_name' do
+  describe "file_name" do
     subject(:dwca) { DarwinCore.new(file_path) }
-    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+    let(:file_path) { File.join(file_dir, "data.tar.gz") }
 
-    it 'returns file name' do
-      expect(dwca.file_name).to eq 'data.tar.gz'
+    it "returns file name" do
+      expect(dwca.file_name).to eq "data.tar.gz"
     end
   end
 
-  describe 'path' do
+  describe "path" do
     subject(:dwca) { DarwinCore.new(file_path) }
-    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+    let(:file_path) { File.join(file_dir, "data.tar.gz") }
 
-    it 'returns path of the archive' do
-      expect(dwca.path).to match %r|spec.files.data\.tar\.gz|
+    it "returns path of the archive" do
+      expect(dwca.path).to match(/spec.files.data\.tar\.gz/)
     end
   end
 
-  describe '#archive' do
+  describe "#archive" do
     subject(:dwca) { DarwinCore.new(file_path) }
-    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+    let(:file_path) { File.join(file_dir, "data.tar.gz") }
 
-    it 'returns archive' do
+    it "returns archive" do
       expect(dwca.archive).to be_kind_of DarwinCore::Archive
     end
   end
 
-  describe '#core' do
+  describe "#core" do
     subject(:dwca) { DarwinCore.new(file_path) }
-    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+    let(:file_path) { File.join(file_dir, "data.tar.gz") }
 
-    it 'returns core' do
+    it "returns core" do
       expect(dwca.core).to be_kind_of DarwinCore::Core
     end
   end
 
-  describe '#metadata' do
+  describe "#metadata" do
     subject(:dwca) { DarwinCore.new(file_path) }
-    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+    let(:file_path) { File.join(file_dir, "data.tar.gz") }
 
-    it 'returns eml' do
+    it "returns eml" do
       expect(dwca.eml).to be_kind_of DarwinCore::Metadata
       expect(dwca.metadata).to be_kind_of DarwinCore::Metadata
     end
   end
-  
-  describe '#extensions' do
+
+  describe "#extensions" do
     subject(:dwca) { DarwinCore.new(file_path) }
-    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+    let(:file_path) { File.join(file_dir, "data.tar.gz") }
 
-    it 'returns extensions' do
+    it "returns extensions" do
       extensions = dwca.extensions
       expect(extensions).to be_kind_of Array
-      expect(extensions[0]).to be_kind_of DarwinCore::Extension 
+      expect(extensions[0]).to be_kind_of DarwinCore::Extension
     end
   end
 
-  describe '#checksum' do
+  describe "#checksum" do
     subject(:dwca) { DarwinCore.new(file_path) }
-    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+    let(:file_path) { File.join(file_dir, "data.tar.gz") }
 
-    it 'creates checksum hash' do
-      expect(dwca.checksum).to eq '7d94fc28ffaf434b66fbc790aa5ef00d834057bf'
+    it "creates checksum hash" do
+      expect(dwca.checksum).to eq "7d94fc28ffaf434b66fbc790aa5ef00d834057bf"
     end
   end
 
-  describe '#has_parent_id' do
+  describe "#parent_id?" do
     subject(:dwca) { DarwinCore.new(file_path) }
 
-    context 'has classification' do
-      let(:file_path) { File.join(file_dir, 'data.tar.gz') }
-      it 'returns true' do
-        expect(dwca.has_parent_id?).to be_true
+    context "has classification" do
+      let(:file_path) { File.join(file_dir, "data.tar.gz") }
+      it "returns true" do
+        expect(dwca.parent_id?).to be true
       end
     end
 
-    context 'does not have classification' do
-      let(:file_path) { File.join(file_dir, 'gnub.tar.gz') }
-      it 'returns false' do
-        expect(dwca.has_parent_id?).to be_false
+    context "does not have classification" do
+      let(:file_path) { File.join(file_dir, "gnub.tar.gz") }
+      it "returns false" do
+        expect(dwca.parent_id?).to be false
       end
     end
   end
 
-  describe '#classification_normalizer' do
+  describe "#classification_normalizer" do
     subject(:dwca) { DarwinCore.new(file_path) }
-    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
-   
-    context 'not initialized' do
-      it 'is nil' do
+    let(:file_path) { File.join(file_dir, "data.tar.gz") }
+
+    context "not initialized" do
+      it "is nil" do
         expect(dwca.classification_normalizer).to be_nil
       end
     end
 
-    context 'initialized' do
-      it 'is DarwinCore::ClassificationNormalizer' do
+    context "initialized" do
+      it "is DarwinCore::ClassificationNormalizer" do
         dwca.normalize_classification
         expect(dwca.classification_normalizer).
-          to be_kind_of DarwinCore::ClassificationNormalizer 
+          to be_kind_of DarwinCore::ClassificationNormalizer
       end
     end
   end
 
-  describe '#normalize_classification' do
+  describe "#normalize_classification" do
     subject(:dwca) { DarwinCore.new(file_path) }
-    let(:file_path) { File.join(file_dir, 'data.tar.gz') }
+    let(:file_path) { File.join(file_dir, "data.tar.gz") }
     let(:normalized) { dwca.normalize_classification }
+    let(:encodings) do
+      normalized.each_with_object(Set.new) do |taxon, e|
+        taxon[1].classification_path.each { |p| e << p.encoding }
+      end
+    end
 
-    it 'returns hash' do
+    it "returns hash" do
       expect(normalized).to be_kind_of Hash
     end
 
-    it 'uses utf-8 encoding for classification paths' do
-      encodings = []
-      normalized.each do |taxon_id, taxon|
-        taxon.classification_path.each { |p| encodings << p.encoding }
-      end
-      expect(encodings.uniq!.map { |e| e.to_s }).to eq ['UTF-8']
+    it "uses utf-8 encoding for classification paths" do
+      expect(encodings.map(&:to_s).to_a).to eq ["UTF-8"]
     end
 
-    it 'has elements of DarwinCore::TaxonNormalized type' do
-      expect(normalized['leptogastrinae:tid:2857']).
+    it "has elements of DarwinCore::TaxonNormalized type" do
+      expect(normalized["leptogastrinae:tid:2857"]).
         to be_kind_of DarwinCore::TaxonNormalized
     end
   end
-
 end
-