druid-tools 1.0.0 → 2.2.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']
@@ -7,18 +7,21 @@ Gem::Specification.new do |gem|
   gem.summary       = 'Tools to manipulate DRUID trees and content directories'
   gem.homepage      = 'http://github.com/sul-dlss/druid-tools'
   gem.licenses      = ['ALv2', 'Stanford University Libraries']
-  gem.has_rdoc      = true
+  gem.metadata['rubygems_mfa_required'] = 'true'
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.required_ruby_version = '>= 3.0'
+
+  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_dependency 'deprecation'
+  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'
+  gem.add_development_dependency 'rubocop-rspec'
 end

data/lib/druid-tools.rb

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

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,17 @@ 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
 
+    def pruning_base
+      pathname
+    end
   end
 
   PurlDruid = AccessDruid
   StacksDruid = AccessDruid
-
 end

data/lib/druid_tools/druid.rb

@@ -1,99 +1,112 @@
+# frozen_string_literal: true
+
 require 'pathname'
 require 'fileutils'
+require 'deprecation'
 
 module DruidTools
   class Druid
-    @@deletes_directory_name = '.deletes'
+    extend Deprecation
+    self.deprecation_horizon = 'druid-tools 3.0.0'
+
     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
-        def #{dir_type}_dir(create=true)
-          path("#{dir_type}",create)
-        end
+    def content_dir(create = true)
+      path('content', create)
+    end
 
-        def find_#{dir_type}(path)
-          find(:#{dir_type},path)
-        end
-      EOC
+    def metadata_dir(create = true)
+      path('metadata', create)
+    end
+
+    def temp_dir(create = true)
+      path('temp', create)
+    end
+
+    def find_content(path)
+      find(:content, path)
+    end
+
+    def find_metadata(path)
+      find(:metadata, path)
+    end
+
+    def find_temp(path)
+      find(:temp, path)
     end
 
     # @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
     end
 
     def id
-      @druid.scan(self.class.pattern).flatten.join('')
+      @druid.scan(self.class.pattern).flatten.join
     end
 
     def tree
       @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 +114,39 @@ 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
+    deprecation_deprecate :mkdir_with_final_link
 
-    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
@@ -137,98 +154,35 @@ module DruidTools
         parts.pop
       end
     end
+    deprecation_deprecate :rmdir
 
     def pathname
-      Pathname self.path
+      Pathname path
     end
 
     def base_pathname
-      Pathname self.base
-    end
-
-    def prune!
-      this_path = pathname
-      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))
+      Pathname base
     end
 
-    def deletes_record_pathname
-      return Pathname(deletes_dir_pathname.to_s + File::SEPARATOR + self.id)
+    def pruning_base
+      pathname.parent
     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)
+    def prune!
+      pruning_base.rmtree if pruning_base.exist? && pruning_base != base_pathname
+      prune_ancestors pruning_base.parent
     end
+    deprecation_deprecate :prune!
 
     # @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
-
+    deprecation_deprecate :prune_ancestors
   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/lib/druid_tools.rb

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

data/spec/druid_tools/purl_druid_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe DruidTools::PurlDruid do
+  let(:purl_root) { Dir.mktmpdir }
+
+  let(:druid) { described_class.new druid_str, purl_root }
+  let(:druid_str) { 'druid:cd456ef7890' }
+
+  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 '#pruning_base' do
+    subject(:path) { described_class.new(druid_str).pruning_base }
+
+    it { is_expected.to eq(Pathname.new('./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