bagit 0.4.2 → 0.4.3

data/lib/bagit/manifest.rb

@@ -3,21 +3,19 @@ require 'digest/sha1'
 require 'digest/md5'
 
 module BagIt
-
   # Requires response to bag_dir, tag_files, bag_files
   module Manifest
     def encode_filename(s)
-     s = s.gsub(/\r/, '%0D')
-     s = s.gsub(/\n/,'%0A')
-     return s
+      s = s.gsub(/\r/, '%0D')
+      s = s.gsub(/\n/, '%0A')
+      s
     end
 
-
     # All tag files that are bag manifest files (manifest-[algorithm].txt)
     def manifest_files
-      files = Dir[File.join(@bag_dir, '*')].select { |f|
-        File.file? f and File.basename(f) =~ /^manifest-.*.txt$/
-      }
+      files = Dir[File.join(@bag_dir, '*')].select do |f|
+        File.file?(f) && File.basename(f) =~ /^manifest-.*.txt$/
+      end
       files
     end
 
@@ -28,31 +26,34 @@ module BagIt
 
     # Generate manifest files for all the bag files
     def manifest!(algo: 'default')
-
       # nuke all the existing manifest files
-      manifest_files.each { |f| FileUtils::rm f }
+      manifest_files.each { |f| FileUtils.rm f }
 
       # manifest each tag file for each algorithm
       bag_files.each do |f|
         rel_path = encode_filename(Pathname.new(f).relative_path_from(Pathname.new(bag_dir)).to_s)
 
-        case algo
-        when 'sha1'
-          write_sha1(f, rel_path)
-        when 'md5'
-          write_md5(f, rel_path)
-        when 'sha256'
-          write_sha256(f, rel_path)
-        when 'sha512'
-          write_sha256(f, rel_path)
-        when 'default'
-          write_sha1(f, rel_path)
-          write_md5(f, rel_path)
-        end
+        write_checksum(checksum_algo: algo, relative_path: rel_path, file: f)
       end
       tagmanifest!
     end
 
+    def write_checksum(checksum_algo:, relative_path:, file:)
+      case checksum_algo
+      when 'sha1'
+        write_sha1(file, relative_path)
+      when 'md5'
+        write_md5(file, relative_path)
+      when 'sha256'
+        write_sha256(file, relative_path)
+      when 'sha512'
+        write_sha256(file, relative_path)
+      when 'default'
+        write_sha1(file, relative_path)
+        write_md5(file, relative_path)
+      end
+    end
+
     def write_sha1(f, rel_path)
       sha1 = Digest::SHA1.file f
       File.open(manifest_file(:sha1), 'a') { |io| io.puts "#{sha1} #{rel_path}" }
@@ -75,9 +76,9 @@ module BagIt
 
     # All tag files that are bag manifest files (tagmanifest-[algorithm].txt)
     def tagmanifest_files
-      files = Dir[File.join(@bag_dir, '*')].select { |f|
-        File.file? f and File.basename(f) =~ /^tagmanifest-.*.txt$/
-      }
+      files = Dir[File.join(@bag_dir, '*')].select do |f|
+        File.file?(f) && File.basename(f) =~ /^tagmanifest-.*.txt$/
+      end
       files
     end
 
@@ -88,12 +89,11 @@ module BagIt
 
     # Generate manifest files for all the tag files (except the tag
     # manifest files)
-    def tagmanifest!(tags=nil)
-
-      tags = tag_files if tags == nil
+    def tagmanifest!(tags = nil)
+      tags = tag_files if tags.nil?
 
       # nuke all the existing tagmanifest files
-      tagmanifest_files.each { |f| FileUtils::rm f }
+      tagmanifest_files.each { |f| FileUtils.rm f }
 
       # ensure presence of manfiest files
       manifest_files.each do |manifest|
@@ -111,29 +111,28 @@ module BagIt
       tag_files
     end
 
-    def add_tag_file(path, src_path=nil)
-
+    def add_tag_file(path, src_path = nil)
       f = File.join(@bag_dir, path)
       raise "Tag file already in manifest: #{path}" if tag_files.include?(f)
 
-      if not File.exist? f
-        FileUtils::mkdir_p File.dirname(f)
+      if !File.exist? f
+        FileUtils.mkdir_p File.dirname(f)
 
         # write file
         if src_path.nil?
           File.open(f, 'w') { |io| yield io }
         else
-          FileUtils::cp src_path, f
+          FileUtils.cp src_path, f
         end
         # this adds the manifest and bag info files on initial creation
         # it must only run when the manifest doesn't already exist or it will
         # infinitely recall add_tag_file. Better way of doing this?
         tagmanifest!
