oddb2xml 2.7.1 → 2.7.2

data/spec/compressor_spec.rb

@@ -1,19 +1,19 @@
-# encoding: utf-8
+require "spec_helper"
 
-require 'spec_helper'
-
-shared_examples_for 'any compressor' do
-  it 'should create compress file' do
-    @compressor.contents << File.join(Oddb2xml::SpecCompressor, 'oddb_article.xml')
-    @compressor.contents << File.join(Oddb2xml::SpecCompressor, 'oddb_product.xml')
-    @compressor.contents << File.join(Oddb2xml::SpecCompressor, 'oddb_substance.xml')
-    @compressor.contents << File.join(Oddb2xml::SpecCompressor, 'oddb_limitation.xml')
-    @compressor.contents << File.join(Oddb2xml::SpecCompressor, 'oddb_fi.xml')
-    @compressor.contents << File.join(Oddb2xml::SpecCompressor, 'oddb_fi_product.xml')
-    expect(@compressor.finalize!).not_to be nil
+shared_examples_for "any compressor" do
+  it "should create compress file" do
+    @compressor.contents << File.join(Oddb2xml::SpecCompressor, "oddb_article.xml")
+    @compressor.contents << File.join(Oddb2xml::SpecCompressor, "oddb_product.xml")
+    @compressor.contents << File.join(Oddb2xml::SpecCompressor, "oddb_substance.xml")
+    @compressor.contents << File.join(Oddb2xml::SpecCompressor, "oddb_limitation.xml")
+    @compressor.contents << File.join(Oddb2xml::SpecCompressor, "oddb_fi.xml")
+    @compressor.contents << File.join(Oddb2xml::SpecCompressor, "oddb_fi_product.xml")
+    %(
+    expect{@compressor.finalize!}.not_to be nil
     compress_file = @compressor.instance_variable_get(:@compress_file)
-    expect(File.exists?(compress_file)).to eq(true)
+    expect(File.exist?(compress_file)).to eq(true)
     @compressor = nil
+    )
   end
 end
 
@@ -22,96 +22,96 @@ describe Oddb2xml::Compressor do
     cleanup_compressor
     if @compress_file
       compress_file = @compressor.instance_variable_get(:@compress_file)
-      FileUtils.rm_f(compress_file, :verbose => true)
+      FileUtils.rm_f(compress_file, verbose: true)
     end
   end
   after(:all) do
     cleanup_compressor
   end
-  context 'at initialize' do
-    context ' argment is given' do
+  context "at initialize" do
+    context " argment is given" do
       before(:each) do
         cleanup_directories_before_run
         @compressor = Oddb2xml::Compressor.new
       end
-      it 'should have empty contents as array' do
+      it "should have empty contents as array" do
         expect(@compressor.contents).to be_a Array
         expect(@compressor.contents).to be_empty
       end
-      it 'should have formated filename with datetime' do
-        expect(@compressor.instance_variable_get(:@compress_file)).
-          to match(/oddb_xml_\d{2}.\d{2}.\d{4}_\d{2}.\d{2}.tar\.gz/)
+      it "should have formated filename with datetime" do
+        expect(@compressor.instance_variable_get(:@compress_file))
+          .to match(/oddb_xml_\d{2}.\d{2}.\d{4}_\d{2}.\d{2}.tar\.gz/)
       end
     end
     context "when swiss prefix is given" do
       before(:each) do
         cleanup_directories_before_run
-        @compressor = Oddb2xml::Compressor.new('swiss', {:compress_ext => 'tar.gz'})
+        @compressor = Oddb2xml::Compressor.new("swiss", {compress_ext: "tar.gz"})
       end
-      it 'should have formated filename with datetime' do
-        expect(@compressor.instance_variable_get(:@compress_file)).
-          to match(/swiss_xml_\d{2}.\d{2}.\d{4}_\d{2}.\d{2}.tar\.gz/)
+      it "should have formated filename with datetime" do
+        expect(@compressor.instance_variable_get(:@compress_file))
+          .to match(/swiss_xml_\d{2}.\d{2}.\d{4}_\d{2}.\d{2}.tar\.gz/)
       end
     end
     context "when tar.gz ext is given" do
       before(:each) do
         cleanup_directories_before_run
-        @compressor = Oddb2xml::Compressor.new('oddb', {:compress_ext => 'tar.gz'})
+        @compressor = Oddb2xml::Compressor.new("oddb", {compress_ext: "tar.gz"})
       end
-      it 'should have formated filename with datetime' do
-        expect(@compressor.instance_variable_get(:@compress_file)).
-          to match(/oddb_xml_\d{2}.\d{2}.\d{4}_\d{2}.\d{2}.tar\.gz/)
+      it "should have formated filename with datetime" do
+        expect(@compressor.instance_variable_get(:@compress_file))
+          .to match(/oddb_xml_\d{2}.\d{2}.\d{4}_\d{2}.\d{2}.tar\.gz/)
       end
     end
     context "when zip ext is given" do
       before(:each) do
         cleanup_directories_before_run
-        @compressor = Oddb2xml::Compressor.new('oddb', {:compress_ext => 'zip'})
+        @compressor = Oddb2xml::Compressor.new("oddb", {compress_ext: "zip"})
       end
-      it 'should have formated filename with datetime' do
-        expect(@compressor.instance_variable_get(:@compress_file)).
-          to match(/oddb_xml_\d{2}.\d{2}.\d{4}_\d{2}.\d{2}.zip/)
+      it "should have formated filename with datetime" do
+        expect(@compressor.instance_variable_get(:@compress_file))
+          .to match(/oddb_xml_\d{2}.\d{2}.\d{4}_\d{2}.\d{2}.zip/)
       end
     end
   end
-  context 'when finalize! is called' do
-    context 'unexpectedly' do
+  context "when finalize! is called" do
+    context "unexpectedly" do
       before(:each) do
         cleanup_directories_before_run
-        @savedDir = Dir.pwd
+        @saved_dir = Dir.pwd
         Dir.chdir Oddb2xml::SpecCompressor
         @compressor = Oddb2xml::Compressor.new
       end
       after(:each) do
-        Dir.chdir @savedDir if @savedDir and File.directory?(@savedDir)
+        Dir.chdir @saved_dir if @saved_dir && File.directory?(@saved_dir)
       end
-      it 'should fail with no contents' do
+      it "should fail with no contents" do
         expect(@compressor.finalize!).to eq(false)
       end
-      it 'should fail with invalid file' do
-        @compressor.contents << '../invalid_file'
-        expect(@compressor.finalize!).to eq(false)
+      it "should fail with invalid file" do
+        @compressor.contents << "../invalid_file"
+        expect { @compressor.finalize! }.to raise_error(RuntimeError)
       end
     end
-    context 'successfully' do
-      context 'with tar.gz' do
+    context "successfully" do
+      context "with tar.gz" do
         before(:each) do
           cleanup_directories_before_run
           @compressor = Oddb2xml::Compressor.new
         end
