relaton 1.20.2 → 2.0.0.pre.alpha.1

data/spec/relaton/db_spec.rb

@@ -6,8 +6,10 @@ RSpec.describe Relaton::Db do
     if example.metadata[:vcr]
       # Force to download index file
       require "relaton/index"
-      allow_any_instance_of(Relaton::Index::Type).to receive(:actual?).and_return(false)
-      allow_any_instance_of(Relaton::Index::FileIO).to receive(:check_file).and_return(nil)
+      allow_any_instance_of(Relaton::Index::Type)
+        .to receive(:actual?).and_return(false)
+      allow_any_instance_of(Relaton::Index::FileIO)
+        .to receive(:check_file).and_return(nil)
     end
   end
 
@@ -16,11 +18,11 @@ RSpec.describe Relaton::Db do
   context "instance methods" do
     context "#search_edition_year" do
       it "create bibitem from YAML content" do
-        h = { "docid" => [{ "id" => "ISO 123", type: "ISO", "primary" => true }] }
-        expect(YAML).to receive(:safe_load).with(:content).and_return h
-        allow(YAML).to receive(:safe_load).and_call_original
-        item = subject.send :search_edition_year, "iso/item.yaml", :content, nil, nil
-        expect(item).to be_instance_of RelatonIsoBib::IsoBibliographicItem
+        h = { "docid" => [{ "id" => "ISO 123", type: "ISO",
+                            "primary" => true }] }
+        item = subject.send :search_edition_year, "iso/item.yaml", h.to_yaml,
+                            nil, nil
+        expect(item).to be_instance_of Relaton::Iso::ItemData
       end
     end
 
@@ -33,18 +35,24 @@ RSpec.describe Relaton::Db do
       it "warn if cached entry is not_found" do
         expect do
           expect(subject).to_not receive(:fetch_entry)
-          entry = subject.send :new_bib_entry, "ISO 123", nil, {}, :relaton_iso, db: db, id: "ISO(ISO 123)"
+          entry = subject.send :new_bib_entry, "ISO 123", nil, {},
+                               :relaton_iso, db: db, id: "ISO(ISO 123)"
           expect(entry).to be_nil
-        end.to output("[relaton] INFO: (ISO 123) not found in cache, if you wish " \
-                      "to ignore cache please use `no-cache` option.\n").to_stderr_from_any_process
+        end.to output(
+          "[relaton] INFO: (ISO 123) not found in cache, " \
+          "if you wish to ignore cache please use " \
+          "`no-cache` option.\n",
+        ).to_stderr_from_any_process
       end
 
       it "ignore cache" do
         expect(subject).to receive(:fetch_entry).with(
-          "ISO 123", nil, { no_cache: true }, :relaton_iso, db: db, id: "ISO(ISO 123)",
+          "ISO 123", nil, { no_cache: true }, :relaton_iso,
+          db: db, id: "ISO(ISO 123)"
         ).and_return :entry
         entry = subject.send(
-          :new_bib_entry, "ISO 123", nil, { no_cache: true }, :relaton_iso, db: db, id: "ISO(ISO 123)"
+          :new_bib_entry, "ISO 123", nil, { no_cache: true },
+          :relaton_iso, db: db, id: "ISO(ISO 123)"
         )
         expect(entry).to be :entry
       end
@@ -54,7 +62,8 @@ RSpec.describe Relaton::Db do
       it "retrun nil for BIPM documents" do
         code = double "code"
         expect(code).not_to receive(:split)
-        expect(subject.send(:combine_doc, code, nil, {}, :relaton_bipm)).to be_nil
+        expect(subject.send(:combine_doc, code, nil, {},
+                            :relaton_bipm)).to be_nil
       end
     end
 
@@ -62,19 +71,29 @@ RSpec.describe Relaton::Db do
       let(:db_cache) { double "db_cache" }
 
       before do
-        expect(subject).to receive(:net_retry).with("ISO 123", nil, {}, kind_of(RelatonIso::Processor), 1).and_return :bib
+        expect(subject).to receive(:net_retry).with(
+          "ISO 123", nil, {},
+          kind_of(Relaton::Iso::Processor), 1
+        ).and_return :bib
       end
 
       it "using cache" do