-      elsif not src_path.nil?
+      elsif !src_path.nil?
         raise "Tag file already exists, will not overwrite: #{path}\n Use add_tag_file(path) to add an existing tag file."
       end
 
-      data = File.open(f) { |io| io.read }
+      data = File.open(f, &:read)
       rel_path = Pathname.new(f).relative_path_from(Pathname.new(bag_dir)).to_s
 
       # sha1
@@ -157,7 +156,7 @@ module BagIt
       filepath = File.join(@bag_dir, path)
       raise "Tag file does not exist: #{path}" unless File.exist? filepath
       remove_tag_file(path) if tag_files.include?(path)
-      FileUtils::rm filepath
+      FileUtils.rm filepath
     end
 
     # Returns true if all present manifested files' message digests
@@ -167,7 +166,7 @@ module BagIt
         # extract the algorithm
         mf =~ /manifest-(.+).txt$/
 
-        algo = case $1
+        algo = case Regexp.last_match(1)
                when /sha1/i
                  Digest::SHA1
                when /md5/i
@@ -177,23 +176,19 @@ module BagIt
                end
 
         # check it, an unknown algorithm is always true
-        unless algo == :unknown
-          lines = File.open(mf) { |io| io.readlines }
+        if algo == :unknown
+          true
+        else
+          lines = File.open(mf, &:readlines)
 
           lines.all? do |line|
-            manifested_digest, path = line.chomp.split /\s+/, 2
+            manifested_digest, path = line.chomp.split(/\s+/, 2)
             actual_digest = File.open(File.join(@bag_dir, path)) { |io| algo.hexdigest io.read }
             actual_digest == manifested_digest
           end
 
-        else
-          true
         end
-
       end
-
     end
-
   end
-
 end

data/lib/bagit/string.rb

@@ -1,6 +1,5 @@
 # Some mixed in functionality for String
 class String
-  
   # Wrap a string to lines of a specified width. All existing newlines
   # are not guaranteed to be preserved
   def wrap(width)
@@ -11,7 +10,6 @@ class String
     else
       s
     end
-
   end
 
   # Indent each line of a string by n spaces
@@ -20,8 +18,8 @@ class String
     gsub '\n', "\n#{indent}"
   end
 
-# Colorize logs
- def color(color_code)
+  # Colorize logs
+  def color(color_code)
     "\e[#{color_code}m#{self}\e[0m"
   end
 

data/lib/bagit/valid.rb

@@ -4,29 +4,26 @@ require 'cgi'
 require 'logger'
 
 module BagIt
-
   class Bag
     include Validatable
-    validates_true_for :consistency, :logic => Proc.new { consistent? }
-    validates_true_for :completeness, :logic => Proc.new { complete? }
+    validates_true_for :consistency, logic: proc { consistent? }
+    validates_true_for :completeness, logic: proc { complete? }
   end
 
   module Validity
     def decode_filename(s)
-      s = s.gsub('%0D',"\r")
-      s = s.gsub('%0A',"\n")
-      return s
+      s = s.gsub('%0D', "\r")
+      s = s.gsub('%0A', "\n")
+      s
     end
-    
+
     # Return true if the manifest cover all files and all files are
     # covered.
     def complete?
       logger = Logger.new(STDOUT)
 
-      if manifest_files == []
-        errors.add  :completeness, "there are no manifest files"
-      end
-      
+      errors.add :completeness, "there are no manifest files" if manifest_files == []
+
       unmanifested_files.each do |file|
         logger.error("#{file} is present but not manifested".red)
         errors.add :completeness, "#{file} is present but not manifested"
@@ -44,38 +41,39 @@ module BagIt
       errors.on(:completeness).nil?
     end
 
+    def manifest_type(type)
+      case type
+      when /sha1/i
+        Digest::SHA1
+      when /md5/i
+        Digest::MD5
+      when /sha256/i
+        Digest::SHA256
+      when /sha384/i
+        Digest::SHA384
+      when /sha512/i
+        Digest::SHA512
+      else
+        raise ArgumentError, "Algorithm #{manifest_type} is not supported."
+      end
+    end
+
     # Return true if all manifested files message digests match.
     def consistent?
-      (manifest_files|tagmanifest_files).each do |mf|
+      (manifest_files | tagmanifest_files).each do |mf|
         # get the algorithm implementation
         File.basename(mf) =~ /manifest-(.+).txt$/
-        manifest_type = $1
-        algo = case manifest_type
-               when /sha1/i
-                 Digest::SHA1
-               when /md5/i
-                 Digest::MD5
-               when /sha256/i
-                 Digest::SHA256
-               when /sha384/i
-                 Digest::SHA384
-               when /sha512/i
-                 Digest::SHA512
-               else
-                 raise ArgumentError.new("Algorithm #{manifest_type} is not supported.")
-               end
+        type = Regexp.last_match(1)
+        algo = manifest_type(type)
         # Check every file in the manifest
         File.open(mf) do |io|
           io.each_line do |line|