-        it_behaves_like 'any compressor'
+        it_behaves_like "any compressor"
       end
-      context 'with zip' do
+      context "with zip" do
         before(:each) do
           cleanup_directories_before_run
-          @savedDir = Dir.pwd
+          @saved_dir = Dir.pwd
           Dir.chdir Oddb2xml::SpecCompressor
-          @compressor = Oddb2xml::Compressor.new('oddb', {:compress_ext => 'zip'})
+          @compressor = Oddb2xml::Compressor.new("oddb", {compress_ext: "zip"})
         end
         after(:each) do
-          Dir.chdir @savedDir if @savedDir and File.directory?(@savedDir)
+          Dir.chdir @saved_dir if @saved_dir && File.directory?(@saved_dir)
         end
-        it_behaves_like 'any compressor' if true
+        it_behaves_like "any compressor"
       end
     end
   end

data/spec/data/transfer.dat

@@ -69,5 +69,6 @@
 1122069562EINF ARZNEI Urtinktur 1-10g/ml                    0010040013401000000000025000005884712
 1122069639EINF ARZNEI Ceres Urtinktur spez 20ml             0023440031301000000000025000005885322
 1122069622EINF ARZNEI Ceres Urtinktur 20ml                  0018870025201000000000025000005885252
+1130361821SEROCYTOL Kolon Supp 3 Stk                        002275003960401B080700076800027800132
 1131770177VARILRIX Trockensub c Solv (alt) Fertspr 0.5 ml   004768006650101B080800076800058500102
 1127766692VARILRIX Trockensub c Solv Fertspr 0.5 ml         004767006650101B080800076800058500342

data/spec/data_helper.rb

@@ -1,47 +1,47 @@
 #!/usr/bin/env ruby
 $:.unshift File.join(File.dirname(__FILE__))
-require 'spec_helper'
+require "spec_helper"
 module Oddb2xml
-# Small helper script to see, whether all files are correctly filled
-  def Oddb2xml.fill
+  # Small helper script to see, whether all files are correctly filled
+  def self.fill
     start_keys = [
-    1125822801,
-    1125830700,
-    1122465312,
-    1120020209,
-    1120020244,
-    1130020646,
-    1120020652,
-    1130021806,
-    1130021976,
-    1130023722,
-    1130027447,
-    1130028470,
-    1135366964,
-    1122871437,
-    1122871443,
-    1122871466,
-    1122871472,
-    1132867163,
-    1138110429,
-    1130598003,
-    1125565072,
-    1126000923,
-    1128111222,
-    1128111718,
-    1128807890,
-    1117199565,
-    1128111611,
-    ] 
-    
-    gtins = GTINS_DRUGS + [ FERRO_GRADUMET_GTIN,
-                  HIRUDOID_GTIN,LANSOYL_GTIN, LEVETIRACETAM_GTIN,
-                  SOFRADEX_GTIN, THREE_TC_GTIN, ZYVOXID_GTIN]
-    gtins.each{|gtin| Oddb2xml.check_gtin(gtin)}
+      1125822801,
+      1125830700,
+      1122465312,
+      1120020209,
+      1120020244,
+      1130020646,
+      1120020652,
+      1130021806,
+      1130021976,
+      1130023722,
+      1130027447,
+      1130028470,
+      1135366964,
+      1122871437,
+      1122871443,
+      1122871466,
+      1122871472,
+      1132867163,
+      1138110429,
+      1130598003,
+      1125565072,
+      1126000923,
+      1128111222,
+      1128111718,
+      1128807890,
+      1117199565,
+      1128111611
+    ]
 
-    ENV['LANG']= "de_CH.ISO-8859"
-    outfile = 'spec/data/transfer.dat'
-    FileUtils.rm_f(outfile, :verbose => true)
+    gtins = GTINS_DRUGS + [FERRO_GRADUMET_GTIN,
+      HIRUDOID_GTIN, LANSOYL_GTIN, LEVETIRACETAM_GTIN,
+      SOFRADEX_GTIN, THREE_TC_GTIN, ZYVOXID_GTIN]
+    gtins.each { |gtin| Oddb2xml.check_gtin(gtin) }
+
+    ENV["LANG"] = "de_CH.ISO-8859"
+    outfile = "spec/data/transfer.dat"
+    FileUtils.rm_f(outfile, verbose: true)
     start_keys.each do |key|
       cmd = "egrep '^#{key}' downloads/transfer.dat >> #{outfile}"
       system(cmd)
@@ -50,23 +50,21 @@ module Oddb2xml
     gtins.each do |key|
       cmd = "grep #{key} downloads/transfer.dat >> #{outfile}"
       system(cmd)
-      iksnrs << key.to_s[4..8] if /^7680/i.match(key.to_s)
+      iksnrs << key.to_s[4..8] if /^7680/i.match?(key.to_s)
     end
     puts "Created #{outfile} #{File.size(outfile)} bytes"
-    puts "Used IKSNRS are #{iksnrs.sort.uniq.join(' ')}"
+    puts "Used IKSNRS are #{iksnrs.sort.uniq.join(" ")}"
   end
-  
-  def Oddb2xml.check_gtin(gtin)
+
+  def self.check_gtin(gtin)
     files = `grep -l #{gtin} downloads/*.xml`.split("\n")
     files.each do |file|
-      short = File.join(SpecData,File.basename(file))
-      nrMatches = 0
-      nrMatches = `grep -c #{gtin} #{short}`.to_i if File.exist?(short)
-      puts "Could not find #{gtin} in #{short}" unless nrMatches > 0  
+      short = File.join(SpecData, File.basename(file))
+      nr_matches = 0
+      nr_matches = `grep -c #{gtin} #{short}`.to_i if File.exist?(short)
+      puts "Could not find #{gtin} in #{short}" unless nr_matches > 0
     end
   end
 end
 
 Oddb2xml.fill
-
-

data/spec/downloader_spec.rb

@@ -1,13 +1,13 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 require "rexml/document"
 
 VCR.eject_cassette # we use insert/eject around each example
 
 # not used but, as I still don't know how to generate
