bagit 0.4.2 → 0.4.3

data/spec/fetch_spec.rb

@@ -1,57 +1,51 @@
 # coding: utf-8
 require 'spec_helper'
 
-describe "fetch.txt" do
-
-  before(:each) do
-
+describe BagIt::Bag do
+  before do
     @sandbox = Sandbox.new
-
     # make the bag
     @bag_path = File.join @sandbox.to_s, 'the_bag'
-    @bag = BagIt::Bag.new @bag_path
+    @bag = described_class.new(@bag_path)
 
     # add some files
     File.open('/dev/urandom') do |rio|
-
       10.times do |n|
         @bag.add_file("file-#{n}-💩
       end
-
     end
-
-  end
-
-  after(:each) do
-    @sandbox.cleanup!
   end
+  describe "fetch.txt" do
+    after do
+      @sandbox.cleanup!
+    end
 
-  before(:each) do
-    @bag.add_remote_file('http://www.gnu.org/graphics/heckert_gnu.small.png', 'gnu.png', 6322,
-                         '390c0a30976f899cbdf951eab5cce60fe9743ac9',
-                         'a3bd7ab2442028bb91b51d9f6722ec98')
+    before do
+      @bag.add_remote_file('http://www.gnu.org/graphics/heckert_gnu.small.png', 'gnu.png', 6322,
+                           '390c0a30976f899cbdf951eab5cce60fe9743ac9',
+                           'a3bd7ab2442028bb91b51d9f6722ec98')
 
-    path = File.join @bag_path, 'fetch.txt'
-    @lines = File.open(path) { |io| io.readlines }
-  end
+      path = File.join @bag_path, 'fetch.txt'
+      @lines = File.open(path, &:readlines)
+    end
 
-  it "should not be empty" do
-    expect(@lines).not_to be_empty
-  end
+    it "isn't empty" do
+      expect(@lines).not_to be_empty
+    end
 
-  it "should only contain lines of the format URL LENGTH FILENAME" do
-    @lines.each { |line| expect(line.chomp).to match(/^[^\s]+\s+(\d+|\-)\s+[^\s]+$/) }
-  end
+    it "only contains lines of the format URL LENGTH FILENAME" do
+      @lines.each { |line| expect(line.chomp).to match(/^[^\s]+\s+(\d+|\-)\s+[^\s]+$/) }
+    end
 
-  it "should contain manifested files" do
-    path = File.join @bag_path, 'manifest-sha1.txt'
-    data = File.open(path) { |io| io.read }
-    expect(data).to include('gnu.png')
-  end
+    it "contains manifested files" do
+      path = File.join @bag_path, 'manifest-sha1.txt'
+      data = File.open(path, &:read)
+      expect(data).to include('gnu.png')
+    end
 
-  it "should be gone when fetch is complete" do
-    @bag.fetch!
-    expect(File.exist?(File.join(@bag_path, 'fetch.txt'))).not_to be true
+    it "is gone when fetch is complete" do
+      @bag.fetch!
+      expect(File.exist?(File.join(@bag_path, 'fetch.txt'))).not_to be true
+    end
   end
-
 end

data/spec/manifest_spec.rb

@@ -1,148 +1,139 @@
 # coding: utf-8
 require 'spec_helper'
 
-describe "BagIt Manifests" do
-
-  before(:each) do
-
-    @sandbox = Sandbox.new
-
-    # make the bag
-    @bag_path = File.join @sandbox.to_s, 'the_bag'
-    @bag = BagIt::Bag.new @bag_path
+describe BagIt::Bag do
+  describe "BagIt Manifests" do
+    before do
+      @sandbox = Sandbox.new
 
-    # add some files
-    File.open('/dev/urandom') do |rio|
+      # make the bag
+      @bag_path = File.join @sandbox.to_s, 'the_bag'
+      @bag = described_class.new @bag_path
 
-      10.times do |n|
-        @bag.add_file("file-#{n}-💩
-        @bag.add_tag_file("tag-#{n}") { |io| io.write rio.read(16) }
+      # add some files
+      File.open('/dev/urandom') do |rio|
+        10.times do |n|
+          @bag.add_file("file-#{n}-💩
+          @bag.add_tag_file("tag-#{n}") { |io| io.write rio.read(16) }
+        end
       end
-
-      
-     
-      
     end
 
-  end
-
-  after(:each) do
-    @sandbox.cleanup!
-  end
-
-  shared_examples_for "a manifest file" do
-
-    before do
-      pattern = File.join @bag_path, '*manifest-*.txt'
-      @manifest_files = Dir.glob pattern
+    after do
+      @sandbox.cleanup!
     end
 
-    it "should have valid algorithm in the name (at least md5 or sha1)" do
-      algorithms = @manifest_files.map { |mf| mf =~ /manifest-(.*).txt$/; $1 }
-      algorithms.each { |a| expect(a).to be_in('md5', 'sha1') }
-    end
+    shared_examples_for "a manifest file" do
+      before do
+        pattern = File.join @bag_path, '*manifest-*.txt'
+        @manifest_files = Dir.glob pattern
+      end
 
-    it "should not be an empty file" do
-      @manifest_files.each { |mf| expect(File.size(mf)).not_to eq(0) }
-    end
+      it "has a valid algorithm in the name (at least md5 or sha1)" do
+        algorithms = @manifest_files.map { |mf| mf =~ /manifest-(.*).txt$/; Regexp.last_match(1) }
+        algorithms.each { |a| expect(a).to be_in('md5', 'sha1') }
+      end
 
-    it "should only contain lines of the format CHECKSUM FILENAME" do
-      @manifest_files.each do |file|
-        File.open(file) do |io|
-          io.each_line { |line| expect(line).to match(/^[a-fA-F0-9]+\s+[^\s].+$/) }
+      it "is not an empty file" do
+        @manifest_files.each { |mf| expect(File.size(mf)).not_to eq(0) }
+      end
+
+      it "only contains lines of the format CHECKSUM FILENAME" do
+        @manifest_files.each do |file|
+          File.open(file) do |io|
+            io.each_line { |line| expect(line).to match(/^[a-fA-F0-9]+\s+[^\s].+$/) }
+          end
         end
       end
-    end
 
-    it "should validate after adding a file and remanifesting" do
-      @bag.add_file('newfile.txt') { |io| io.puts("new file to remanifest") }
-      @bag.manifest!
-      expect(@bag).to be_valid
+      it "validates after adding a file and remanifesting" do
+        @bag.add_file('newfile.txt') { |io| io.puts("new file to remanifest") }
+        @bag.manifest!
+        expect(@bag).to be_valid
+      end
     end
 
-  end
-
-  describe "bag manifest files" do
-
-    before do
-      @bag.manifest!
-    end
+    describe "bag manifest files" do
+      before do
+        @bag.manifest!
+      end
 
-    it_behaves_like "a manifest file"
+      it_behaves_like "a manifest file"
 
-    it "should have a manifest file" do
-      expect(@bag.manifest_files).not_to be_empty
-    end
+      it "has a manifest file" do
+        expect(@bag.manifest_files).not_to be_empty
+      end
 
-    it "should only contain bag files" do
-      @bag.manifest_files.each do |mf|
-        File.open(mf) do |io|
-          io.each_line do |line|
-            expect(line.chomp).to match(/^[a-f0-9]+\s+data\/[^\s].+$/)
+      it "only contains bag files" do
+        @bag.manifest_files.each do |mf|
+          File.open(mf) do |io|
+            io.each_line do |line|
+              expect(line.chomp).to match(/^[a-f0-9]+\s+data\/[^\s].+$/)
+            end
           end
         end
       end
     end
 
-  end
-
-  describe "tag manifest files" do
-
-    before do
-      @bag.add_tag_file("test-tag") { |f| f.puts "all alone" }
-    end
+    describe "tag manifest files" do
+      before do
+        @bag.add_tag_file("test-tag") { |f| f.puts "all alone" }
+      end
 
-    it_should_behave_like "a manifest file"
+      it_should_behave_like "a manifest file"
 
-    it "should have a tag manifest file" do
-      expect(@bag.tagmanifest_files).not_to be_empty
-    end
-    it "should only contain tag files" do
-      @bag.tagmanifest_files.each do |mf|
-        File.open(mf) do |io|
-          io.each_line do |line|
-            expect(line.chomp).to match(/^[a-fA-F0-9]+\s+(?!data\/)[^\s].+$/)
-          end
-        end
+      it "has a tag manifest file" do
+        expect(@bag.tagmanifest_files).not_to be_empty
       end
-    end
-    it "should contain manifest and bag info files" do
-      @bag.tagmanifest_files.each do |mf|
-        expect(File.open(mf).read).to include(File.basename(@bag.bag_info_txt_file))
-        expect(File.open(mf).read).to include(File.basename(@bag.bagit_txt_file))
-        @bag.manifest_files.each do |man|
-          expect(File.open(mf).read).to include(man)
+      it "only contains tag files" do
+        @bag.tagmanifest_files.each do |mf|
+          File.open(mf) do |io|
+            io.each_line do |line|
+              expect(line.chomp).to match(/^[a-fA-F0-9]+\s+(?!data\/)[^\s].+$/)
+            end
+          end
         end
       end
-    end
-    it "should not contain the untracked tag file" do
-      @bag.tagmanifest_files.each do |mf|
-        File.open(mf) do |io|
-          expect(io.read).not_to include "tag-notrack"
+      it "contains manifest and bag info files" do
+        @bag.tagmanifest_files.each do |mf|
+          expect(File.open(mf).read).to include(File.basename(@bag.bag_info_txt_file))
+          expect(File.open(mf).read).to include(File.basename(@bag.bagit_txt_file))
+          @bag.manifest_files.each do |man|
+            expect(File.open(mf).read).to include(man)
+          end
         end
       end
-    end
-    describe "removing tracked files" do
-      before(:each) do
-        @bag.remove_tag_file "tag-1"
-        @bag.delete_tag_file "tag-2"
-      end
-      it "should still have the untracked tag file on the file system" do
-        expect(File.join(@bag_path, "tag-1")).to exist_on_fs
-      end
-      it "should not have the deleted tag file on the file system" do
-        expect(File.join(@bag_path, "tag-2")).not_to exist_on_fs
-      end
-      it "should not have the removed or deleted tag files in the manifest" do
+      it "does not contain the untracked tag file" do
         @bag.tagmanifest_files.each do |mf|
           File.open(mf) do |io|
-            expect(io.read).not_to include "tag-1"
-            expect(io.read).not_to include "tag-2"
+            expect(io.read).not_to include "tag-notrack"
           end
         end
       end
-    end
-  end
 
+      describe "removing tracked files" do
+        before do
+          @bag.remove_tag_file "tag-1"
+          @bag.delete_tag_file "tag-2"
+        end
+
+        it "still has the untracked tag file on the file system" do
+          expect(File.join(@bag_path, "tag-1")).to exist_on_fs
+        end
 
+        it "doesn't have the deleted tag file on the file system" do
+          expect(File.join(@bag_path, "tag-2")).not_to exist_on_fs
+        end
+
+        it "doesn't have the removed or deleted tag files in the manifest" do
+          @bag.tagmanifest_files.each do |mf|
+            File.open(mf) do |io|
+              expect(io.read).not_to include "tag-1"
+              expect(io.read).not_to include "tag-2"
+            end
+          end
+        end
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -12,26 +12,24 @@ RSpec.configure do |config|
   config.include(BagitMatchers)
 end
 
-$:.unshift File.expand_path('../lib', File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
 require 'bagit'
 
 require 'tempfile'
 
 class Sandbox
-
   def initialize
     tf = Tempfile.open 'sandbox'
     @path = tf.path
     tf.close!
-    FileUtils::mkdir @path
+    FileUtils.mkdir @path
   end
 
   def cleanup!
-    FileUtils::rm_rf @path
+    FileUtils.rm_rf @path
   end
 
   def to_s
     @path
   end
-
 end

data/spec/tag_info_spec.rb

@@ -1,78 +1,72 @@
 # coding: utf-8
 require 'spec_helper'
 
-describe "Tag Info Files" do
-
-  before(:each) do
-
-    @sandbox = Sandbox.new
+describe BagIt::Bag do
+  describe "Tag Info Files" do
+    before do
+      @sandbox = Sandbox.new
 
-    # make the bag
-    @bag_path = File.join @sandbox.to_s, 'the_bag'
-    @bag = BagIt::Bag.new @bag_path
+      # make the bag
+      @bag_path = File.join @sandbox.to_s, 'the_bag'
+      @bag = described_class.new @bag_path
 
-    # add some files
-    File.open('/dev/urandom') do |rio|
-      10.times do |n|
-        @bag.add_file("file-#{n}-💩
+      # add some files
+      File.open('/dev/urandom') do |rio|
+        10.times do |n|
+          @bag.add_file("file-#{n}-💩
+        end
       end
     end
 
-  end
-
-  after(:each) do
-    @sandbox.cleanup!
-  end
-
-  describe "bagit.txt" do
-
-    before do
-      path = File.join @bag_path, 'bagit.txt'
-      @lines = File.open(path) { |io| io.readlines }
-    end
-
-    it "should create a file bagit.txt on bag initialization" do
-      expect(File.join(@bag_path, 'bagit.txt')).to exist_on_fs
+    after do
+      @sandbox.cleanup!
     end
 
-    it "should have exactly two lines" do
-      expect(@lines.size).to eq(2)
-    end
-
-    it "should have a bagit version" do
-      a = @lines.select { |line| line.chomp =~ /BagIt-Version:\s*\d+\.\d+/ }
-      expect(a).not_to be_empty
-    end
+    describe "bagit.txt" do
+      before do
+        path = File.join @bag_path, 'bagit.txt'
+        @lines = File.open(path, &:readlines)
+      end
 
-    it "should have a tag file encoding" do
-      a = @lines.select { |line| line.chomp =~ /Tag-File-Character-Encoding:\s*.+/ }
-      expect(a).not_to be_empty
-    end
+      it "creates a file bagit.txt on bag initialization" do
+        expect(File.join(@bag_path, 'bagit.txt')).to exist_on_fs
+      end
 
-  end
+      it "has exactly two lines" do
+        expect(@lines.size).to eq(2)
+      end
 
-  describe "bag-info.txt" do
+      it "has a bagit version" do
+        a = @lines.select { |line| line.chomp =~ /BagIt-Version:\s*\d+\.\d+/ }
+        expect(a).not_to be_empty
+      end
 
-    before(:each) do
-      path = File.join @bag_path, 'bag-info.txt'
-      @lines = File.open(path) { |io| io.readlines }
+      it "has a tag file encoding" do
+        a = @lines.select { |line| line.chomp =~ /Tag-File-Character-Encoding:\s*.+/ }
+        expect(a).not_to be_empty
+      end
     end
 
-    it "should not be empty" do
-      expect(@lines).not_to be_empty
-    end
+    describe "bag-info.txt" do
+      before do
+        path = File.join @bag_path, 'bag-info.txt'
+        @lines = File.open(path, &:readlines)
+      end
 
-    it "should contain lines of the format LABEL: VALUE (like an email header)" do
-      @lines.each { |line| expect(line.chomp).to match(/^[^\s]+\s*:\s+.*$/) }
-    end
+      it "isn't empty" do
+        expect(@lines).not_to be_empty
+      end
 
-    it "should be case insensitive with respect to LABELs" do
-      path = File.join @bag_path, 'bag-info.txt'
-      expect { @bag.write_bag_info 'foo' => 'lowercase', 'Foo' => 'capital' }.to raise_error(/Multiple labels/)
-    end
+      it "contains lines of the format LABEL: VALUE (like an email header)" do
+        @lines.each { |line| expect(line.chomp).to match(/^[^\s]+\s*:\s+.*$/) }
+      end
 
-    it "should fold long VALUEs" do
-      longline = <<LOREM
+      it "is case insensitive with respect to LABELs" do
+        expect { @bag.write_bag_info 'foo' => 'lowercase', 'Foo' => 'capital' }.to raise_error(/Multiple labels/)
+      end
+
+      it "folds long VALUEs" do
+        longline = <<LOREM
 Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
   eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enimad
   minim veniam, quis nostrud exercitation ullamco laboris nisi ut
@@ -81,53 +75,51 @@ Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
   pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
   culpa qui officia deserunt mollit anim id est laborum.
 LOREM
-      @bag.write_bag_info 'Lorem' => longline
-      expect(@bag.bag_info.keys.length).to eq(4) # this isn't a great test. Changed it from 1 to 4 because unrelated changes caused failure.
-    end
+        @bag.write_bag_info 'Lorem' => longline
+        expect(@bag.bag_info.keys.length).to eq(4) # this isn't a great test. Changed it from 1 to 4 because unrelated changes caused failure.
+      end
 
-    it "should specify a bag software agent" do
-      expect(@bag.bag_info.keys).to include("Bag-Software-Agent")
-    end
+      it "specifys a bag software agent" do
+        expect(@bag.bag_info.keys).to include("Bag-Software-Agent")
+      end
 
-    it "should contain a valid bagging date" do
-      expect(@bag.bag_info.keys).to include("Bagging-Date")
-      @bag.bag_info["Bagging-Date"] =~ /^^[0-9]{4}-[0-9]{2}-[0-9]{2}$/
-    end
+      it "contains a valid bagging date" do
+        expect(@bag.bag_info.keys).to include("Bagging-Date")
+        @bag.bag_info["Bagging-Date"] =~ /^^[0-9]{4}-[0-9]{2}-[0-9]{2}$/
+      end
 
-    it "should contain a payload oxum" do
-      expect(@bag.bag_info.keys).to include("Payload-Oxum")
-    end
-    it "should not override any previous values" do
-      path = File.join @bag_path, 'bag-info.txt'
-      @bag.write_bag_info 'Bag-Software-Agent' => 'Some Other Agent'
-      @bag.write_bag_info 'Source-Organization' => 'Awesome Inc.'
-      @bag.write_bag_info 'Bagging-Date' => '1901-01-01'
-      @bag.write_bag_info
-      contents = File.open(path).read
-      expect(contents).to include "Some Other Agent"
-      expect(contents).to include "Awesome Inc."
-      expect(contents).to include "1901-01-01"
-    end
-    it "should override previous tags when they collide with new ones" do
-      path = File.join @bag_path, 'bag-info.txt'
-      @bag.write_bag_info 'Source-Organization' => 'Awesome Inc.'
-      @bag.write_bag_info 'Source-Organization' => 'Awesome LLC.'
-      contents = File.open(path).read
-      expect(contents).to include "Awesome LLC."
-      expect(contents).not_to include "Awesome Inc."
-    end
-    it "should contain values passed to bag" do
-      hash = {"Bag-Software-Agent" => "rspec",
-        "Bagging-Date" => "2012-11-21",
-        "Contact-Name" => "Willis Corto",
-        "Some-Tag" => "Some Value"
-      }
-      bag_with_info = BagIt::Bag.new(@bag_path + '2', hash)
-      hash.each do |key, value|
-        expect(bag_with_info.bag_info[key]).to eq(value)
+      it "contains a payload oxum" do
+        expect(@bag.bag_info.keys).to include("Payload-Oxum")
+      end
+      it "does not override any previous values" do
+        path = File.join @bag_path, 'bag-info.txt'
+        @bag.write_bag_info 'Bag-Software-Agent' => 'Some Other Agent'
+        @bag.write_bag_info 'Source-Organization' => 'Awesome Inc.'
+        @bag.write_bag_info 'Bagging-Date' => '1901-01-01'
+        @bag.write_bag_info
+        contents = File.open(path).read
+        expect(contents).to include "Some Other Agent"
+        expect(contents).to include "Awesome Inc."
+        expect(contents).to include "1901-01-01"
+      end
+      it "overrides previous tags when they collide with new ones" do
+        path = File.join @bag_path, 'bag-info.txt'
+        @bag.write_bag_info 'Source-Organization' => 'Awesome Inc.'
+        @bag.write_bag_info 'Source-Organization' => 'Awesome LLC.'
+        contents = File.open(path).read
+        expect(contents).to include "Awesome LLC."
+        expect(contents).not_to include "Awesome Inc."
+      end
+      it "contains values passed to bag" do
+        hash = { "Bag-Software-Agent" => "rspec",
+                 "Bagging-Date" => "2012-11-21",
+                 "Contact-Name" => "Willis Corto",
+                 "Some-Tag" => "Some Value" }
+        bag_with_info = described_class.new(@bag_path + '2', hash)
+        hash.each do |key, value|
+          expect(bag_with_info.bag_info[key]).to eq(value)
+        end
       end
     end
-
   end
-
 end