-        expect(db_cache).to receive(:[]).with("ISO(ISO 123)").and_return nil
-        expect(db_cache).to receive(:[]=).with("ISO(ISO 123)", :entry)
-        expect(subject).to receive(:check_entry).with(:bib, :relaton_iso, db: db_cache, id: "ISO(ISO 123)").and_return :entry
-        entry = subject.send :fetch_entry, "ISO 123", nil, {}, :relaton_iso, db: db_cache, id: "ISO(ISO 123)"
+        expect(db_cache).to receive(:[]).with("ISO(ISO 123)")
+          .and_return nil
+        expect(db_cache).to receive(:[]=)
+          .with("ISO(ISO 123)", :entry)
+        expect(subject).to receive(:check_entry).with(
+          :bib, :relaton_iso,
+          db: db_cache, id: "ISO(ISO 123)"
+        ).and_return :entry
+        entry = subject.send :fetch_entry, "ISO 123", nil, {}, :relaton_iso,
+                             db: db_cache, id: "ISO(ISO 123)"
         expect(entry).to be :entry
       end
 
       it "DbCache is undefined" do
-        expect(subject).to receive(:check_entry).with(:bib, :relaton_iso, **{}).and_return :entry
+        expect(subject).to receive(:check_entry).with(:bib, :relaton_iso,
+                                                      **{}).and_return :entry
         entry = subject.send :fetch_entry, "ISO 123", nil, {}, :relaton_iso
         expect(entry).to be :entry
       end
@@ -85,7 +104,8 @@ RSpec.describe Relaton::Db do
           :bib, :relaton_iso, db: db_cache, id: "ISO(ISO 123)", no_cache: true
         ).and_return :entry
         expect(db_cache).to receive(:[]).with("ISO(ISO 123)").and_return :entry
-        entry = subject.send :fetch_entry, "ISO 123", nil, {}, :relaton_iso, db: db_cache, id: "ISO(ISO 123)", no_cache: true
+        entry = subject.send :fetch_entry, "ISO 123", nil, {}, :relaton_iso,
+                             db: db_cache, id: "ISO(ISO 123)", no_cache: true
         expect(entry).to be :entry
       end
     end
@@ -144,7 +164,8 @@ RSpec.describe Relaton::Db do
       expect(result).to be false
     end
 
-    it "returns false when date is on or after :publication_date_before (exclusive)" do
+    it "returns false when date is on or after " \
+       ":publication_date_before (exclusive)" do
       result = subject.send(
         :pub_date_in_range?, xml_with_date,
         publication_date_before: "2019-06-15"
@@ -224,7 +245,7 @@ RSpec.describe Relaton::Db do
         :relaton_iso
       )
       expect(id).to eq(
-        "ISO(ISO 19115-1 after-2018-01-01 before-2020-12-31)"
+        "ISO(ISO 19115-1 after-2018-01-01 before-2020-12-31)",
       )
       expect(code).to eq "ISO 19115-1"
     end
@@ -243,7 +264,7 @@ RSpec.describe Relaton::Db do
         :relaton_iso
       )
       expect(id).to eq(
-        "ISO(ISO 19115-1:2014 (all parts) after-2014-01-01)"
+        "ISO(ISO 19115-1:2014 (all parts) after-2014-01-01)",
       )
     end
   end
@@ -269,9 +290,7 @@ RSpec.describe Relaton::Db do
         { publication_date_after: "2019-01-01",
           fetch_db: true }, :relaton_iso
       )
-      expect(item).to be_instance_of(
-        RelatonIsoBib::IsoBibliographicItem
-      )
+      expect(item).to be_instance_of(Relaton::Iso::ItemData)
     end
 
     it "does not return base cached entry when date does not match" do
@@ -288,8 +307,10 @@ RSpec.describe Relaton::Db do
     it "::init_bib_caches" do
       expect(FileUtils).to receive(:rm_rf).with(/\/\.relaton\/cache$/)
       expect(FileUtils).to receive(:rm_rf).with(/testcache\/cache$/)