-            expected, path = line.chomp.split /\s+/, 2
+            expected, path = line.chomp.split(/\s+/, 2)
             file = File.join(bag_dir, decode_filename(path))
 
-            if File.exist? file
-              actual = algo.file(file).hexdigest
-              if expected.downcase != actual         
-                errors.add :consistency, "expected #{file} to have #{algo}: #{expected}, actual is #{actual}"
-              end
-            end
+            next unless File.exist? file
+            actual = algo.file(file).hexdigest
+            errors.add :consistency, "expected #{file} to have #{algo}: #{expected}, actual is #{actual}" if expected.downcase != actual
           end
         end
       end
@@ -89,59 +87,53 @@ module BagIt
     end
 
     protected
-    
-    # Returns all files in the instance that are not manifested
-    def unmanifested_files
-      mfs = manifested_files.map { |f| File.join bag_dir, f }
-      bag_files.reject { |f| mfs.member? f }
-    end
 
-    # Returns a list of manifested files that are not present
-    def empty_manifests
-      bfs = bag_files
-      manifested_files.reject { |f| bfs.member? File.join(bag_dir, f) }
-    end
-    # Returns a list of tag manifested files that are not present
-    def tag_empty_manifests
-      empty = []
-      tag_manifested_files.each do |f|
-        if !File.exists?(File.join(bag_dir,f))
-          empty.push f
-        end
+      # Returns all files in the instance that are not manifested
+      def unmanifested_files
+        mfs = manifested_files.map { |f| File.join bag_dir, f }
+        bag_files.reject { |f| mfs.member? f }
       end
-      return empty
-    end
-    # Returns a list of all files present in the manifest files
-    def manifested_files
 
-      manifest_files.inject([]) do |acc, mf|
+      # Returns a list of manifested files that are not present
+      def empty_manifests
+        bfs = bag_files
+        manifested_files.reject { |f| bfs.member? File.join(bag_dir, f) }
+      end
 
-        files = File.open(mf) do |io|
+      # Returns a list of tag manifested files that are not present
+      def tag_empty_manifests
+        empty = []
+        tag_manifested_files.each do |f|
+          empty.push f unless File.exist?(File.join(bag_dir, f))
+        end
+        empty
+      end
 
-          io.readlines.map do |line|
-            digest, path = line.chomp.split /\s+/, 2
-            decode_filename(path)
+      # Returns a list of all files present in the manifest files
+      def manifested_files
+        manifest_files.inject([]) do |acc, mf|
+          files = File.open(mf) do |io|
+            io.readlines.map do |line|
+              _digest, path = line.chomp.split(/\s+/, 2)
+              decode_filename(path)
+            end
           end
 
+          (acc + files).uniq
         end
-
-        (acc + files).uniq
       end
 
-    end
-    # Returns a list of all files in the tag manifest files
-    def tag_manifested_files
-      tagmanifest_files.inject([]) do |acc, mf|
-        files = File.open(mf) do |io|
-          io.readlines.map do |line|
-            digest, path = line.chomp.split /\s+/, 2
-            path
+      # Returns a list of all files in the tag manifest files
+      def tag_manifested_files
+        tagmanifest_files.inject([]) do |acc, mf|
+          files = File.open(mf) do |io|
+            io.readlines.map do |line|
+              _digest, path = line.chomp.split(/\s+/, 2)
+              path
+            end
           end
+          (acc + files).uniq
         end
-        (acc+files).uniq
       end
-    end
-
   end
-
 end

data/lib/bagit/version.rb

@@ -1,3 +1,3 @@
 module BagIt
-  VERSION = "0.4.2"
+  VERSION = "0.4.3".freeze
 end

data/spec/bagit_spec.rb

@@ -2,31 +2,31 @@
 require 'spec_helper'
 
 # based on v0.96 http://www.cdlib.org/inside/diglib/bagit/bagitspec.html
-describe BagIt::Bag do
+RSpec.describe BagIt::Bag do
   describe 'empty bag' do
-    before(:each) 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
     end
 
-    after(:each) do
+    after do
       @sandbox.cleanup!
     end
 
-    it "should be empty" do
+    it "is empty" do
       expect(@bag).to be_empty
     end
   end
 
   describe 'bag with files' do
-    before(:each) 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|
@@ -37,47 +37,49 @@ describe BagIt::Bag do
       end
     end
 
-    after(:each) do
+    after do
       @sandbox.cleanup!
     end
 
-    it "should be a directory" do
+    it "is a directory" do
       expect(File.directory?(@bag_path)).to be true
     end
 
