druid-tools 1.0.0 → 2.0.0

data/README.md

@@ -1,6 +1,5 @@
 [![Build Status](https://travis-ci.org/sul-dlss/druid-tools.svg?branch=delete-records)](https://travis-ci.org/sul-dlss/druid-tools)
 [![Coverage Status](https://coveralls.io/repos/github/sul-dlss/druid-tools/badge.svg?branch=master)](https://coveralls.io/github/sul-dlss/druid-tools?branch=master)
-[![Dependency Status](https://gemnasium.com/badges/github.com/sul-dlss/druid-tools.svg)](https://gemnasium.com/github.com/sul-dlss/druid-tools)
 [![Gem Version](https://badge.fury.io/rb/druid-tools.svg)](https://badge.fury.io/rb/druid-tools)
 
 # Druid::Tools
@@ -11,7 +10,7 @@ Note that druid syntax is defined in consul (and druids are issued by the SURI s
 
 Druid format:
 
-    bbdddbbdddd (two letters two digits two letters 4 digits)
+    bbdddbbdddd (two letters three digits two letters 4 digits)
 
 Letters must be lowercase, and must not include A, E, I, O, U or L.  (capitals for easier distinction here)
 We often use vowels in our test data, and this code base has allowed vowels historically (though not

data/Rakefile

@@ -1,5 +1,7 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
@@ -7,4 +9,4 @@ RSpec::Core::RakeTask.new(:spec)
 require 'rubocop/rake_task'
 RuboCop::RakeTask.new
 
-task :default => [:spec, :rubocop]
+task default: %i[spec rubocop]

data/VERSION

@@ -1 +1 @@
-1.0.0
+2.0.0

data/druid-tools.gemspec

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 
 Gem::Specification.new do |gem|
   gem.authors       = ['Michael Klein', 'Darren Hardy']
@@ -9,16 +9,16 @@ Gem::Specification.new do |gem|
   gem.licenses      = ['ALv2', 'Stanford University Libraries']
   gem.has_rdoc      = true
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^spec/})
   gem.name          = 'druid-tools'
   gem.require_paths = ['lib']
   gem.version       = File.read('VERSION').strip
 
+  gem.add_development_dependency 'coveralls'
   gem.add_development_dependency 'rake', '>= 10.1.0'
   gem.add_development_dependency 'rspec', '~> 3.0'
-  gem.add_development_dependency 'coveralls'
-  gem.add_development_dependency 'rubocop', '~> 0.50.0' # avoid code churn due to rubocop changes
-  gem.add_development_dependency 'rubocop-rspec', '~> 1.18.0' # avoid code churn due to rubocop-rspec changes
+  gem.add_development_dependency 'rubocop', '~> 0.70.0'
+  gem.add_development_dependency 'rubocop-rspec', '~> 1.33.0'
 end

data/lib/druid-tools.rb

@@ -1 +1,3 @@
-require 'druid_tools'
+# frozen_string_literal: true
+
+require 'druid_tools'

data/lib/druid_tools.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DruidTools
   require 'druid_tools/version'
   require 'druid_tools/druid'

data/lib/druid_tools/access_druid.rb

@@ -1,9 +1,8 @@
+# frozen_string_literal: true
 
 module DruidTools
-
   # Overrides the Druid#tree method
   class AccessDruid < Druid
-
     self.prefix = 'druid'
 
     def tree
@@ -11,15 +10,13 @@ module DruidTools
     end
 
     # all content lives in the base druid directory
-    def path(extra=nil, create=false)
-      result = File.join(*([base,tree].compact))
-      mkdir(extra) if create and not File.exists?(result)
+    def path(extra = nil, create = false)
+      result = File.join(*[base, tree].compact)
+      mkdir(extra) if create && !File.exist?(result)
       result
     end
-
   end
 
   PurlDruid = AccessDruid
   StacksDruid = AccessDruid
-
 end

data/lib/druid_tools/druid.rb

@@ -1,47 +1,48 @@
+# frozen_string_literal: true
+
 require 'pathname'
 require 'fileutils'
 
 module DruidTools
   class Druid
-    @@deletes_directory_name = '.deletes'
     attr_accessor :druid, :base
 
     # See https://consul.stanford.edu/pages/viewpage.action?title=SURI+2.0+Specification&spaceKey=chimera
     # character class matching allowed letters in a druid suitable for use in regex (no aeioul)
-    STRICT_LET = '[b-df-hjkmnp-tv-z]'.freeze
+    STRICT_LET = '[b-df-hjkmnp-tv-z]'
 
     class << self
       attr_accessor :prefix
 
       # @param [boolean] true if validation should be more restrictive about allowed letters (no aeioul)
       # @return [Regexp] matches druid:aa111aa1111 or aa111aa1111
-      def pattern(strict=false)
-        return /\A(?:#{self.prefix}:)?(#{STRICT_LET}{2})(\d{3})(#{STRICT_LET}{2})(\d{4})\z/ if strict
-        /\A(?:#{self.prefix}:)?([a-z]{2})(\d{3})([a-z]{2})(\d{4})\z/
+      def pattern(strict = false)
+        return /\A(?:#{prefix}:)?(#{STRICT_LET}{2})(\d{3})(#{STRICT_LET}{2})(\d{4})\z/ if strict
+
+        /\A(?:#{prefix}:)?([a-z]{2})(\d{3})([a-z]{2})(\d{4})\z/
       end
 
       # @return [String] suitable for use in [Dir#glob]
       def glob
-        "{#{self.prefix}:,}[a-z][a-z][0-9][0-9][0-9][a-z][a-z][0-9][0-9][0-9][0-9]"
+        "{#{prefix}:,}[a-z][a-z][0-9][0-9][0-9][a-z][a-z][0-9][0-9][0-9][0-9]"
       end
 
       # @return [String] suitable for use in [Dir#glob]
       def strict_glob
-        "{#{self.prefix}:,}#{STRICT_LET}#{STRICT_LET}[0-9][0-9][0-9]#{STRICT_LET}#{STRICT_LET}[0-9][0-9][0-9][0-9]"
+        "{#{prefix}:,}#{STRICT_LET}#{STRICT_LET}[0-9][0-9][0-9]#{STRICT_LET}#{STRICT_LET}[0-9][0-9][0-9][0-9]"
       end
 
       # @param [String] druid id
       # @param [boolean] true if validation should be more restrictive about allowed letters (no aeioul)
       # @return [Boolean] true if druid matches pattern; otherwise false
-      def valid?(druid, strict=false)
+      def valid?(druid, strict = false)
         druid =~ pattern(strict) ? true : false
       end
-
     end
     self.prefix = 'druid'
 
-    [:content, :metadata, :temp].each do |dir_type|
-      self.class_eval <<-EOC
+    %i[content metadata temp].each do |dir_type|
+      class_eval <<-EOC
         def #{dir_type}_dir(create=true)
           path("#{dir_type}",create)
         end
@@ -55,11 +56,10 @@ module DruidTools
     # @param druid [String] A valid druid
     # @param [boolean] true if validation should be more restrictive about allowed letters (no aeioul)
     # @param base [String] The directory used by #path
-    def initialize(druid, base='.', strict=false)
+    def initialize(druid, base = '.', strict = false)
       druid = druid.to_s unless druid.is_a? String
-      unless self.class.valid?(druid, strict)
-        raise ArgumentError, "Invalid DRUID: '#{druid}'"
-      end
+      raise ArgumentError, "Invalid DRUID: '#{druid}'" unless self.class.valid?(druid, strict)
+
       druid = [self.class.prefix, druid].join(':') unless druid =~ /^#{self.class.prefix}:/
       @base = base
       @druid = druid
@@ -73,27 +73,24 @@ module DruidTools
       @druid.scan(self.class.pattern).flatten + [id]
     end
 
-    def path(extra=nil, create=false)
-      result = File.join(*([base,tree,extra].compact))
-      mkdir(extra) if create and not File.exists?(result)
+    def path(extra = nil, create = false)
+      result = File.join(*[base, tree, extra].compact)
+      mkdir(extra) if create && !File.exist?(result)
       result
     end
 
-    def mkdir(extra=nil)
+    def mkdir(extra = nil)
       new_path = path(extra)
-      if(File.symlink? new_path)
-        raise DruidTools::DifferentContentExistsError, "Unable to create directory, link already exists: #{new_path}"
-      end
-      if(File.directory? new_path)
-        raise DruidTools::SameContentExistsError, "The directory already exists: #{new_path}"
-      end
+      raise DruidTools::DifferentContentExistsError, "Unable to create directory, link already exists: #{new_path}" if File.symlink? new_path
+      raise DruidTools::SameContentExistsError, "The directory already exists: #{new_path}" if File.directory? new_path
+
       FileUtils.mkdir_p(new_path)
     end
 
     def find(type, path)
-      possibles = [self.path(type.to_s),self.path,File.expand_path('..',self.path)]
-      loc = possibles.find { |p| File.exists?(File.join(p,path)) }
-      loc.nil? ? nil : File.join(loc,path)
+      possibles = [self.path(type.to_s), self.path, File.expand_path('..', self.path)]
+      loc = possibles.find { |p| File.exist?(File.join(p, path)) }
+      loc.nil? ? nil : File.join(loc, path)
     end
 
     # @param [String] type The type of directory being sought ('content', 'metadata', or 'temp')
@@ -101,35 +98,38 @@ module DruidTools
     # @return [Pathname] Search for and return the pathname of the directory that contains the list of files.
     #    Raises an exception unless a directory is found that contains all the files in the list.
     def find_filelist_parent(type, filelist)
-      raise "File list not specified" if filelist.nil? or filelist.empty?
+      raise 'File list not specified' if filelist.nil? || filelist.empty?
+
       filelist = [filelist] unless filelist.is_a?(Array)
-      search_dir = Pathname(self.path(type))
+      search_dir = Pathname(path(type))
       directories = [search_dir, search_dir.parent, search_dir.parent.parent]
       found_dir = directories.find { |pathname| pathname.join(filelist[0]).exist? }
       raise "#{type} dir not found for '#{filelist[0]}' when searching '#{search_dir}'" if found_dir.nil?
+
       filelist.each do |filename|
-        raise "File '#{filename}' not found in #{type} dir s'#{found_dir}'" unless found_dir.join(filename).exist?
+        raise "File '#{filename}' not found in #{type} dir '#{found_dir}'" unless found_dir.join(filename).exist?
       end
       found_dir
     end
 
-    def mkdir_with_final_link(source, extra=nil)
+    def mkdir_with_final_link(source, extra = nil)
       new_path = path(extra)
-      if(File.directory?(new_path) && !File.symlink?(new_path))
+      if File.directory?(new_path) && !File.symlink?(new_path)
         raise DruidTools::DifferentContentExistsError, "Unable to create link, directory already exists: #{new_path}"
       end
-      real_path = File.expand_path('..',new_path)
+
+      real_path = File.expand_path('..', new_path)
       FileUtils.mkdir_p(real_path)
-      FileUtils.ln_s(source, new_path, :force=>true)
+      FileUtils.ln_s(source, new_path, force: true)
     end
 
-    def rmdir(extra=nil)
+    def rmdir(extra = nil)
       parts = tree
       parts << extra unless extra.nil?
-      while parts.length > 0
+      until parts.empty?
         dir = File.join(base, *parts)
         begin
-          FileUtils.rm(File.join(dir,'.DS_Store'), :force => true)
+          FileUtils.rm(File.join(dir, '.DS_Store'), force: true)
           FileUtils.rmdir(dir)
         rescue Errno::ENOTEMPTY
           break
@@ -139,11 +139,11 @@ module DruidTools
     end
 
     def pathname
-      Pathname self.path
+      Pathname path
     end
 
     def base_pathname
-      Pathname self.base
+      Pathname base
     end
 
     def prune!
@@ -151,84 +151,16 @@ module DruidTools
       parent = this_path.parent
       parent.rmtree if parent.exist? && parent != base_pathname
       prune_ancestors parent.parent
-      creates_delete_record
-    end
-
-    #This function checks for existance of a .deletes dir one level into the path (ex: stacks/.deletes or purl/.deletes).
-    #If the directory does not exist, it is created.  If the directory exists, check to see if the current druid has an entry there, if it does delete it.
-    #This is done because a file might be deleted, then republishing, then deleted we again, and we want to log the most recent delete.
-    #
-    #@raises [Errno::EACCES] If write priveleges are denied
-    #
-    #@return [void]
-    def prep_deletes_dir
-      #Check for existences of deletes dir
-      create_deletes_dir if !deletes_dir_exists?
-      #In theory we could return true after this step (if it fires), since if there was no deletes dir then the file can't be present in the dir
-
-      #Check to see if this druid has been deleted before, meaning file currently exists
-      deletes_delete_record if deletes_record_exists?
-    end
-
-    #Provide the location for the .deletes directory in the tree
-    #
-    #@return [Pathname] the path to the directory, ex: "stacks/.deletes"
-    def deletes_dir_pathname
-      return Pathname(self.base.to_s + (File::SEPARATOR+@@deletes_directory_name))
-    end
-
-    def deletes_record_pathname
-      return Pathname(deletes_dir_pathname.to_s + File::SEPARATOR + self.id)
-    end
-
-    #Using the deletes directory path supplied by deletes_dir_pathname, this function determines if this directory exists
-    #
-    #@return [Boolean] true if if exists, false if it does not
-    def deletes_dir_exists?
-      return File.directory?(deletes_dir_pathname)
-    end
-
-    def deletes_record_exists?
-      return File.exists?(deletes_dir_pathname.to_s + File::SEPARATOR + self.id)
-    end
-
-    #Creates the deletes dir using the path supplied by deletes_dir_pathname
-    #
-    #@raises [Errno::EACCES] If write priveleges are denied
-    #
-    #@return [void]
-    def create_deletes_dir
-      FileUtils::mkdir_p deletes_dir_pathname
-    end
-
-    #Deletes the delete record if it currently exists.  This is done to change the filed created, not just last modified time, on the system
-    #
-    #@raises [Errno::EACCES] If write priveleges are denied
-    #
-    #return [void]
-    def deletes_delete_record
-      FileUtils.rm(deletes_record_pathname) if deletes_record_exists? #thrown in to prevent an  Errno::ENOENT if you call this on something without a delete record
-    end
-
-    #Creates an empty (pointer) file using the object's id in the .deletes dir
-    #
-    #@raises [Errno::EACCES] If write priveleges are denied
-    #
-    #@return [void]
-    def creates_delete_record
-      prep_deletes_dir
-      FileUtils.touch(deletes_record_pathname)
     end
 
     # @param [Pathname] outermost_branch The branch at which pruning begins
     # @return [void] Ascend the druid tree and prune empty branches
     def prune_ancestors(outermost_branch)
-      while outermost_branch.exist? && outermost_branch.children.size == 0
+      while outermost_branch.exist? && outermost_branch.children.empty?
         outermost_branch.rmdir
         outermost_branch = outermost_branch.parent
-        break if  outermost_branch == base_pathname
+        break if outermost_branch == base_pathname
       end
     end
-
   end
 end

data/lib/druid_tools/exceptions.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module DruidTools
-  class SameContentExistsError < Exception; end
-  class DifferentContentExistsError < Exception; end
-  class InvalidDruidError < Exception; end
-end
+  class SameContentExistsError < RuntimeError; end
+  class DifferentContentExistsError < RuntimeError; end
+  class InvalidDruidError < RuntimeError; end
+end

data/lib/druid_tools/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DruidTools
   VERSION = File.read(File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'VERSION'))).to_s.strip
 end

data/spec/druid_tools/purl_druid_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe DruidTools::PurlDruid do
+  let(:purl_root) { Dir.mktmpdir }
+
+  let(:druid) { described_class.new 'druid:cd456ef7890', purl_root }
+
+  after do
+    FileUtils.remove_entry purl_root
+  end
+
+  it 'overrides Druid#tree so that the leaf is not Druid#id' do
+    expect(druid.tree).to eq(%w[cd 456 ef 7890])
+  end
+
+  describe '#content_dir' do
+    it 'creates content directories at leaf of the druid tree' do
+      expect(druid.content_dir).to match(%r{ef/7890$})
+    end
+
+    it "does not create a 'content' subdirectory" do
+      expect(druid.content_dir).not_to match(/content$/)
+    end
+  end
+end

data/spec/druid_tools_spec.rb

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+RSpec.describe DruidTools::Druid do
+  let(:fixture_dir) { File.expand_path('fixtures', __dir__) }
+  let(:druid_str) { 'druid:cd456ef7890' }
+  let(:tree1) { File.join(fixture_dir, 'cd/456/ef/7890/cd456ef7890') }
+  let(:strictly_valid_druid_str) { 'druid:cd456gh1234' }
+  let(:tree2) { File.join(fixture_dir, 'cd/456/gh/1234/cd456gh1234') }
+
+  after do
+    FileUtils.rm_rf(File.join(fixture_dir, 'cd'))
+  end
+
+  describe '.valid?' do
+    # also tests .pattern
+    it 'correctly validates druid strings' do
+      tests = [
+        # Expected     Input druid
+        [true,         'druid:aa000bb0001'],
+        [true,         'aa000bb0001'],
+        [false,        'Aa000bb0001'],
+        [false,        "xxx\naa000bb0001"],
+        [false,        'aaa000bb0001'],
+        [false,        'druidX:aa000bb0001'],
+        [false,        ':aa000bb0001'],
+        [true,         'aa123bb1234'],
+        [false,        'aa12bb1234'],
+        [false,        'aa1234bb1234'],
+        [false,        'aa123bb123'],
+        [false,        'aa123bb12345'],
+        [false,        'a123bb1234'],
+        [false,        'aaa123bb1234'],
+        [false,        'aa123b1234'],
+        [false,        'aa123bbb1234'],
+        [false,        'druid:az918AZ9381'.upcase],
+        [true,         'druid:az918AZ9381'.downcase],
+        [true,         'druid:zz943vx1492']
+      ]
+      tests.each do |exp, dru|
+        expect(described_class.valid?(dru)).to eq(exp)
+        expect(described_class.valid?(dru, false)).to eq(exp)
+      end
+    end
+    context 'with strict validation' do
+      it 'correctly validates druid strings' do
+        tests = [
+          # Expected     Input druid
+          [false,        'aa000aa0000'],
+          [false,        'ee000ee0000'],
+          [false,        'ii000ii0000'],
+          [false,        'oo000oo0000'],
+          [false,        'uu000uu0000'],
+          [false,        'll000ll0000'],
+          [false,        'aa000bb0001'],
+          [true,         'druid:dd000bb0001'],
+          [false,        'druid:aa000bb0001'],
+          [true,         'dd000bb0001'],
+          [false,        'Dd000bb0001'],
+          [false,        "xxx\ndd000bb0001"],
+          [false,        'ddd000bb0001'],
+          [false,        'druidX:dd000bb0001'],
+          [false,        ':dd000bb0001'],
+          [true,         'cc123bb1234'],
+          [false,        'aa123bb1234'],
+          [false,        'dd12bb1234'],
+          [false,        'dd1234bb1234'],
+          [false,        'dd123bb123'],
+          [false,        'dd123bb12345'],
+          [false,        'd123bb1234'],
+          [false,        'ddd123bb1234'],
+          [false,        'dd123b1234'],
+          [false,        'dd123bbb1234'],
+          [false,        'druid:bz918BZ9381'.upcase],
+          [true,         'druid:bz918BZ9381'.downcase],
+          [false,        'druid:az918AZ9381'.downcase],
+          [true,         'druid:zz943vx1492']
+        ]
+        tests.each do |exp, dru|
+          expect(described_class.valid?(dru, true)).to eq(exp)
+        end
+      end
+    end
+  end
+
+  it '#druid provides the full druid including the prefix' do
+    expect(described_class.new('druid:cd456ef7890', fixture_dir).druid).to eq('druid:cd456ef7890')
+    expect(described_class.new('cd456ef7890', fixture_dir).druid).to eq('druid:cd456ef7890')
+  end
+
+  it '#id extracts the ID from the stem' do
+    expect(described_class.new('druid:cd456ef7890', fixture_dir).id).to eq('cd456ef7890')
+    expect(described_class.new('cd456ef7890', fixture_dir).id).to eq('cd456ef7890')
+  end
+
+  describe '#new' do
+    it 'raises exception if the druid is invalid' do
+      expect { described_class.new('nondruid:cd456ef7890', fixture_dir) }.to raise_error(ArgumentError)
+      expect { described_class.new('druid:cd4567ef890', fixture_dir) }.to raise_error(ArgumentError)
+    end
+    it 'takes strict argument' do
+      described_class.new(strictly_valid_druid_str, fixture_dir, true)
+      expect { described_class.new(druid_str, fixture_dir, true) }.to raise_error(ArgumentError)
+    end
+  end
+
+  it '#tree builds a druid tree from a druid' do
+    druid = described_class.new(druid_str, fixture_dir)
+    expect(druid.tree).to eq(%w[cd 456 ef 7890 cd456ef7890])
+    expect(druid.path).to eq(tree1)
+  end
+
+  it '#mkdir, #rmdir create and destroy druid directories' do
+    expect(File.exist?(tree1)).to eq false
+    expect(File.exist?(tree2)).to eq false
+
+    druid1 = described_class.new(druid_str, fixture_dir)
+    druid2 = described_class.new(strictly_valid_druid_str, fixture_dir)
+
+    druid1.mkdir
+    expect(File.exist?(tree1)).to eq true
+    expect(File.exist?(tree2)).to eq false
+
+    druid2.mkdir
+    expect(File.exist?(tree1)).to eq true
+    expect(File.exist?(tree2)).to eq true
+
+    druid2.rmdir
+    expect(File.exist?(tree1)).to eq true
+    expect(File.exist?(tree2)).to eq false
+
+    druid1.rmdir
+    expect(File.exist?(tree1)).to eq false
+    expect(File.exist?(tree2)).to eq false
+    expect(File.exist?(File.join(fixture_dir, 'cd'))).to eq false
+  end
+
+  describe 'alternate prefixes' do
+    before :all do
+      described_class.prefix = 'sulair'
+    end
+
+    after :all do
+      described_class.prefix = 'druid'
+    end
+
+    it 'handles alternate prefixes' do
+      expect { described_class.new('druid:cd456ef7890', fixture_dir) }.to raise_error(ArgumentError)
+      expect(described_class.new('sulair:cd456ef7890', fixture_dir).id).to eq('cd456ef7890')
+      expect(described_class.new('cd456ef7890', fixture_dir).druid).to eq('sulair:cd456ef7890')
+    end
+  end
+
+  describe 'content directories' do
+    it 'knows where its content goes' do
+      druid = described_class.new(druid_str, fixture_dir)
+      expect(druid.content_dir(false)).to eq(File.join(tree1, 'content'))
+      expect(druid.metadata_dir(false)).to eq(File.join(tree1, 'metadata'))
+      expect(druid.temp_dir(false)).to eq(File.join(tree1, 'temp'))
+
+      expect(File.exist?(File.join(tree1, 'content'))).to eq false
+      expect(File.exist?(File.join(tree1, 'metadata'))).to eq false
+      expect(File.exist?(File.join(tree1, 'temp'))).to eq false
+    end
+
+    it 'creates its content directories on the fly' do
+      druid = described_class.new(druid_str, fixture_dir)
+      expect(druid.content_dir).to eq(File.join(tree1, 'content'))
+      expect(druid.metadata_dir).to eq(File.join(tree1, 'metadata'))
+      expect(druid.temp_dir).to eq(File.join(tree1, 'temp'))
+
+      expect(File.exist?(File.join(tree1, 'content'))).to eq true
+      expect(File.exist?(File.join(tree1, 'metadata'))).to eq true
+      expect(File.exist?(File.join(tree1, 'temp'))).to eq true
+    end
+
+    it 'matches glob' do
+      druid = described_class.new(druid_str, fixture_dir)
+      druid.mkdir
+      expect(Dir.glob(File.join(File.dirname(druid.path), described_class.glob)).size).to eq(1)
+    end
+    it 'matches strict_glob' do
+      druid = described_class.new(druid_str, fixture_dir)
+      druid.mkdir
+      expect(Dir.glob(File.join(File.dirname(druid.path), described_class.strict_glob)).size).to eq(0)
+      druid = described_class.new(strictly_valid_druid_str, fixture_dir)
+      druid.mkdir
+      expect(Dir.glob(File.join(File.dirname(druid.path), described_class.strict_glob)).size).to eq(1)
+    end
+  end
+
+  describe 'content discovery' do
+    let(:druid) { described_class.new(druid_str, fixture_dir) }
+    let(:filelist) { %w[1 2 3 4].collect { |num| "someFile#{num}" } }
+
+    it 'finds content in content directories' do
+      location = druid.content_dir
+      File.open(File.join(location, 'someContent'), 'w') { |f| f.write 'This is the content' }
+      expect(druid.find_content('someContent')).to eq(File.join(location, 'someContent'))
+    end
+
+    it 'finds content in the root directory' do
+      location = druid.path(nil, true)
+      File.open(File.join(location, 'someContent'), 'w') { |f| f.write 'This is the content' }
+      expect(druid.find_content('someContent')).to eq(File.join(location, 'someContent'))
+    end
+
+    it 'finds content in the leaf directory' do
+      location = File.expand_path('..', druid.path(nil, true))
+      File.open(File.join(location, 'someContent'), 'w') { |f| f.write 'This is the content' }
+      expect(druid.find_content('someContent')).to eq(File.join(location, 'someContent'))
+    end
+
+    it 'does not find content in the wrong content directory' do
+      location = druid.metadata_dir
+      File.open(File.join(location, 'someContent'), 'w') { |f| f.write 'This is the content' }
+      expect(druid.find_content('someContent')).to be_nil
+    end
+
+    it 'does not find content in a higher-up directory' do
+      location = File.expand_path('../..', druid.path(nil, true))
+      File.open(File.join(location, 'someContent'), 'w') { |f| f.write 'This is the content' }
+      expect(druid.find_content('someContent')).to be_nil
+    end
+
+    it 'finds a filelist in the content directory' do
+      location = Pathname(druid.content_dir)
+      filelist.each do |filename|
+        location.join(filename).open('w') { |f| f.write "This is #{filename}" }
+      end
+      expect(druid.find_filelist_parent('content', filelist)).to eq(location)
+    end
+
+    it 'finds a filelist in the root directory' do
+      location = Pathname(druid.path(nil, true))
+      filelist.each do |filename|
+        location.join(filename).open('w') { |f| f.write "This is #{filename}" }
+      end
+      expect(druid.find_filelist_parent('content', filelist)).to eq(location)
+    end
+
+    it 'finds a filelist in the leaf directory' do
+      location = Pathname(File.expand_path('..', druid.path(nil, true)))
+      filelist.each do |filename|
+        location.join(filename).open('w') { |f| f.write "This is #{filename}" }
+      end
+      expect(druid.find_filelist_parent('content', filelist)).to eq(location)
+    end
+
+    it 'raises an exception if the first file in the filelist is not found' do
+      Pathname(druid.content_dir)
+      expect { druid.find_filelist_parent('content', filelist) }.to raise_exception(/content dir not found for 'someFile1' when searching/)
+    end
+
+    it 'raises an exception if any other file in the filelist is not found' do
+      location = Pathname(druid.content_dir)
+      location.join(filelist.first).open('w') { |f| f.write "This is #{filelist.first}" }
+      expect { druid.find_filelist_parent('content', filelist) }.to raise_exception(/File 'someFile2' not found/)
+    end
+  end
+
+  describe '#mkdir error handling' do
+    it 'raises SameContentExistsError if the directory already exists' do
+      druid_obj = described_class.new(strictly_valid_druid_str, fixture_dir)
+      druid_obj.mkdir
+      expect { druid_obj.mkdir }.to raise_error(DruidTools::SameContentExistsError)
+    end
+
+    it 'raises DifferentContentExistsError if a link already exists in the workspace for this druid' do
+      source_dir = '/tmp/content_dir'
+      FileUtils.mkdir_p(source_dir)
+      dr = described_class.new(strictly_valid_druid_str, fixture_dir)
+      dr.mkdir_with_final_link(source_dir)
+      expect { dr.mkdir }.to raise_error(DruidTools::DifferentContentExistsError)
+    end
+  end
+
+  describe '#mkdir_with_final_link' do
+    let(:source_dir) { '/tmp/content_dir' }
+    let(:druid_obj) { described_class.new(strictly_valid_druid_str, fixture_dir) }
+
+    before do
+      FileUtils.mkdir_p(source_dir)
+    end
+
+    it 'creates a druid tree in the workspace with the final directory being a link to the passed in source' do
+      druid_obj.mkdir_with_final_link(source_dir)
+      expect(File).to be_symlink(druid_obj.path)
+      expect(File.readlink(tree2)).to eq(source_dir)
+    end
+
+    it 'does not error out if the link to source already exists' do
+      druid_obj.mkdir_with_final_link(source_dir)
+      expect(File).to be_symlink(druid_obj.path)
+      expect(File.readlink(tree2)).to eq(source_dir)
+    end
+
+    it 'raises DifferentContentExistsError if a directory already exists in the workspace for this druid' do
+      druid_obj.mkdir(fixture_dir)
+      expect { druid_obj.mkdir_with_final_link(source_dir) }.to raise_error(DruidTools::DifferentContentExistsError)
+    end
+  end
+
+  describe '#prune!' do
+    let(:workspace) { Dir.mktmpdir }
+    let(:dr1) { described_class.new(druid_str, workspace) }
+    let(:dr2) { described_class.new(strictly_valid_druid_str, workspace) }
+    let(:pathname1) { dr1.pathname }
+
+    after do
+      FileUtils.remove_entry workspace
+    end
+
+    context 'when there is a shared ancestor' do
+      before do
+        # Nil the create records for this context because we're in a known read only one
+        dr1.mkdir
+        dr2.mkdir
+        dr1.prune!
+      end
+
+      it 'deletes the outermost directory' do
+        expect(File).not_to exist(dr1.path)
+      end
+
+      it 'deletes empty ancestor directories' do
+        expect(File).not_to exist(pathname1.parent)
+        expect(File).not_to exist(pathname1.parent.parent)
+      end
+
+      it 'stops at ancestor directories that have children' do
+        # 'cd/456' should still exist because of druid2
+        shared_ancestor = pathname1.parent.parent.parent
+        expect(shared_ancestor.to_s).to match(%r{cd/456$})
+        expect(File).to exist(shared_ancestor)
+      end
+    end
+
+    it 'removes all directories up to the base path when there are no common ancestors' do
+      # Nil the create records for this test
+      dr1.mkdir
+      dr1.prune!
+      expect(File).not_to exist(File.join(workspace, 'cd'))
+      expect(File).to exist(workspace)
+    end
+
+    it 'removes directories with symlinks' do
+      # Nil the create records for this test
+      source_dir = File.join workspace, 'src_dir'
+      FileUtils.mkdir_p(source_dir)
+      dr2.mkdir_with_final_link(source_dir)
+      dr2.prune!
+      expect(File).not_to exist(dr2.path)
+      expect(File).not_to exist(File.join(workspace, 'cd'))
+    end
+  end
+end