-      expect(Relaton::Db).to receive(:new).with(/\/\.relaton\/cache$/, /testcache\/cache$/)
-      Relaton::Db.init_bib_caches(global_cache: true, local_cache: "testcache", flush_caches: true)
+      expect(Relaton::Db).to receive(:new).with(/\/\.relaton\/cache$/,
+                                                /testcache\/cache$/)
+      Relaton::Db.init_bib_caches(global_cache: true, local_cache: "testcache",
+                                  flush_caches: true)
     end
   end
 
@@ -328,7 +349,9 @@ RSpec.describe Relaton::Db do
       allow(File).to receive(:exist?).and_call_original
       expect do
         expect(db.mv("new_cache_dir")).to be_nil
-      end.to output(/\[relaton\] INFO: target directory exists/).to_stderr_from_any_process
+      end.to output(
+        /\[relaton\] INFO: target directory exists/,
+      ).to_stderr_from_any_process
     end
 
     it "clear" do
@@ -362,14 +385,14 @@ RSpec.describe Relaton::Db do
       item = db.fetch_db "ISO((ISO 124)"
       expect(item).to be_nil
       item = db.fetch_db "ISO(ISO 123)"
-      expect(item).to be_instance_of RelatonIsoBib::IsoBibliographicItem
+      expect(item).to be_instance_of Relaton::Iso::ItemData
     end
 
     it "all documents" do
       items = db.fetch_all
       expect(items.size).to be 2
-      expect(items[0]).to be_instance_of RelatonIec::IecBibliographicItem
-      expect(items[1]).to be_instance_of RelatonIsoBib::IsoBibliographicItem
+      expect(items[0]).to be_instance_of Relaton::Iec::ItemData
+      expect(items[1]).to be_instance_of Relaton::Iso::ItemData
     end
 
     context "search for text" do
@@ -381,6 +404,12 @@ RSpec.describe Relaton::Db do
         expect(items[0].id).to eq "ISO123"
       end
 
+      it "with spaces in text" do
+        items = db.fetch_all "first test"
+        expect(items.size).to eq 1
+        expect(items[0].id).to eq "ISO123"
+      end
+
       it "in attributes" do
         items = db.fetch_all "123"
         expect(items.size).to eq 2
@@ -415,40 +444,47 @@ RSpec.describe Relaton::Db do
 
   context "#fetch" do
     it "doesn't use cache" do
-      docid = RelatonBib::DocumentIdentifier.new id: "ISO 19115-1", type: "ISO"
-      item = RelatonIsoBib::IsoBibliographicItem.new docid: [docid]
-      expect(RelatonIso::IsoBibliography).to receive(:get).with("ISO 19115-1", nil, {}).and_return item
+      docid = Relaton::Bib::Docidentifier.new content: "ISO 19115-1",
+                                              type: "ISO"
+      item = Relaton::Iso::ItemData.new docid: [docid]
+      expect(Relaton::Iso::Bibliography).to receive(:get)
+        .with("ISO 19115-1", nil, {}).and_return item
       bib = subject.fetch("ISO 19115-1", nil, {})
-      expect(bib).to be_instance_of RelatonIsoBib::IsoBibliographicItem
+      expect(bib).to be_instance_of Relaton::Iso::ItemData
     end
 
     it "when no local db", vcr: "iso_19115_1" do
       db = Relaton::Db.new "testcache", nil
       bib = db.fetch("ISO 19115-1", nil, {})
-      expect(bib).to be_instance_of RelatonIsoBib::IsoBibliographicItem
+      expect(bib).to be_instance_of Relaton::Iso::ItemData
     end
 
     it "document with net retries" do
-      expect(subject.instance_variable_get(:@registry).processors[:relaton_ietf]).to receive(:get)
-        .and_raise(RelatonBib::RequestError).exactly(3).times
-      expect { subject.fetch "RFC 8341", nil, retries: 3 }.to raise_error RelatonBib::RequestError
+      registry = subject.instance_variable_get(:@registry)
+      expect(registry.processors[:relaton_ietf]).to receive(:get)
+        .and_raise(Relaton::RequestError).exactly(3).times
+      expect do
+        subject.fetch "RFC 8341", nil, retries: 3
+      end.to raise_error Relaton::RequestError
     end
 
     it "strip reference" do