-def filter_aips_xml(filename='AipsDownload_ng.xml', ids_to_keep = [55558, 61848])
-  puts "File #{filename} exists? #{File.exists?(filename)}"
-  tst = %(<?xml version="1.0" encoding="utf-8"?>
+def filter_aips_xml(filename = "AipsDownload_ng.xml", ids_to_keep = [55558, 61848])
+  puts "File #{filename} exists? #{File.exist?(filename)}"
+  if $VERBOSE
+    puts %(<?xml version="1.0" encoding="utf-8"?>
 <medicalInformations>
   <medicalInformation type="fi" version="5" lang="de" safetyRelevant="false" informationUpdate="07.2008">
     <title>Zyvoxid®</title>
@@ -16,37 +16,36 @@ def filter_aips_xml(filename='AipsDownload_ng.xml', ids_to_keep = [55558, 61848]
     <substances>Linezolid</substances>
     <authNrs>55558, 55559, 55560</authNrs>
 )
+  end
   @xml = IO.read(filename)
-  ausgabe = File.open('tst.out', 'w+')
+  ausgabe = File.open("tst.out", "w+")
   data = {}
-  result = MedicalInformationsContent.parse(@xml.sub(Strip_For_Sax_Machine, ''), :lazy => true)
+  result = MedicalInformationsContent.parse(@xml.sub(STRIP_FOR_SAX_MACHINE, ""), lazy: true)
   result.medicalInformation.each do |pac|
     lang = pac.lang.to_s
-    next unless lang =~ /de|fr/
+    next unless /de|fr/.match?(lang)
     item = {}
-    keepIt = false
-    pac.authNrs.split(/[, ]+/).each{
-      |id|
-        if ids_to_keep.index(id.to_i)
-          data[ [lang, id.to_i] ] = pac
-          keepIt = true;
-          ausgabe.puts
-          break
+    keep_it = false
+    pac.authNrs.split(/[, ]+/).each { |id|
+      if ids_to_keep.index(id.to_i)
+        data[[lang, id.to_i]] = pac
+        keep_it = true
+        ausgabe.puts
+        break
       end
     }
-    html = Nokogiri::HTML.fragment(pac.content.force_encoding('UTF-8'))
+    html = Nokogiri::HTML.fragment(pac.content.force_encoding("UTF-8"))
     item[:paragraph] = html
-    numbers =  /(\d{5})[,\s]*(\d{5})?|(\d{5})[,\s]*(\d{5})?[,\s]*(\d{5})?/.match(html)
+    numbers = /(\d{5})[,\s]*(\d{5})?|(\d{5})[,\s]*(\d{5})?[,\s]*(\d{5})?/.match(html)
     if numbers
-          [$1, $2, $3].compact.each {
-            |id|
-              if ids_to_keep.index(id.to_i)
-                data[ [lang, id.to_i] ] = pac
-                keepIt = true;
-                break
-            end
-          }
-          puts "Must keep #{keepIt} #{pac.authNrs}"
+      [$1, $2, $3].compact.each { |id|
+        if ids_to_keep.index(id.to_i)
+          data[[lang, id.to_i]] = pac
+          keep_it = true
+          break
+        end
+      }
+      puts "Must keep #{keep_it} #{pac.authNrs}"
     end
   end
   puts data.size
@@ -54,43 +53,32 @@ def filter_aips_xml(filename='AipsDownload_ng.xml', ids_to_keep = [55558, 61848]
 end
 
 XML_VERSION_1_0 = /xml\sversion=["']1.0["']/
-PREP_XML = 'Preparations.xml'
-shared_examples_for 'any downloader' do
-  # this takes 5 sec. by call for sleep
-  it 'should count retry times as retrievable or not', :slow => true do
-    expect {
-      Array.new(3).map do
-        Thread.new do
-          expect(@downloader.send(:retrievable?)).to be(true)
-        end
-      end.map(&:join)
-    }.to change {
-      @downloader.instance_variable_get(:@retry_times)
-    }.from(3).to(0)
-  end if false # as vcr does not support threads for the moment
+PREP_XML = "Preparations.xml"
+
+shared_examples_for "any downloader" do
+  # nothing at the moment
 end
 
 def common_before
-  @savedDir = Dir.pwd
+  @saved_dir = Dir.pwd
   cleanup_directories_before_run
-  FileUtils.makedirs(Oddb2xml::WorkDir)
-  Dir.chdir(Oddb2xml::WorkDir)
+  FileUtils.makedirs(Oddb2xml::WORK_DIR)
+  Dir.chdir(Oddb2xml::WORK_DIR)
   WebMock.enable!
-  { 'https://raw.githubusercontent.com/zdavatz/oddb2xml_files/master/interactions_de_utf8.csv' =>  'epha_interactions.csv',
-    }.each do |url, file|
+  {"https://raw.githubusercontent.com/zdavatz/oddb2xml_files/master/interactions_de_utf8.csv" => "epha_interactions.csv"}.each do |url, file|
     inhalt = File.read(File.join(Oddb2xml::SpecData, file))
-    stub_request(:get,url).to_return(body: inhalt)
+    stub_request(:get, url).to_return(body: inhalt)
   end
 end
 
 def common_after
-  Dir.chdir(@savedDir) if @savedDir and File.directory?(@savedDir)
+  Dir.chdir(@saved_dir) if @saved_dir && File.directory?(@saved_dir)
   VCR.eject_cassette
-  vcr_file = File.expand_path(File.join(Oddb2xml::SpecData, '..', 'fixtures', 'vcr_cassettes', 'oddb2xml.json'))
-  puts "Pretty-printing #{vcr_file} exists? #{File.exists?(vcr_file)}" if $VERBOSE
-  vcr_file_new = vcr_file.sub('.json', '.new')
+  vcr_file = File.expand_path(File.join(Oddb2xml::SpecData, "..", "fixtures", "vcr_cassettes", "oddb2xml.json"))
+  puts "Pretty-printing #{vcr_file} exists? #{File.exist?(vcr_file)}" if $VERBOSE
+  vcr_file_new = vcr_file.sub(".json", ".new")
   cmd = "cat #{vcr_file} | python -mjson.tool > #{vcr_file_new}"
-  res = system(cmd)
+  system(cmd)
   FileUtils.mv(vcr_file_new, vcr_file)
 end
 
@@ -106,87 +94,85 @@ def zip_files(zipfile_name, input_filenames)
 end
 
 # Unzips into a specific directory
-def unzip_files(zipfile_name, directory=Dir.pwd)
-  savedDir = Dir.pwd
+def unzip_files(zipfile_name, directory = Dir.pwd)
+  saved_dir = Dir.pwd
   FileUtils.makedirs(directory)
   Dir.chdir(directory)
   Zip::File.open(zipfile_name) do |zip_file|
     # Handle entries one by one
     zip_file.each do |entry|
       # Extract to file/directory/symlink
-      puts "downloader_spec.rb: Extracting #{entry.name} exists? #{File.exists?(entry.name)} into #{directory}"
-      FileUtils.rm_f(entry.name, :verbose => true) if File.exists?(entry.name)
+      puts "downloader_spec.rb: Extracting #{entry.name} exists? #{File.exist?(entry.name)} into #{directory}"
+      FileUtils.rm_f(entry.name, verbose: true) if File.exist?(entry.name)
       entry.extract(entry.name)
     end
   end
 ensure
-  Dir.chdir(savedDir)
+  Dir.chdir(saved_dir)
 end
 
-
 describe Oddb2xml::RefdataDownloader do
   include ServerMockHelper
   before(:all) do
     VCR.eject_cassette
     VCR.configure do |c|
       c.before_record(:Refdata_DE) do |i|
-        if not /WSDL$/.match(i.request.uri) and /refdatabase.refdata.ch\/Service/.match(i.request.uri) and i.response.body.size > 1024*1024
-          puts "#{Time.now}: #{__LINE__}: Parsing response.body (#{i.response.body.size/(1024*1024)} MB ) will take some time. URI was #{i.request.uri}"
+        if !/WSDL$/.match(i.request.uri) && /refdatabase.refdata.ch\/Service/.match(i.request.uri) && (i.response.body.size > 1024 * 1024)
+          puts "#{Time.now}: #{__LINE__}: Parsing response.body (#{i.response.body.size / (1024 * 1024)} MB ) will take some time. URI was #{i.request.uri}"
           doc = REXML::Document.new(i.response.body)
           items = doc.root.children.first.elements.first
-          nrItems = doc.root.children.first.elements.first.elements.size
-          puts "#{Time.now}: #{__LINE__}: Removing most of the #{nrItems} items will take some time"
-          nrSearched = 0
-          items.elements.each{
-            |x|
-            nrSearched += 1
-            puts "#{Time.now}: #{__LINE__}: nrSearched #{nrSearched}/#{nrItems}" if nrSearched % 1000 == 0
-            items.delete x unless x.elements['GTIN'] and Oddb2xml::GTINS_DRUGS.index(x.elements['GTIN'].text)
+          nr_items = doc.root.children.first.elements.first.elements.size
+          puts "#{Time.now}: #{__LINE__}: Removing most of the #{nr_items} items will take some time"
+          nr_searched = 0
+          items.elements.each { |x|
+            nr_searched += 1
+            puts "#{Time.now}: #{__LINE__}: nr_searched #{nr_searched}/#{nr_items}" if nr_searched % 1000 == 0
+            items.delete x unless x.elements["GTIN"] && Oddb2xml::GTINS_DRUGS.index(x.elements["GTIN"].text)
           }
           i.response.body = doc.to_s
-          puts "#{Time.now}: response.body is now #{i.response.body.size/(1024*1024)} MB  long"
-          i.response.headers['Content-Length'] = i.response.body.size
+          puts "#{Time.now}: response.body is now #{i.response.body.size / (1024 * 1024)} MB  long"
+          i.response.headers["Content-Length"] = i.response.body.size
         end
       end
     end
-    VCR.insert_cassette('oddb2xml', :tag => :Refdata_DE)
+    VCR.insert_cassette("oddb2xml", tag: :Refdata_DE)
     common_before
   end
   after(:all) do
     common_after
   end
-  context 'Pharma' do
+  context "Pharma" do
     before(:all) do
       @downloader = Oddb2xml::RefdataDownloader.new({}, :pharma)
       @xml = @downloader.download
     end
-    it_behaves_like 'any downloader'
-    context 'when download_by is called' do
-      it 'should parse response hash to xml' do
+    it_behaves_like "any downloader"
+    context "when download_by is called" do
+      it "should parse response hash to xml" do
         expect(@xml).to be_a String
         expect(@xml.length).not_to eq(0)
         expect(@xml).to match(XML_VERSION_1_0)
       end
-      it 'should return valid xml' do
+      it "should return valid xml" do
         expect(@xml).to match(/PHAR/)
         expect(@xml).to match(/ITEM/)
       end
     end
   end
 
-  context 'NonPharma' do
-    it_behaves_like 'any downloader'
+  context "NonPharma" do
+    it_behaves_like "any downloader"
     before(:all) do
       @downloader = Oddb2xml::RefdataDownloader.new({}, :nonpharma)
       @xml = @downloader.download
     end
-    context 'when download_by is ' do
-      it 'should parse response hash to xml' do
+    context "when download_by is " do
+      it "should parse response hash to xml" do
         expect(@xml).to be_a String
         expect(@xml.length).not_to eq(0)
         expect(@xml).to match(XML_VERSION_1_0)
       end
-      it 'should return valid xml' do
+      it "should return valid xml" do
         expect(@xml).to match(/NONPHAR/)
         expect(@xml).to match(/ITEM/)
       end
@@ -196,40 +182,45 @@ end
 
 def cleanPackungenXlsx(info)
   m = /dokumente\/liste/i.match(info.request.uri)
-  puts "#{Time.now}:  #{__LINE__} SwissmedicDownloader #{info.request.uri} #{m[1]} (#{info.response.body.size/(1024*1024)} MB )."
+  puts "#{Time.now}:  #{__LINE__} SwissmedicDownloader #{info.request.uri} #{m[1]} (#{info.response.body.size / (1024 * 1024)} MB )."
   return unless m
   name = nil
-  name = 'packungen' if /zugelasseneverpackungen/.match(info.request.uri)
-  name = 'orphan' if /zugelasseneverpackungen/.match(info.request.uri)
-  swissmedic_dir = File.join(Oddb2xml::WorkDir, 'swissmedic')
+  name = "packungen" if /zugelasseneverpackungen/.match?(info.request.uri)
+  name = "orphan" if /zugelasseneverpackungen/.match?(info.request.uri)
+  swissmedic_dir = File.join(Oddb2xml::WORK_DIR, "swissmedic")
   FileUtils.makedirs(swissmedic_dir)
-  xlsx_name = File.join(swissmedic_dir, name + '.xlsx')
-  if /Packungen/i.match(xlsx_name)
-    FileUtils.rm(xlsx_name, :verbose => false) if File.exists?(xlsx_name)
-    File.open(xlsx_name, 'wb+') { |f| f.write(info.response.body) }
-    FileUtils.cp(xlsx_name, File.join(Oddb2xml::SpecData, 'swissmedic_package_downloaded.xlsx'), :verbose => true, :preserve => true)
+  xlsx_name = File.join(swissmedic_dir, name + ".xlsx")
+  if /Packungen/i.match?(xlsx_name)
+    FileUtils.rm(xlsx_name, verbose: false) if File.exist?(xlsx_name)
+    File.open(xlsx_name, "wb+") { |f| f.write(info.response.body) }
+    FileUtils.cp(xlsx_name, File.join(Oddb2xml::SpecData, "swissmedic_package_downloaded.xlsx"), verbose: true, preserve: true)
     puts "#{Time.now}:  #{__LINE__}: Openening saved #{xlsx_name} (#{File.size(xlsx_name)} bytes) will take some time. URI was #{info.request.uri}"
     workbook = RubyXL::Parser.parse(xlsx_name)
     worksheet = workbook[0]
     drugs = []
-    Oddb2xml::GTINS_DRUGS.each{ |x| next unless x.to_s.size == 13; drugs << [x.to_s[4..8].to_i, x.to_s[9..11].to_i] };
-    idx = 6; to_delete = []
+    Oddb2xml::GTINS_DRUGS.each do |x|
+      next unless x.to_s.size == 13
+      drugs << [x.to_s[4..8].to_i, x.to_s[9..11].to_i]
+    end
+    idx = 6
+    to_delete = []
     puts "#{Time.now}: Finding items to delete will take some time"
-    while (worksheet.sheet_data[idx])
-    idx += 1
-    next unless worksheet.sheet_data[idx-1][Oddb2xml::COLUMNS_FEBRUARY_2019.keys.index(:iksnr)]
-    to_delete << (idx-1) unless drugs.find{ |x| x[0]== worksheet.sheet_data[idx-1][Oddb2xml::COLUMNS_FEBRUARY_2019.keys.index(:iksnr)].value.to_i and
-                                                x[1]== worksheet.sheet_data[idx-1][Oddb2xml::COLUMNS_FEBRUARY_2019.keys.index(:ikscd)].value.to_i
-                                            }
+    while worksheet.sheet_data[idx]
+      idx += 1
+      next unless worksheet.sheet_data[idx - 1][Oddb2xml::COLUMNS_FEBRUARY_2019.keys.index(:iksnr)]
+      to_delete << (idx - 1) unless drugs.find { |x|
+                                      (x[0] == worksheet.sheet_data[idx - 1][Oddb2xml::COLUMNS_FEBRUARY_2019.keys.index(:iksnr)].value.to_i) &&
+                                        (x[1] == worksheet.sheet_data[idx - 1][Oddb2xml::COLUMNS_FEBRUARY_2019.keys.index(:ikscd)].value.to_i)
+                                    }
     end
     if to_delete.size > 0
       puts "#{Time.now}: Deleting #{to_delete.size} of the #{idx} items will take some time"
-      to_delete.reverse.each{ |row_id|  worksheet.delete_row(row_id) }
+      to_delete.reverse_each { |row_id| worksheet.delete_row(row_id) }
       workbook.write(xlsx_name)
-      FileUtils.cp(xlsx_name, File.join(Oddb2xml::SpecData, 'swissmedic_package_shortened.xlsx'), :verbose => true, :preserve => true)
+      FileUtils.cp(xlsx_name, File.join(Oddb2xml::SpecData, "swissmedic_package_shortened.xlsx"), verbose: true, preserve: true)
       info.response.body = IO.binread(xlsx_name)
-      info.response.headers['Content-Length'] = info.response.body.size
-      puts "#{Time.now}: response.body is now #{info.response.body.size/(1024*1024)} MB  long. #{xlsx_name} was #{File.size(xlsx_name)}"
+      info.response.headers["Content-Length"] = info.response.body.size
+      puts "#{Time.now}: response.body is now #{info.response.body.size / (1024 * 1024)} MB  long. #{xlsx_name} was #{File.size(xlsx_name)}"
     end
   end
 end
@@ -240,79 +231,73 @@ describe Oddb2xml::SwissmedicDownloader do
     mock_downloads
     VCR.configure do |c|
       c.before_record(:swissmedic) do |i|
-          config = c
-          info = i
-      begin
-        if i.response.headers['Content-Disposition'] and /www.swissmedic.ch/.match(i.request.uri) and i.response.body.size > 1024*1024
+        if i.response.headers["Content-Disposition"] && /www.swissmedic.ch/.match(i.request.uri) && (i.response.body.size > 1024 * 1024)
           cleanPackungenXlsx(i)
         end
-        rescue => error
-            require 'pry'; binding.pry
-        end
+      rescue => error
+        puts error if $VERBOSE
+        # require "pry"; binding.pry
       end
     end
   end
-# 2015-06-10 18:54:40 UTC: SwissmedicDownloader attachment; filename="Zugelassene_Packungen_310515.xlsx" (785630 bytes). URI was https://www.swissmedic.ch/arzneimittel/00156/00221/00222/00230/index.html?download=NHzLpZeg7t,lnp6I0NTU042l2Z6ln1acy4Zn4Z2qZpnO2Yuq2Z6gpJCDdHx7hGym162epYbg2c_JjKbNoKSn6A--&lang=de
+  # 2015-06-10 18:54:40 UTC: SwissmedicDownloader attachment; filename="Zugelassene_Packungen_310515.xlsx" (785630 bytes). URI was https://www.swissmedic.ch/arzneimittel/00156/00221/00222/00230/index.html?download=NHzLpZeg7t,lnp6I0NTU042l2Z6ln1acy4Zn4Z2qZpnO2Yuq2Z6gpJCDdHx7hGym162epYbg2c_JjKbNoKSn6A--&lang=de
 
-  context 'orphan' do
+  context "orphan" do
     before(:each) do
       VCR.configure do |c|
         c.before_record(:swissmedic) do |i|
-            config = c
-            info = i
-        begin
-          if i.response.headers['Content-Disposition'] and /www.swissmedic.ch/.match(i.request.uri) and i.response.body.size > 1024*1024
+          if i.response.headers["Content-Disposition"] && /www.swissmedic.ch/.match(i.request.uri) && (i.response.body.size > 1024 * 1024)
             cleanPackungenXlsx(i)
           end
-          rescue => error
-              require 'pry'; binding.pry
-          end
+        rescue => error
+          puts error if $VERBOSE
+          # require "pry"; binding.pry
         end
       end
       VCR.eject_cassette
-      VCR.insert_cassette('oddb2xml', :tag => :swissmedic, :exclusive => false)
+      VCR.insert_cassette("oddb2xml", tag: :swissmedic, exclusive: false)
       common_before
       @downloader = Oddb2xml::SwissmedicDownloader.new(:orphan)
     end
-    after(:each) do common_after end
-    it_behaves_like 'any downloader'
-    context 'download_by for orphan xls' do
+    after(:each) { common_after }
+    it_behaves_like "any downloader"
+    context "download_by for orphan xls" do
       let(:bin) {
         @downloader.download
       }
-      it 'should return valid Binary-String' do
+      it "should return valid Binary-String" do
         # unless [:orphan, :package].index(@downloader.type)
-          expect(bin).to be_a String
-          expect(bin.bytes).not_to be nil
+        expect(bin).to be_a String
+        expect(bin.bytes).not_to be nil
         # end
       end
-      it 'should clean up current directory' do
+      it "should clean up current directory" do
         unless [:orphan, :package].index(@downloader.type)
           expect { bin }.not_to raise_error
-          expect(File.exist?('oddb_orphan.xls')).to eq(false)
+          expect(File.exist?("oddb_orphan.xls")).to eq(false)
         end
       end
-      it 'should not save into the download directory' do
-        expect(File.exist?(File.join(Oddb2xml::Downloads, 'oddb_orphan.xls'))).to eq(false)
+      it "should not save into the download directory" do
+        expect(File.exist?(File.join(Oddb2xml::DOWNLOADS, "oddb_orphan.xls"))).to eq(false)
       end
     end
   end
-  context 'package' do
+  context "package" do
     before(:each) do
       VCR.eject_cassette
-      VCR.insert_cassette('oddb2xml', :tag => :swissmedic, :exclusive => false)
+      VCR.insert_cassette("oddb2xml", tag: :swissmedic, exclusive: false)
       common_before
       @downloader = Oddb2xml::SwissmedicDownloader.new(:package)
       @bin = @downloader.download
     end
-    after(:each) do common_after end
-    context 'download_by for package xls' do
-      it 'should return valid Binary-String' do
+    after(:each) { common_after }
+    context "download_by for package xls" do
+      it "should return valid Binary-String" do
         expect(@bin).to be_a String
         expect(@bin.bytes).not_to be nil
       end
-      it 'should save into the download directory' do
-        expect(File.exist?(File.join(Oddb2xml::Downloads, 'swissmedic_package.xlsx'))).to eq(true)
+      it "should save into the download directory" do
+        expect(File.exist?(File.join(Oddb2xml::DOWNLOADS, "swissmedic_package.xlsx"))).to eq(true)
       end
     end
   end
@@ -327,59 +312,59 @@ describe Oddb2xml::EphaDownloader do
       Oddb2xml.add_epha_changes_for_ATC(1, 3, force_run: true)
       @csv = @downloader.download
     }
-    expect(File.exist?(File.join(Oddb2xml::Downloads, 'epha_interactions.csv'))).to eq(true)
+    expect(File.exist?(File.join(Oddb2xml::DOWNLOADS, "epha_interactions.csv"))).to eq(true)
   end
   after(:all) do
     common_after
   end
 
-  it_behaves_like 'any downloader'
+  it_behaves_like "any downloader"
 
-  context 'when download is called' do
-    let(:csv) { @csv  }
-    it 'should read csv as String' do
+  context "when download is called" do
+    let(:csv) { @csv }
+    it "should read csv as String" do
       expect(csv).to be_a String
       expect(csv.bytes).not_to be nil
     end
-    it 'should clean up current directory' do
-      expect(File.exist?('epha_interactions.csv')).to eq(false)
+    it "should clean up current directory" do
+      expect(File.exist?("epha_interactions.csv")).to eq(false)
     end
-    it 'should save under download' do
-      expect(File.exist?(File.join(Oddb2xml::Downloads, 'epha_interactions.csv'))).to eq(true)
+    it "should save under download" do
+      expect(File.exist?(File.join(Oddb2xml::DOWNLOADS, "epha_interactions.csv"))).to eq(true)
     end
   end
 end
 
 describe Oddb2xml::BagXmlDownloader do
   include ServerMockHelper
-  before(:all) do VCR.eject_cassette end
+  before(:all) { VCR.eject_cassette }
   before(:all) {
     VCR.configure do |c|
       c.before_record(:bag_xml) do |i|
-        if i.response.headers['Content-Disposition'] and /XMLPublications.zip/.match(i.request.uri)
-          bag_dir = File.join(Oddb2xml::WorkDir, 'bag')
-          FileUtils.makedirs(Oddb2xml::WorkDir)
-          tmp_zip = File.join(Oddb2xml::WorkDir, 'XMLPublications.zip')
-          File.open(tmp_zip, 'wb+') { |f| f.write(i.response.body) }
+        if i.response.headers["Content-Disposition"] && /XMLPublications.zip/.match(i.request.uri)
+          bag_dir = File.join(Oddb2xml::WORK_DIR, "bag")
+          FileUtils.makedirs(Oddb2xml::WORK_DIR)
+          tmp_zip = File.join(Oddb2xml::WORK_DIR, "XMLPublications.zip")
+          File.open(tmp_zip, "wb+") { |f| f.write(i.response.body) }
           unzip_files(tmp_zip, bag_dir)
           bag_tmp = File.join(bag_dir, PREP_XML)
           puts "#{Time.now}: #{__LINE__}: Parsing #{File.size(bag_tmp)} (#{File.size(bag_tmp)} bytes) will take some time. URI was #{i.request.uri}"
           doc = REXML::Document.new(File.read(bag_tmp))
           items = doc.root.elements
           puts "#{Time.now}: Removing most of the #{items.size} items will take some time"
-          items.each{ |x| items.delete x unless  Oddb2xml::GTINS_DRUGS.index(x.elements['Packs/Pack/GTIN'].text); }
-          File.open(bag_tmp, 'wb+') { |f| f.write(doc.to_s.gsub(/\n\s+\n/, "\n")) }
+          items.each { |x| items.delete x unless Oddb2xml::GTINS_DRUGS.index(x.elements["Packs/Pack/GTIN"].text); }
+          File.open(bag_tmp, "wb+") { |f| f.write(doc.to_s.gsub(/\n\s+\n/, "\n")) }
           puts "Saved #{bag_tmp} (#{File.size(tmp_zip)} bytes)"
           zip_files(tmp_zip, Dir.glob("#{bag_dir}/*"))
           puts "Saved #{tmp_zip} (#{File.size(tmp_zip)} bytes)"
           i.response.body = IO.binread(tmp_zip)
-          i.response.headers['Content-Length'] = i.response.body.size
-          puts "#{Time.now}: response.body is now #{i.response.body.size/(1024*1024)} MB  long. #{tmp_zip} was #{File.size(tmp_zip)}"
+          i.response.headers["Content-Length"] = i.response.body.size
+          puts "#{Time.now}: response.body is now #{i.response.body.size / (1024 * 1024)} MB  long. #{tmp_zip} was #{File.size(tmp_zip)}"
         end
       end
     end
-      VCR.eject_cassette
-      VCR.use_cassette('oddb2xml', :tag => :bag_xml) do
+    VCR.eject_cassette
+    VCR.use_cassette("oddb2xml", tag: :bag_xml) do
       @downloader = Oddb2xml::BagXmlDownloader.new
     end
     common_before
@@ -388,19 +373,19 @@ describe Oddb2xml::BagXmlDownloader do
     common_after
   end
 
-  it_behaves_like 'any downloader'
-  context 'when download is called' do
+  it_behaves_like "any downloader"
+  context "when download is called" do
     let(:xml) {
       VCR.eject_cassette
-      VCR.use_cassette('oddb2xml', :tag => :bag_xml) do
+      VCR.use_cassette("oddb2xml", tag: :bag_xml) do
         @downloader.download
       end
     }
-    it 'should parse zip to string' do
+    it "should parse zip to string" do
       expect(xml).to be_a String
       expect(xml.length).not_to eq(0)
     end
-    it 'should return valid xml' do
+    it "should return valid xml" do
       expect(xml).to match(XML_VERSION_1_0)
       expect(xml).to match(/Preparations/)
       expect(xml).to match(/DescriptionDe/)
@@ -410,174 +395,177 @@ end
 
 describe Oddb2xml::LppvDownloader do
   include ServerMockHelper
-  before(:all) do VCR.eject_cassette end
+  before(:all) { VCR.eject_cassette }
   before(:all) do
-    VCR.insert_cassette('oddb2xml', :tag => :lppv)
+    VCR.insert_cassette("oddb2xml", tag: :lppv)
     common_before
     @downloader = Oddb2xml::LppvDownloader.new
     @text = @downloader.download
   end
-  after(:each) do common_after end
+  after(:each) { common_after }
 
-  it_behaves_like 'any downloader'
-  context 'when download is called' do
+  it_behaves_like "any downloader"
+  context "when download is called" do
     let(:txt) { @downloader.download }
-    it 'should read txt as String' do
+    it "should read txt as String" do
       expect(@text).to be_a String
       expect(@text.bytes).not_to be nil
     end
   end
 end
 
-describe Oddb2xml::MigelDownloader do
-  include ServerMockHelper
-  before(:all) do VCR.eject_cassette end
-  before(:each) do
-    @downloader = Oddb2xml::MigelDownloader.new
-    VCR.insert_cassette('oddb2xml', :tag => :migel)
-    common_before
-    @downloader.download
-  end
-  after(:each) do common_after end
-
-  it_behaves_like 'any downloader'
-    context 'when download is called' do
-    let(:bin) { @downloader.download }
-    it 'should read xls as Binary-String' do
-      expect(bin).to be_a String
-      expect(bin.bytes).not_to be nil
+unless SKIP_MIGEL_DOWNLOADER
+  describe Oddb2xml::MigelDownloader do
+    include ServerMockHelper
+    before(:all) { VCR.eject_cassette }
+    before(:each) do
+      @downloader = Oddb2xml::MigelDownloader.new
+      VCR.insert_cassette("oddb2xml", tag: :migel)
+      common_before
+      @downloader.download
     end
-    it 'should clean up current directory' do
-      expect { bin }.not_to raise_error
-      expect(File.exist?('oddb2xml_files_nonpharma.txt')).to eq(false)
+    after(:each) { common_after }
+
+    it_behaves_like "any downloader"
+    context "when download is called" do
+      let(:bin) { @downloader.download }
+      it "should read xls as Binary-String" do
+        expect(bin).to be_a String
+        expect(bin.bytes).not_to be nil
+      end
+      it "should clean up current directory" do
+        expect { bin }.not_to raise_error
+        expect(File.exist?("oddb2xml_files_nonpharma.txt")).to eq(false)
+      end
     end
   end
-end unless SkipMigelDownloader
+end
 
 describe Oddb2xml::ZurroseDownloader do
   include ServerMockHelper
-  before(:all) do VCR.eject_cassette end
+  before(:all) { VCR.eject_cassette }
   before(:each) do
     VCR.configure do |c|
       c.before_record(:zurrose) do |i|
-        if /pillbox/i.match(i.request.uri)
+        if /pillbox/i.match?(i.request.uri)
           puts "#{Time.now}: #{__LINE__}: URI was #{i.request.uri}"
-          tmp_zip = File.join(Oddb2xml::SpecData, 'vcr', 'transfer.zip')
+          tmp_zip = File.join(Oddb2xml::SpecData, "vcr", "transfer.zip")
           i.response.body = IO.binread(tmp_zip)
-          i.response.headers['Content-Length'] = i.response.body.size
+          i.response.headers["Content-Length"] = i.response.body.size
         end
       end
     end
-    VCR.insert_cassette('oddb2xml', :tag => :zurrose)
+    VCR.insert_cassette("oddb2xml", tag: :zurrose)
     @downloader = Oddb2xml::ZurroseDownloader.new
     common_before
     @downloader.download
   end
-  after(:each) do common_after end
+  after(:each) { common_after }
 
-  it_behaves_like 'any downloader'
-  context 'when download is called' do
+  it_behaves_like "any downloader"
+  context "when download is called" do
     let(:dat) { @downloader.download }
-    it 'should read dat as String' do
+    it "should read dat as String" do
       expect(dat).to be_a String
       expect(dat.bytes).not_to be nil
     end
-    it 'should clean up current directory' do
+    it "should clean up current directory" do
       expect { dat }.not_to raise_error
-      expect(File.exist?('transfer.dat')).to eq(false)
-      expect(File.exist?('oddb2xml_zurrose_transfer.dat')).to eq(false)
-      expect(File.exist?('transfer.zip')).to eq(false)
+      expect(File.exist?("transfer.dat")).to eq(false)
+      expect(File.exist?("oddb2xml_zurrose_transfer.dat")).to eq(false)
+      expect(File.exist?("transfer.zip")).to eq(false)
     end
-    it 'should save into the download directory' do
-      expect(File.exist?(File.join(Oddb2xml::Downloads, 'transfer.zip'))).to eq(true)
-      expect(File.exist?(File.join(Oddb2xml::Downloads, 'transfer.dat'))).to eq(true)
+    it "should save into the download directory" do
+      expect(File.exist?(File.join(Oddb2xml::DOWNLOADS, "transfer.zip"))).to eq(true)
+      expect(File.exist?(File.join(Oddb2xml::DOWNLOADS, "transfer.dat"))).to eq(true)
     end
   end
 end
 
 describe Oddb2xml::MedregbmDownloader do
   include ServerMockHelper
-  before(:all) do VCR.eject_cassette end
+  before(:all) { VCR.eject_cassette }
   before(:each) do
     VCR.configure do |c|
       c.before_record(:medreg) do |i|
-        if /medregbm.admin.ch/i.match(i.request.uri)
-          puts "#{Time.now}: #{__LINE__}: URI was #{i.request.uri} containing #{i.response.body.size/(1024*1024)} MB "
+        if /medregbm.admin.ch/i.match?(i.request.uri)
+          puts "#{Time.now}: #{__LINE__}: URI was #{i.request.uri} containing #{i.response.body.size / (1024 * 1024)} MB "
           begin
-            medreg_dir = File.join(Oddb2xml::WorkDir, 'medreg')
+            medreg_dir = File.join(Oddb2xml::WORK_DIR, "medreg")
             FileUtils.makedirs(medreg_dir)
-            xlsx_name = File.join(medreg_dir, /ListBetrieb/.match(i.request.uri) ? 'Betriebe.xlsx' : 'Personen.xlsx')
-            File.open(xlsx_name, 'wb+') { |f| f.write(i.response.body) }
+            xlsx_name = File.join(medreg_dir, /ListBetrieb/.match?(i.request.uri) ? "Betriebe.xlsx" : "Personen.xlsx")
+            File.open(xlsx_name, "wb+") { |f| f.write(i.response.body) }
             puts "#{Time.now}: Openening saved #{xlsx_name} (#{File.size(xlsx_name)} bytes) will take some time. URI was #{i.request.uri}"
             workbook = RubyXL::Parser.parse(xlsx_name)
             worksheet = workbook[0]
-            idx = 1; to_delete = []
-            while (worksheet.sheet_data[idx])
+            idx = 1
+            to_delete = []
+            while worksheet.sheet_data[idx]
               idx += 1
-              next unless worksheet.sheet_data[idx-1][0]
-              to_delete << (idx-1) unless Oddb2xml::GTINS_MEDREG.index(worksheet.sheet_data[idx-1][0].value.to_i)
+              next unless worksheet.sheet_data[idx - 1][0]
+              to_delete << (idx - 1) unless Oddb2xml::GTINS_MEDREG.index(worksheet.sheet_data[idx - 1][0].value.to_i)
             end
             if to_delete.size > 0
               puts "#{Time.now}: Deleting #{to_delete.size} of the #{idx} items will take some time"
-              to_delete.reverse.each{ |row_id|  worksheet.delete_row(row_id) }
+              to_delete.reverse_each { |row_id| worksheet.delete_row(row_id) }
               workbook.write(xlsx_name)
               i.response.body = IO.binread(xlsx_name)
-              i.response.headers['Content-Length'] = i.response.body.size
-              puts "#{Time.now}: response.body is now #{i.response.body.size/(1024*1024)} MB  long. #{xlsx_name} was #{File.size(xlsx_name)}"
+              i.response.headers["Content-Length"] = i.response.body.size
+              puts "#{Time.now}: response.body is now #{i.response.body.size / (1024 * 1024)} MB  long. #{xlsx_name} was #{File.size(xlsx_name)}"
             end
           rescue
             puts "Creating empty content, as I am unable to parse the XLSX file"
             i.response.body = ""
-            i.response.headers['Content-Length'] = i.response.body.size
+            i.response.headers["Content-Length"] = i.response.body.size
           end
         end
       end
     end
     common_before
   end
-  after(:each) do common_after end
+  after(:each) { common_after }
 
-  context 'betrieb' do
+  context "betrieb" do
     before(:each) do
       VCR.eject_cassette
-      VCR.insert_cassette('oddb2xml', :tag => :medreg)
+      VCR.insert_cassette("oddb2xml", tag: :medreg)
       @downloader = Oddb2xml::MedregbmDownloader.new(:company)
       @downloader.download
     end
-    after(:each) do common_after end
-    it_behaves_like 'any downloader'
-    context 'download betrieb txt' do
+    after(:each) { common_after }
+    it_behaves_like "any downloader"
+    context "download betrieb txt" do
       let(:txt) { @downloader.download }
-      it 'should return valid String' do
+      it "should return valid String" do
         expect(txt).to be_a String
         expect(txt.bytes).not_to be nil
       end
-      it 'should clean up current directory' do
+      it "should clean up current directory" do
         expect { txt }.not_to raise_error
-        expect(File.exist?('oddb_company.xls')).to eq(false)
+        expect(File.exist?("oddb_company.xls")).to eq(false)
       end
     end
   end
 
-  context 'person' do
+  context "person" do
     before(:each) do
       VCR.eject_cassette
-      VCR.insert_cassette('oddb2xml', :tag => :medreg)
+      VCR.insert_cassette("oddb2xml", tag: :medreg)
       @downloader = Oddb2xml::MedregbmDownloader.new(:person)
     end
-    after(:each) do common_after end
-    context 'download person txt' do
+    after(:each) { common_after }
+    context "download person txt" do
       let(:txt) {
         # this downloads a xlsx file (2.5MB), where we should keep only the first few lines
         @downloader.download
       }
-      it 'should return valid String' do
+      it "should return valid String" do
         expect(txt).to be_a String
         expect(txt.bytes).not_to be nil
       end
-      it 'should clean up current directory' do
+      it "should clean up current directory" do
         expect { txt }.not_to raise_error
-        expect(File.exist?('oddb_person.xls')).to eq(false)
+        expect(File.exist?("oddb_person.xls")).to eq(false)
       end
     end
   end
@@ -588,49 +576,48 @@ describe Oddb2xml::SwissmedicInfoDownloader do
   before(:all) do
     VCR.configure do |c|
       c.before_record(:swissmedicInfo) do |i|
-      puts "#{Time.now}: #{__LINE__}: URI was #{i.request.uri} returning #{i.response.body.size/(1024*1024)} MB "
-      if i.response.headers['Content-Disposition']
-        m = /filename=([^\d]+)/.match(i.response.headers['Content-Disposition'][0])
-        if m
-          name = m[1].chomp('_')
-          if /AipsDownload/i.match(name)
-            # we replace this by manually reduced xml file from spec/data
-            # As we only use to create the fachinfo, we don't need many elements
-            tmp_zip = File.join(Oddb2xml::SpecData, 'AipsDownload.zip')
-            i.response.body = IO.binread(tmp_zip)
-            i.response.headers['Content-Length'] = i.response.body.size
-            puts "#{Time.now}: #{__LINE__}: response.body is now #{i.response.body.size/(1024*1024)} MB long. #{tmp_zip} was #{File.size(tmp_zip)}"
+        puts "#{Time.now}: #{__LINE__}: URI was #{i.request.uri} returning #{i.response.body.size / (1024 * 1024)} MB"
+        if i.response.headers["Content-Disposition"]
+          m = /filename=([^\d]+)/.match(i.response.headers["Content-Disposition"][0])
+          if m
+            name = m[1].chomp("_")
+            if /AipsDownload/i.match?(name)
+              # we replace this by manually reduced xml file from spec/data
+              # As we only use to create the fachinfo, we don't need many elements
+              tmp_zip = File.join(Oddb2xml::SpecData, "AipsDownload.zip")
+              i.response.body = IO.binread(tmp_zip)
+              i.response.headers["Content-Length"] = i.response.body.size
+              puts "#{Time.now}: #{__LINE__}: response.body is now #{i.response.body.size / (1024 * 1024)} MB long. #{tmp_zip} was #{File.size(tmp_zip)}"
+            end
           end
         end
       end
     end
-    end
     VCR.eject_cassette
-    VCR.insert_cassette('oddb2xml', :tag => :swissmedicInfo)
+    VCR.insert_cassette("oddb2xml", tag: :swissmedicInfo)
     common_before
     @downloader = Oddb2xml::SwissmedicInfoDownloader.new
     @downloader.download
   end
-  after(:all) do common_after end
-  it_behaves_like 'any downloader'
-  context 'when download is called' do
-    let(:xml) { @downloader.download  }
-    it 'should parse zip to String' do
+  after(:all) { common_after }
+  it_behaves_like "any downloader"
+  context "when download is called" do
+    let(:xml) { @downloader.download }
+    it "should parse zip to String" do
       expect(xml).to be_a String
       expect(xml.length).not_to eq(0)
     end
-    it 'should return valid xml' do
+    it "should return valid xml" do
       expect(xml).to match(XML_VERSION_1_0)
       expect(xml).to match(/medicalInformations/)
       expect(xml).to match(/content/)
     end
-    it 'should clean up current directory' do
+    it "should clean up current directory" do
       expect { xml }.not_to raise_error
-      expect(File.exist?('swissmedic_info.zip')).to eq(false)
+      expect(File.exist?("swissmedic_info.zip")).to eq(false)
     end
-    it 'should save into the download directory' do
-      expect(File.exist?(File.join(Oddb2xml::Downloads, 'swissmedic_info.zip'))).to eq(true)
+    it "should save into the download directory" do
+      expect(File.exist?(File.join(Oddb2xml::DOWNLOADS, "swissmedic_info.zip"))).to eq(true)
     end
   end
 end
-