dor-services 5.2.0 → 5.3.0

data/lib/dor/services/search_service.rb

@@ -2,7 +2,6 @@ require 'json'
 require 'active_support/core_ext'
 
 module Dor
-
   class SearchService
 
     RISEARCH_TEMPLATE = "select $object from <#ri> where $object <dc:identifier> '%s'"
@@ -27,19 +26,19 @@ module Dor
         client = Config.fedora.client['risearch']
         client.options[:timeout] = opts.delete(:timeout)
         query_params = {
-          :type => 'tuples',
-          :lang => 'itql',
+          :type   => 'tuples',
+          :lang   => 'itql',
           :format => 'CSV',
-          :limit => '1000',
+          :limit  => '1000',
           :stream => 'on',
-          :query => query
+          :query  => query
         }.merge(opts)
         result = client.post(query_params)
-        result.split(/\n/)[1..-1].collect { |pid| pid.chomp.sub(/^info:fedora\//,'') }
+        result.split(/\n/)[1..-1].collect { |pid| pid.chomp.sub(/^info:fedora\//, '') }
       end
 
       def iterate_over_pids(opts = {}, &block)
-        opts[:query] ||= "select $object from <#ri> where $object <info:fedora/fedora-system:def/model#label> $label"
+        opts[:query] ||= 'select $object from <#ri> where $object <info:fedora/fedora-system:def/model#label> $label'
         opts[:in_groups_of] ||= 100
         opts[:mode] ||= :single
         start = 0
@@ -58,30 +57,27 @@ module Dor
       def gsearch(params)
         client = Config.gsearch.client
         query_params = params.merge(:wt => 'json')
-        query_string = query_params.collect { |k,v|
+        query_string = query_params.collect { |k, v|
           if v.is_a?(Array)
             v.collect { |vv| "#{k}=#{URI.encode(vv.to_s)}" }.join('&')
           else
             "#{k}=#{URI.encode(v.to_s)}"
           end
         }.join('&')
-        result = JSON.parse(client["select?#{query_string}"].get)
+        JSON.parse(client["select?#{query_string}"].get)
       end
 
-      def query query, args={}
+      def query(query, args = {})
         params = args.merge({ :q => query })
         params[:start] ||= 0
         resp = solr.find params
-        if block_given?
-          cont = true
-          while cont && resp.docs.length > 0
-            cont = yield(resp)
-            params[:rows] ||= resp.docs.length
-            params[:start] += params[:rows]
-            resp = solr.find params
-          end
-        else
-          return resp
+        return resp unless block_given?
+        cont = true
+        while cont && resp.docs.length > 0
+          cont = yield(resp)
+          params[:rows] ||= resp.docs.length
+          params[:start] += params[:rows]
+          resp = solr.find params
         end
       end
 
@@ -91,9 +87,9 @@ module Dor
         elsif id.is_a?(Array) # Two values: [ 'google', 'STANFORD_0123456789' ]
           id = id.join(':')
         end
-        q = %{#{Solrizer.solr_name 'identifier', :stored_searchable}:"#{id}"}
+        q = %(#{Solrizer.solr_name 'identifier', :stored_searchable}:"#{id}")
         result = []
-        resp = query(q, :fl => 'id', :rows => 1000) do |resp|
+        query(q, :fl => 'id', :rows => 1000) do |resp|
           result += resp.docs.collect { |doc| doc['id'] }
           true
         end
@@ -122,5 +118,4 @@ module Dor
     end
 
   end
-
 end

data/lib/dor/services/suri_service.rb

@@ -6,12 +6,12 @@ module Dor
     # If Dor::Config.suri.mint_ids is set to true, then this method
     # returns Config.suri.id_namespace:id_from_suri
     # Throws an exception if there were any problems
-    def self.mint_id quantity=nil
+    def self.mint_id(quantity = nil)
       want_array = quantity.is_a?(Numeric)
       quantity = 1 if quantity.nil?
       ids = []
       if Config.suri.mint_ids
-        #Post with no body
+        # Post with no body
         resource = RestClient::Resource.new("#{Config.suri.url}/suri2/namespaces/#{Config.suri.id_namespace}",
                                   :user => Config.suri.user, :password => Config.suri.pass)
         ids = resource["identifiers?quantity=#{quantity}"].post('').chomp.split(/\n/).collect { |id| "#{Config.suri.id_namespace}:#{id.strip}" }
@@ -20,11 +20,11 @@ module Dor
         resp = Nokogiri::XML(repo.next_pid :numPIDs => quantity)
         ids = resp.xpath('/pidList/pid').collect { |node| node.text }
       end
-      return want_array ? ids : ids.first
+      want_array ? ids : ids.first
 
-#    rescue Exception => e
-#      Rails.logger.error("Unable to mint id from suri: #{e.to_s}")
-#      raise e
+      # rescue Exception => e
+      #   Rails.logger.error("Unable to mint id from suri: #{e.to_s}")
+      #   raise e
     end
 
   end

data/lib/dor/services/technical_metadata_service.rb

@@ -4,7 +4,6 @@ require 'jhove_service'
 require 'dor-services'
 
 module Dor
-
   class TechnicalMetadataService
 
     # @param [Dor::Item] dor_item The DOR item being processed by the technical metadata robot
@@ -25,9 +24,9 @@ module Dor
         return true
       else
         merged_nodes = merge_file_nodes(old_techmd, new_techmd, deltas)
-        final_techmd = build_technical_metadata(druid,merged_nodes)
+        final_techmd = build_technical_metadata(druid, merged_nodes)
       end
-      ds = dor_item.datastreams["technicalMetadata"]
+      ds = dor_item.datastreams['technicalMetadata']
       ds.dsLabel = 'Technical Metadata'
       ds.content = final_techmd
       ds.save
@@ -41,7 +40,7 @@ module Dor
           require 'jhove_service'
         rescue LoadError => e
           puts e.inspect
-          raise "jhove-service dependency gem was not found.  Please add it to your Gemfile and run bundle install"
+          raise 'jhove-service dependency gem was not found.  Please add it to your Gemfile and run bundle install'
         end
       end
     end
@@ -51,15 +50,13 @@ module Dor
     def self.get_content_group_diff(dor_item)
       inventory_diff_xml = dor_item.get_content_diff('all')
       inventory_diff = Moab::FileInventoryDifference.parse(inventory_diff_xml)
-      content_group_diff = inventory_diff.group_difference("content")
-      content_group_diff
+      inventory_diff.group_difference('content')
     end
 
     # @param [FileGroupDifference] content_group_diff
     # @return [Hash<Symbol,Array>] Sets of filenames grouped by change type for use in performing file or metadata operations
     def self.get_file_deltas(content_group_diff)
-      deltas = content_group_diff.file_deltas
-      deltas
+      content_group_diff.file_deltas
     end
 
     # @param [Hash<Symbol,Array>] deltas Sets of filenames grouped by change type for use in performing file or metadata operations
@@ -81,36 +78,25 @@ module Dor
     #   The data is updated to the latest format.
     def self.get_sdr_technical_metadata(druid)
       begin
-        sdr_techmd = get_sdr_metadata(druid, "technicalMetadata")
-      rescue RestClient::ResourceNotFound => e
-        return nil
-      end
-      if sdr_techmd =~ /<technicalMetadata/
-        return sdr_techmd
-      elsif sdr_techmd =~ /<jhove/
-        return ::JhoveService.new.upgrade_technical_metadata(sdr_techmd)
-      else
+        sdr_techmd = get_sdr_metadata(druid, 'technicalMetadata')
+      rescue RestClient::ResourceNotFound
         return nil
       end
+      return sdr_techmd if sdr_techmd =~ /<technicalMetadata/
+      return ::JhoveService.new.upgrade_technical_metadata(sdr_techmd) if sdr_techmd =~ /<jhove/
+      nil
     end
 
     # @param [Dor::Item] dor_item The DOR item being processed by the technical metadata robot
     # @return [String] The technicalMetadata datastream from the previous version of the digital object (fetched from DOR fedora).
     #   The data is updated to the latest format.
     def self.get_dor_technical_metadata(dor_item)
-      ds = "technicalMetadata"
-      if dor_item.datastreams.keys.include?(ds) && !dor_item.datastreams[ds].new?
-        dor_techmd = dor_item.datastreams[ds].content
-      else
-        return nil
-      end
-      if dor_techmd =~ /<technicalMetadata/
-        return dor_techmd
-      elsif dor_techmd =~ /<jhove/
-        return ::JhoveService.new.upgrade_technical_metadata(dor_techmd)
-      else
-        return nil
-      end
+      ds = 'technicalMetadata'
+      return nil unless dor_item.datastreams.keys.include?(ds) && !dor_item.datastreams[ds].new?
+      dor_techmd = dor_item.datastreams[ds].content
+      return dor_techmd if dor_techmd =~ /<technicalMetadata/
+      return ::JhoveService.new.upgrade_technical_metadata(dor_techmd) if dor_techmd =~ /<jhove/
+      nil
     end
 
     # @param [String] druid The identifier of the digital object being processed by the technical metadata robot
@@ -119,8 +105,7 @@ module Dor
     def self.get_sdr_metadata(druid, dsname)
       sdr_client = Dor::Config.sdr.rest_client
       url = "objects/#{druid}/metadata/#{dsname}.xml"
-      response = sdr_client[url].get
-      response
+      sdr_client[url].get
     end
 
     # @param [DruidTools::Druid] druid A wrapper class for the druid identifier.  Used to generate paths
@@ -129,10 +114,10 @@ module Dor
     def self.get_new_technical_metadata(druid, new_files)
       return nil if new_files.nil? || new_files.empty?
       workspace = DruidTools::Druid.new(druid, Dor::Config.sdr.local_workspace_root)
-      content_dir = workspace.find_filelist_parent('content',new_files)
+      content_dir = workspace.find_filelist_parent('content', new_files)
       temp_dir = workspace.temp_dir
       jhove_service = ::JhoveService.new(temp_dir)
-      jhove_service.digital_object_id=druid
+      jhove_service.digital_object_id = druid
       fileset_file = write_fileset(temp_dir, new_files)
       jhove_output_file = jhove_service.run_jhove(content_dir, fileset_file)
       tech_md_file = jhove_service.create_technical_metadata(jhove_output_file)
@@ -155,7 +140,7 @@ module Dor
     def self.merge_file_nodes(old_techmd, new_techmd, deltas)
       old_file_nodes = get_file_nodes(old_techmd)
       new_file_nodes = get_file_nodes(new_techmd)
-      merged_nodes = Hash.new
+      merged_nodes = {}
       deltas[:identical].each do |path|
         merged_nodes[path] = old_file_nodes[path]
       end
@@ -165,12 +150,12 @@ module Dor
       deltas[:added].each do |path|
         merged_nodes[path] = new_file_nodes[path]
       end
-      deltas[:renamed].each do |oldpath,newpath|
+      deltas[:renamed].each do |oldpath, newpath|
         clone = old_file_nodes[oldpath].clone
         clone.sub!(/<file\s*id.*?["'].*?["'].*?>/, "<file id='#{newpath}'>")
         merged_nodes[newpath] = clone
       end
-      deltas[:copyadded].each do |oldpath,newpath|
+      deltas[:copyadded].each do |oldpath, newpath|
         clone = old_file_nodes[oldpath].clone
         clone.sub!(/<file\s*id.*?["'].*?["'].*?>/, "<file id='#{newpath}'>")
         merged_nodes[newpath] = clone
@@ -179,11 +164,11 @@ module Dor
     end
 
     # @param [String] technical_metadata A technicalMetadata datastream contents
-    # @return [Hash<String,Nokogiri::XML::Node>] The set of nodes from a technicalMetadata datastream , indexed by filename
+    # @return [Hash<String,Nokogiri::XML::Node>] The set of nodes from a technicalMetadata datastream, indexed by filename
     def self.get_file_nodes(technical_metadata)
-      file_hash = Hash.new
+      file_hash = {}
       return file_hash if technical_metadata.nil?
-      current_file = Array.new
+      current_file = []
       path = nil
       in_file = false
       technical_metadata.each_line do |line|
@@ -194,7 +179,7 @@ module Dor
         elsif line =~ /^\s*<\/file>/
           current_file << line
           file_hash[path] = current_file.join
-          current_file = Array.new
+          current_file = []
           path = nil
           in_file = false
         elsif in_file
@@ -216,10 +201,8 @@ module Dor
       EOF
       doc = techmd_root
       merged_nodes.keys.sort.each {|path| doc << merged_nodes[path] }
-      doc << "</technicalMetadata>"
-      doc
+      doc + '</technicalMetadata>'
     end
 
   end
-
 end

data/lib/dor/utils/ng_tidy.rb

@@ -1,11 +1,11 @@
 class Nokogiri::XML::Text
 
   def normalize
-    self.content =~ /\S/ ? self.content.gsub(/\s+/,' ').strip : self.content
+    content =~ /\S/ ? content.gsub(/\s+/, ' ').strip : content
   end
 
   def normalize!
-    self.content = self.normalize
+    self.content = normalize
   end
 
 end
@@ -13,7 +13,7 @@ end
 class Nokogiri::XML::Node
 
   def normalize_text!
-    self.xpath('//text()').each { |t| t.normalize! }
+    xpath('//text()').each { |t| t.normalize! }
   end
 
 end

data/lib/dor/utils/sdr_client.rb

@@ -1,11 +1,10 @@
 module Sdr
-
   module Client
     class << self
 
       # @param [String] druid id of the object you want the version of
       # @return [Integer] the current version from SDR
-      def current_version druid
+      def current_version(druid)
         sdr_client = Dor::Config.sdr.rest_client
         xml = sdr_client["objects/#{druid}/current_version"].get
 
@@ -13,7 +12,7 @@ module Sdr
           doc = Nokogiri::XML xml
           raise if doc.root.name != 'currentVersion'
           return Integer(doc.text)
-        rescue => e
+        rescue
           raise "Unable to parse XML from SDR current_version API call: #{xml}"
         end
       end

data/lib/dor/utils/solr_doc_helper.rb

@@ -1,7 +1,6 @@
 module SolrDocHelper
-
   def add_solr_value(solr_doc, field_name, value, field_type = :default, index_types = [:searchable])
-    if Solrizer::VERSION > "3"
+    if Solrizer::VERSION > '3'
       case field_type
         when :symbol
           index_types << field_type
@@ -13,5 +12,4 @@ module SolrDocHelper
       }
     end
   end
-
 end

data/lib/dor/version.rb

@@ -1,3 +1,3 @@
 module Dor
-  VERSION = '5.2.0'
+  VERSION = '5.3.0'
 end

data/lib/dor/workflow/document.rb

@@ -6,23 +6,26 @@ module Workflow
 
     set_terminology do |t|
       t.root(:path => 'workflow')
-      t.repository(:path=>{:attribute => "repository"})
-      t.workflowId(:path=>{:attribute => "id"})
+      t.repository(:path => {:attribute => 'repository'})
+      t.workflowId(:path => {:attribute => 'id'})
       t.process {
-        t.name_(:path=>{:attribute=>"name"})
-        t.status(:path=>{:attribute=>"status"})
-        t.timestamp(:path=>{:attribute=>"datetime"}) #, :data_type => :date)
-        t.elapsed(:path=>{:attribute=>"elapsed"})
-        t.lifecycle(:path=>{:attribute=>"lifecycle"})
-        t.attempts(:path=>{:attribute=>"attempts"}, :index_as => [:not_searchable])
-        t.version(:path=>{:attribute=>"version"})
+        t.name_(:path => {:attribute => 'name'})
+        t.status(:path => {:attribute => 'status'})
+        t.timestamp(:path => {:attribute => 'datetime'}) # , :data_type => :date)
+        t.elapsed(:path => {:attribute => 'elapsed'})
+        t.lifecycle(:path => {:attribute => 'lifecycle'})
+        t.attempts(:path => {:attribute => 'attempts'}, :index_as => [:not_searchable])
+        t.version(:path => {:attribute => 'version'})
       }
     end
-    @@definitions={}
-    def initialize node
+
+    @@definitions = {}
+
+    def initialize(node)
       self.ng_xml = Nokogiri::XML(node)
     end
-    #is this an incomplete workflow with steps that have a priority > 0
+
+    # is this an incomplete workflow with steps that have a priority > 0
     def expedited?
       processes.any? { |proc| !proc.completed? && proc.priority.to_i > 0 }
     end
@@ -34,75 +37,75 @@ module Workflow
 
     # @return [Boolean] if any process node does not have version, returns true, false otherwise (all processes have version)
     def active?
-      ng_xml.at_xpath("/workflow/process[not(@version)]") ? true : false
+      ng_xml.at_xpath('/workflow/process[not(@version)]') ? true : false
     end
 
     def definition
       @definition ||= begin
-        if @@definitions.key? self.workflowId.first
-          @@definitions[self.workflowId.first]
+        if @@definitions.key? workflowId.first
+          @@definitions[workflowId.first]
         else
-          wfo = Dor::WorkflowObject.find_by_name(self.workflowId.first)
-          wf_def=wfo ? wfo.definition : nil
-          @@definitions[self.workflowId.first] = wf_def
+          wfo = Dor::WorkflowObject.find_by_name(workflowId.first)
+          wf_def = wfo ? wfo.definition : nil
+          @@definitions[workflowId.first] = wf_def
           wf_def
         end
       end
     end
 
-    def graph(parent=nil, dir=nil)
-      wf_definition = self.definition
-      result = wf_definition ? Workflow::Graph.from_processes(wf_definition.repo, wf_definition.name, self.processes, parent) : nil
+    def graph(parent = nil, dir = nil)
+      wf_definition = definition
+      result = wf_definition ? Workflow::Graph.from_processes(wf_definition.repo, wf_definition.name, processes, parent) : nil
       result['rankdir'] = dir || 'TB' unless result.nil?
       result
     end
 
     def [](value)
-      self.processes.find { |p| p.name == value }
+      processes.find { |p| p.name == value }
     end
 
     def processes
-      #if the workflow service didnt return any processes, dont return any processes from the reified wf
-      return [] if ng_xml.search("/workflow/process").length == 0
+      # if the workflow service didnt return any processes, dont return any processes from the reified wf
+      return [] if ng_xml.search('/workflow/process').length == 0
       @processes ||=
-      if self.definition
-        self.definition.processes.collect do |process|
+      if definition
+        definition.processes.collect do |process|
           node = ng_xml.at("/workflow/process[@name = '#{process.name}']")
-          process.update!(node,self) unless node.nil?
+          process.update!(node, self) unless node.nil?
           process
         end
       else
-        self.find_by_terms(:workflow, :process).collect do |x|
-          pnode = Dor::Workflow::Process.new(self.repository, self.workflowId, {})
-          pnode.update!(x,self)
+        find_by_terms(:workflow, :process).collect do |x|
+          pnode = Dor::Workflow::Process.new(repository, workflowId, {})
+          pnode.update!(x, self)
           pnode
         end.sort_by(&:datetime)
       end
     end
 
-    def workflow_should_show_completed? processes
-      return processes.all?{|p| ['skipped', 'completed', '', nil].include?(p.status)}
+    def workflow_should_show_completed?(processes)
+      processes.all? {|p| ['skipped', 'completed', '', nil].include?(p.status)}
     end
 
-    def to_solr(solr_doc=Hash.new, *args)
-      wf_name = self.workflowId.first
-      repo = self.repository.first
+    def to_solr(solr_doc = {}, *args)
+      wf_name = workflowId.first
+      repo = repository.first
       wf_solr_type = :string
       wf_solr_attrs = [:symbol]
       add_solr_value(solr_doc, 'wf',     wf_name, wf_solr_type, wf_solr_attrs)
       add_solr_value(solr_doc, 'wf_wps', wf_name, wf_solr_type, wf_solr_attrs)
       add_solr_value(solr_doc, 'wf_wsp', wf_name, wf_solr_type, wf_solr_attrs)
       status = processes.empty? ? 'empty' : (workflow_should_show_completed?(processes) ? 'completed' : 'active')
-      errors = processes.select(&:error?).count
-      add_solr_value(solr_doc, 'workflow_status', [wf_name,status,errors,repo].join('|'), wf_solr_type, wf_solr_attrs)
+      errors = processes.count(&:error?)
+      add_solr_value(solr_doc, 'workflow_status', [wf_name, status, errors, repo].join('|'), wf_solr_type, wf_solr_attrs)
 
       processes.each do |process|
         next unless process.status.present?
-        #add a record of the robot having operated on this item, so we can track robot activity
+        # add a record of the robot having operated on this item, so we can track robot activity
         if process.date_time && process.status && (process.status == 'completed' || process.status == 'error')
           solr_doc["wf_#{wf_name}_#{process.name}_dttsi"] = "#{process.date_time}Z"
         end
-        add_solr_value(solr_doc, 'wf_error', "#{wf_name}:#{process.name}:#{process.error_message}", wf_solr_type, wf_solr_attrs) if process.error_message #index the error message without the druid so we hopefully get some overlap
+        add_solr_value(solr_doc, 'wf_error', "#{wf_name}:#{process.name}:#{process.error_message}", wf_solr_type, wf_solr_attrs) if process.error_message # index the error message without the druid so we hopefully get some overlap
         add_solr_value(solr_doc, 'wf_wsp', "#{wf_name}:#{process.status}", wf_solr_type, wf_solr_attrs)
         add_solr_value(solr_doc, 'wf_wsp', "#{wf_name}:#{process.status}:#{process.name}", wf_solr_type, wf_solr_attrs)
         add_solr_value(solr_doc, 'wf_wps', "#{wf_name}:#{process.name}", wf_solr_type, wf_solr_attrs)
@@ -127,7 +130,7 @@ module Workflow
     end
 
     def inspect
-      "#<#{self.class.name}:#{self.object_id}>"
+      "#<#{self.class.name}:#{object_id}>"
     end
   end
 end