-      expect(subject).to receive(:combine_doc).with("ISO 19115-1", nil, {}, :relaton_iso).and_return :doc
+      expect(subject).to receive(:combine_doc)
+        .with("ISO 19115-1", nil, {}, :relaton_iso)
+        .and_return :doc
       expect(subject.fetch(" ISO 19115-1 ", nil, {})).to be :doc
     end
 
     it "BIPM Meeting", vcr: "cipm_meeting_43" do
       bib = subject.fetch("CIPM Meeting 43")
-      expect(bib).to be_instance_of RelatonBipm::BipmBibliographicItem
+      expect(bib).to be_instance_of Relaton::Bipm::ItemData
     end
   end
 
   it "fetch std", vcr: "iso_19115_1_std" do
     db = Relaton::Db.new "testcache", nil
     bib = db.fetch_std("ISO 19115-1", nil, :relaton_iso, {})
-    expect(bib).to be_instance_of RelatonIsoBib::IsoBibliographicItem
+    expect(bib).to be_instance_of Relaton::Iso::ItemData
   end
 
   context "async fetch" do
@@ -491,16 +527,18 @@ RSpec.describe Relaton::Db do
     end
 
     it "handle HTTP request error" do
-      expect(subject).to receive(:fetch).and_raise RelatonBib::RequestError
+      expect(subject).to receive(:fetch).and_raise Relaton::RequestError
       subject.fetch_async("ISO REF") { |r| queue << r }
       result = Timeout.timeout(5) { queue.pop }
-      expect(result).to be_instance_of RelatonBib::RequestError
+      expect(result).to be_instance_of Relaton::RequestError
     end
 
     it "handle other errors" do
       expect(subject).to receive(:fetch).and_raise Errno::EACCES
       log_io = Relaton.logger_pool[:default].instance_variable_get(:@logdev)
-      expect(log_io).to receive(:write).with("[relaton] ERROR: `ISO REF` -- Permission denied\n")
+      expect(log_io).to receive(:write).with(
+        "[relaton] ERROR: `ISO REF` -- Permission denied\n",
+      )
       subject.fetch_async("ISO REF") { |r| queue << r }
       result = Timeout.timeout(5) { queue.pop }
       expect(result).to be_nil

data/spec/relaton/registry_spec.rb

@@ -10,122 +10,125 @@ RSpec.describe Relaton::Registry do
 
   it "finds ISO processor" do
     expect(Relaton::Registry.instance.find_processor("relaton_iso"))
-      .to be_instance_of RelatonIso::Processor
+      .to be_instance_of Relaton::Iso::Processor
   end
 
   it "returns supported processors" do
-    expect(Relaton::Registry.instance.supported_processors).to include :relaton_iso
+    processors = Relaton::Registry.instance.supported_processors
+    expect(processors).to include :relaton_iso
   end
 
   context "finds processor by type" do
     it "CN" do
-      expect(Relaton::Registry.instance.by_type("CN")).to be_instance_of RelatonGb::Processor
+      expect(Relaton::Registry.instance.by_type("CN")).to be_instance_of Relaton::Gb::Processor
     end
 
     it "IEC" do
-      expect(Relaton::Registry.instance.by_type("IEC")).to be_instance_of RelatonIec::Processor
+      expect(Relaton::Registry.instance.by_type("IEC")).to be_instance_of Relaton::Iec::Processor
     end
 
     it "IETF" do
-      expect(Relaton::Registry.instance.by_type("IETF")).to be_instance_of RelatonIetf::Processor
+      expect(Relaton::Registry.instance.by_type("IETF")).to be_instance_of Relaton::Ietf::Processor
     end
 
     it "ISO" do
-      expect(Relaton::Registry.instance.by_type("ISO")).to be_instance_of RelatonIso::Processor
+      expect(Relaton::Registry.instance.by_type("ISO")).to be_instance_of Relaton::Iso::Processor
     end
 
     it "ITU" do
-      expect(Relaton::Registry.instance.by_type("ITU")).to be_instance_of RelatonItu::Processor
+      expect(Relaton::Registry.instance.by_type("ITU")).to be_instance_of Relaton::Itu::Processor
     end
 
     it "NIST" do
-      expect(Relaton::Registry.instance.by_type("NIST")).to be_instance_of RelatonNist::Processor
+      expect(Relaton::Registry.instance.by_type("NIST")).to be_instance_of Relaton::Nist::Processor
     end
 
     it "OGC" do