-    it "should not be empty" do
+    it "is not be empty" do
       expect(@bag).not_to be_empty
     end
 
-    it "should have a sub-directory called data" do
+    it "has a sub-directory called data" do
       data_path = File.join @bag_path, 'data'
       expect(File.directory?(data_path)).to be true
     end
 
     describe "#add_file" do
-      it "should allow addition of files via io" do
+      it "allows addition of files via io" do
         @bag.add_file("foo") { |io| io.puts 'all alone' }
         expect(File.join(@bag_path, "data", "foo")).to exist_on_fs
       end
 
-      it "should allow addition of files via copy" do
+      it "allows addition of files via copy" do
         src_path = File.join @sandbox.to_s, 'somefile'
         File.open(src_path, 'w') { |io| io.puts "something" }
         @bag.add_file("foo", src_path) { |io| io.puts 'all alone' }
         expect(File.join(@bag_path, "data", "foo")).to exist_on_fs
       end
 
-      it "should allow addition of files with deep paths" do
+      it "allows addition of files with deep paths" do
         @bag.add_file("deep/dir/structure/file") { |io| io.puts 'all alone' }
         expect(File.join(@bag_path, "data", "deep/dir/structure/file")).to exist_on_fs
       end
 
-      it "should not allow overwriting of files" do
-        expect { @bag.add_file("file-0-💩
-") { |io| io.puts 'overwrite!' } }.to raise_error(RuntimeError)
+      it "does not allow overwriting of files" do
+        expect do
+          @bag.add_file("file-0-💩
+") { |io| io.puts 'overwrite!' }
+        end.to raise_error(RuntimeError)
       end
 
-      it "should update payload oxum" do
+      it "updates the payload oxum" do
         oxum_count = @bag.bag_info["Payload-Oxum"].split('.')[1].to_i
         @bag.add_file("foo") { |io| io.puts 'all alone' }
         expect(@bag.bag_info["Payload-Oxum"].split('.')[1].to_i).to eq(oxum_count + 1)
@@ -85,14 +87,14 @@ describe BagIt::Bag do
     end
 
     describe "#remove_file" do
-      it "should raise an error when deleing non existant files" do
+      it "raises an error when deleing non existant files" do
         expect { @bag.remove_file("file-x") }.to raise_error(RuntimeError)
       end
     end
 
     describe "#get" do
       describe "file not in bag" do
-        it "should return nil" do
+        it "returns nil" do
           expect(@bag.get('foobar')).to be_nil
         end
       end
@@ -104,15 +106,15 @@ describe BagIt::Bag do
           @file = @bag.get("foo")
         end
 
-        it "should return an IO object for the given path" do
+        it "returns an IO object for the given path" do
           expect(@file).to be_a_kind_of(IO)
         end
 
-        it "should have the same content as the file added" do
+        it "has the same content as the file added" do
           expect(@file.read).to eq(@contents)
         end
 
-        it "should accept an optional leading slash or ./" do
+        it "accepts an optional leading slash or ./" do
           expect(@bag.get("/foo").read).to eq(@contents)
           expect(@bag.get("./foo").read).to eq(@contents)
         end
@@ -124,7 +126,7 @@ describe BagIt::Bag do
         @paths = @bag.paths
       end
 
-      it "should return a non-empty Array of Strings" do
+      it "returns a non-empty Array of Strings" do
         expect(@paths).to be_a_kind_of(Array)
         expect(@paths).not_to be_empty
         @paths.each do |p|
@@ -132,25 +134,27 @@ describe BagIt::Bag do
         end
       end
 
-      it "should return relative paths to all files in the data directory" do
-        expect(@paths).to match_array((0..9).collect { |x| "file-#{x}-💩
-" })
+      it "returns relative paths to all files in the data directory" do
+        expect(@paths).to match_array((0..9).collect do |x|
+                                        "file-#{x}-💩
+"
+                                      end)
       end
     end
 
     describe "#payload-oxum" do
-      it "should return a valid oxum" do
+      it "returns a valid oxum" do
         expect(@bag.payload_oxum).to match(/^[0-9]+\.[0-9]+$/)
       end
 
-      it "should accurately specify the number of payload files" do
+      it "accurately specifys the number of payload files" do
         @bag.add_tag_file('non-payload') { |f| f.puts "I shouldn't count in the oxum" }
         @bag.payload_oxum.split('.')[1] == @bag.bag_files.count
       end
     end
 
     describe "#gc!" do
-      it "should clean up empty directories" do
+      it "cleans up empty directories" do
         f = File.join "1", "2", "3", "file"
         @bag.add_file(f) { |io| io.puts 'all alone' }
         @bag.remove_file f