-      expect(Relaton::Registry.instance.by_type("OGC")).to be_instance_of RelatonOgc::Processor
+      expect(Relaton::Registry.instance.by_type("OGC")).to be_instance_of Relaton::Ogc::Processor
     end
 
     it "CC" do
-      expect(Relaton::Registry.instance.by_type("CC")).to be_instance_of RelatonCalconnect::Processor
+      expect(Relaton::Registry.instance.by_type("CC")).to be_instance_of Relaton::Calconnect::Processor
     end
 
     it "OMG" do
-      expect(Relaton::Registry.instance.by_type("OMG")).to be_instance_of RelatonOmg::Processor
+      expect(Relaton::Registry.instance.by_type("OMG")).to be_instance_of Relaton::Omg::Processor
     end
 
     it "UN" do
-      expect(Relaton::Registry.instance.by_type("UN")).to be_instance_of RelatonUn::Processor
+      expect(Relaton::Registry.instance.by_type("UN")).to be_instance_of Relaton::Un::Processor
     end
 
     it "W3C" do
-      expect(Relaton::Registry.instance.by_type("W3C")).to be_instance_of RelatonW3c::Processor
+      expect(Relaton::Registry.instance.by_type("W3C")).to be_instance_of Relaton::W3c::Processor
     end
 
     it "IEEE" do
-      expect(Relaton::Registry.instance.by_type("IEEE")).to be_instance_of RelatonIeee::Processor
+      expect(Relaton::Registry.instance.by_type("IEEE")).to be_instance_of Relaton::Ieee::Processor
     end
 
     it "IHO" do
-      expect(Relaton::Registry.instance.by_type("IHO")).to be_instance_of RelatonIho::Processor
+      expect(Relaton::Registry.instance.by_type("IHO")).to be_instance_of Relaton::Iho::Processor
     end
 
     it "BIPM" do
-      expect(Relaton::Registry.instance.by_type("BIPM")).to be_instance_of RelatonBipm::Processor
-      expect(Relaton::Registry.instance.processor_by_ref("CCTF")).to be_instance_of RelatonBipm::Processor
+      expect(Relaton::Registry.instance.by_type("BIPM")).to be_instance_of Relaton::Bipm::Processor
+      expect(Relaton::Registry.instance.processor_by_ref("CCTF"))
+        .to be_instance_of Relaton::Bipm::Processor
     end
 
     it "ECMA" do
-      expect(Relaton::Registry.instance.by_type("ECMA")).to be_instance_of RelatonEcma::Processor
+      expect(Relaton::Registry.instance.by_type("ECMA")).to be_instance_of Relaton::Ecma::Processor
     end
 
     it "CIE" do
-      expect(Relaton::Registry.instance.by_type("CIE")).to be_instance_of RelatonCie::Processor
+      expect(Relaton::Registry.instance.by_type("CIE")).to be_instance_of Relaton::Cie::Processor
     end
 
     it "BSI" do
-      expect(Relaton::Registry.instance.by_type("BSI")).to be_instance_of RelatonBsi::Processor
+      expect(Relaton::Registry.instance.by_type("BSI")).to be_instance_of Relaton::Bsi::Processor
     end
 
     it "CEN" do
-      expect(Relaton::Registry.instance.by_type("CEN")).to be_instance_of RelatonCen::Processor
+      expect(Relaton::Registry.instance.by_type("CEN")).to be_instance_of Relaton::Cen::Processor
     end
 
     it "IANA" do
-      expect(Relaton::Registry.instance.by_type("IANA")).to be_instance_of RelatonIana::Processor
+      expect(Relaton::Registry.instance.by_type("IANA")).to be_instance_of Relaton::Iana::Processor
     end
 
     it "3GPP" do
-      expect(Relaton::Registry.instance.by_type("3GPP")).to be_instance_of Relaton3gpp::Processor
+      expect(Relaton::Registry.instance.by_type("3GPP")).to be_instance_of Relaton::ThreeGpp::Processor
     end
 
     it "OASIS" do
-      expect(Relaton::Registry.instance.by_type("OASIS")).to be_instance_of RelatonOasis::Processor
+      expect(Relaton::Registry.instance.by_type("OASIS")).to be_instance_of Relaton::Oasis::Processor
     end
 
     it "DOI" do
-      expect(Relaton::Registry.instance.by_type("DOI")).to be_instance_of RelatonDoi::Processor
-      expect(Relaton::Registry.instance.processor_by_ref("doi:10.1000/182")).to be_instance_of RelatonDoi::Processor
+      expect(Relaton::Registry.instance.by_type("DOI")).to be_instance_of Relaton::Doi::Processor
+      expect(Relaton::Registry.instance.processor_by_ref("doi:10.1000/182"))
+        .to be_instance_of Relaton::Doi::Processor
     end
 
     it "JIS" do
-      expect(Relaton::Registry.instance.by_type("JIS")).to be_instance_of RelatonJis::Processor
+      expect(Relaton::Registry.instance.by_type("JIS")).to be_instance_of Relaton::Jis::Processor
     end
 
     it "XSF" do
-      expect(Relaton::Registry.instance.by_type("XEP")).to be_instance_of RelatonXsf::Processor
+      expect(Relaton::Registry.instance.by_type("XEP")).to be_instance_of Relaton::Xsf::Processor
     end
 
     it "CCSDS" do
-      expect(Relaton::Registry.instance.by_type("CCSDS")).to be_instance_of RelatonCcsds::Processor
+      expect(Relaton::Registry.instance.by_type("CCSDS")).to be_instance_of Relaton::Ccsds::Processor
     end
 
     it "ETSI" do
-      expect(Relaton::Registry.instance.by_type("ETSI")).to be_instance_of RelatonEtsi::Processor
+      expect(Relaton::Registry.instance.by_type("ETSI")).to be_instance_of Relaton::Etsi::Processor
     end
 
     it "ISBN" do
-      expect(Relaton::Registry.instance.by_type("ISBN")).to be_instance_of RelatonIsbn::Processor
+      expect(Relaton::Registry.instance.by_type("ISBN")).to be_instance_of Relaton::Isbn::Processor
     end
 
     context "PLATEAU" do
@@ -137,21 +140,19 @@ RSpec.describe Relaton::Registry do
       end
 
       it "fetch data" do
-        expect(Relaton::Plateau::Fetcher).to receive(:fetch).with("plateau-handbooks", output: "dir", format: "xml")
+        require "relaton/plateau/data_fetcher"
+        expect(Relaton::Plateau::DataFetcher).to receive(:fetch)
+          .with("plateau-handbooks", output: "dir", format: "xml")
         processor.fetch_data "plateau-handbooks", output: "dir", format: "xml"
       end
 
       it "from_xml" do
-        expect(Relaton::Plateau::XMLParser).to receive(:from_xml).with(:xml).and_return :bibitem
+        require "relaton/plateau"
+        expect(Relaton::Plateau::Item).to receive(:from_xml)
+          .with(:xml).and_return :bibitem
         expect(processor.from_xml(:xml)).to eq :bibitem
       end
 
-      it "hash_to_bib" do
-        expect(Relaton::Plateau::HashConverter).to receive(:hash_to_bib).with(:hash).and_return bib: :bib
-        expect(Relaton::Plateau::BibItem).to receive(:new).with(bib: :bib).and_return :bibitem
-        expect(processor.hash_to_bib(:hash)).to eq :bibitem
-      end
-
       it "grammar_hash" do
         expect(processor.grammar_hash).to be_instance_of String
       end
@@ -167,10 +168,11 @@ RSpec.describe Relaton::Registry do
 
   it "find processot by dataset" do
     expect(Relaton::Registry.instance.find_processor_by_dataset("nist-tech-pubs"))
-      .to be_instance_of RelatonNist::Processor
+      .to be_instance_of Relaton::Nist::Processor
   end
 
   it "find processor by dataset" do
-    expect(Relaton::Registry.instance.find_processor_by_dataset "etsi-csv").to be_instance_of RelatonEtsi::Processor
+    expect(Relaton::Registry.instance.find_processor_by_dataset("etsi-csv"))
+      .to be_instance_of Relaton::Etsi::Processor
   end
 end

data/spec/relaton/util_spec.rb

@@ -1,2 +1,3 @@
 describe Relaton::Util do
+  it { expect(described_class).to be_a Module }
 end