3526

pending completion

Build # 3526

Build Type

push

travis-ci

Committed by

jcoyne

Commit Message

<a href="https://github.com/sul-dlss/dor-services/commit/<a class=hub.com/sul-dlss/dor-services/commit/6c5228c12ae8a2778cb50882fb0909f3bbfc9311">6c5228c12<a href="https://github.com/sul-dlss/dor-services/commit/6c5228c12ae8a2778cb50882fb0909f3bbfc9311">">Revert part of </a><a class="double-link" href="https://github.com/sul-dlss/dor-services/commit/<a class="double-link" href="https://github.com/sul-dlss/dor-services/commit/0f93ec0ce20f666bcc2e8d29c94bf813229053a8">0f93ec0ce</a>">0f93ec0ce</a><a href="https://github.com/sul-dlss/dor-services/commit/6c5228c12ae8a2778cb50882fb0909f3bbfc9311">

This was causing versions to not be openable

Run Details

2286 of 2499 relevant lines covered (91.48%)

8.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.87

/lib/dor/datastreams/content_metadata_ds.rb

# frozen_string_literal: true

require 'set'

module Dor
  class ContentMetadataDS < ActiveFedora::OmDatastream
    set_terminology do |t|
      t.root        path: 'contentMetadata',          index_as: [:not_searchable]
      t.contentType path: '/contentMetadata/@type',   index_as: [:not_searchable]
      t.stacks      path: '/contentMetadata/@stacks', index_as: [:not_searchable]
      t.resource(index_as: [:not_searchable]) do
        t.id_       path: { attribute: 'id' }
        t.sequence  path: { attribute: 'sequence' } # , :data_type => :integer
        t.type_     path: { attribute: 'type' }, index_as: [:displayable]
        t.attribute(path: 'attr', index_as: [:not_searchable]) do
          t.name    path: { attribute: 'name' }, index_as: [:not_searchable]
        end
        t.file(index_as: [:not_searchable]) do
          t.id_      path: { attribute: 'id' }
          t.mimeType path: { attribute: 'mimeType' }, index_as: [:displayable]
          t.dataType path: { attribute: 'dataType' }, index_as: [:displayable]
          t.size     path: { attribute: 'size'     }, index_as: [:displayable]    # , :data_type => :long
          t.role     path: { attribute: 'role' },     index_as: [:not_searchable]
          t.shelve   path: { attribute: 'shelve'   }, index_as: [:not_searchable] # , :data_type => :boolean
          t.publish  path: { attribute: 'publish'  }, index_as: [:not_searchable] # , :data_type => :boolean
          t.preserve path: { attribute: 'preserve' }, index_as: [:not_searchable] # , :data_type => :boolean
          t.checksum do
            t.type_ path: { attribute: 'type' }
          end
        end
        t.shelved_file(path: 'file', attributes: { shelve: 'yes' }, index_as: [:not_searchable]) do
          t.id_ path: { attribute: 'id' }, index_as: %i[displayable stored_searchable]
        end
      end
      t.shelved_file_id proxy: %i[resource shelved_file id], index_as: %i[displayable stored_searchable]
    end

    ### READ ONLY METHODS

    # Only use this when you want the behavior of raising an exception if anything besides exactly one matching node
    # is found.  Otherwise just use .xpath, .at_xpath or .search.
    # @param xpath [String] accessor invocation for Nokogiri xpath
    # @return [Nokogiri::XML::Element] the matched element
    def singular_node(xpath)
      node = ng_xml.search(xpath)
      len  = node.length
      raise "#{xpath} not found" if len < 1
      raise "#{xpath} duplicated: #{len} found" if len != 1

      node.first
    end

    # Generates the XML tree for externalFile references. For example:
    #     <externalFile objectId="druid:mn123pq4567" resourceId="Image01" fileId="image_01.jp2000" mimetype="image/jp2" />
    # @param [String] objectId the linked druid
    # @param [String] resourceId the linked druid's resource identifier
    # @param [String] fileId the linked druid's resource's file identifier
    # @param [String] mimetype the file's MIME type
    # @return [Nokogiri::XML::Element]
    def generate_external_file_node(objectId, resourceId, fileId, mimetype)
      externalFile = ng_xml.create_element 'externalFile'
      externalFile[:objectId]   = objectId
      externalFile[:resourceId] = resourceId
      externalFile[:fileId]     = fileId
      externalFile[:mimetype]   = mimetype
      externalFile
    end

    # Generates the XML tree for virtual resource relationship reference. For example:
    #   <relationship type="alsoAvailableAs" objectId="druid:mn123pq4567" />
    # @param [String] objectId the linked druid
    # @return [Nokogiri::XML::Element]
    def generate_also_available_as_node(objectId)
      relationship = ng_xml.create_element 'relationship'
      relationship[:type] = 'alsoAvailableAs'
      relationship[:objectId] = objectId
      relationship
    end

    # Terminology-based solrization is going to be painfully slow for large
    # contentMetadata streams. Just select the relevant elements instead.
    # TODO: Call super()?
    def to_solr(solr_doc = {}, *_args)
      doc = ng_xml
      return solr_doc unless doc.root['type']

      preserved_size = 0
      shelved_size = 0
      counts = Hash.new(0)                # default count is zero
      resource_type_counts = Hash.new(0)  # default count is zero
      file_roles = ::Set.new
      mime_types = ::Set.new
      first_shelved_image = nil

      doc.xpath('contentMetadata/resource').sort { |a, b| a['sequence'].to_i <=> b['sequence'].to_i }.each do |resource|
        counts['resource'] += 1
        resource_type_counts[resource['type']] += 1 if resource['type']
        resource.xpath('file').each do |file|
          counts['content_file'] += 1
          preserved_size += file['size'].to_i if file['preserve'] == 'yes'
          shelved_size += file['size'].to_i if file['shelve'] == 'yes'
          if file['shelve'] == 'yes'
            counts['shelved_file'] += 1
            first_shelved_image ||= file['id'] if file['id'] =~ /jp2$/
          end
          mime_types << file['mimetype']
          file_roles << file['role'] if file['role']
        end
      end
      solr_doc['content_type_ssim'] = doc.root['type']
      solr_doc['content_file_mimetypes_ssim'] = mime_types.to_a
      solr_doc['content_file_count_itsi'] = counts['content_file']
      solr_doc['shelved_content_file_count_itsi'] = counts['shelved_file']
      solr_doc['resource_count_itsi'] = counts['resource']
      solr_doc['preserved_size_dbtsi'] = preserved_size # double (trie) to support very large sizes
      solr_doc['shelved_size_dbtsi'] = shelved_size # double (trie) to support very large sizes
      solr_doc['resource_types_ssim'] = resource_type_counts.keys if resource_type_counts.size > 0
      solr_doc['content_file_roles_ssim'] = file_roles.to_a if file_roles.size > 0
      resource_type_counts.each do |key, count|
        solr_doc["#{key}_resource_count_itsi"] = count
      end
      # first_shelved_image is neither indexed nor multiple
      solr_doc['first_shelved_image_ss'] = first_shelved_image unless first_shelved_image.nil?
      solr_doc
    end

    ### END: READ ONLY METHODS
    ### DATSTREAM WRITING METHODS

    def unshelve_and_unpublish
      ng_xml.xpath('/contentMetadata/resource//file').each_with_index do |file_node, index|
        ng_xml_will_change! if index == 0
        file_node['publish'] = 'no'
        file_node['shelve'] = 'no'
      end
    end

    # Copies the child's resource into the parent (self) as a virtual resource.
    # Assumes the resource isn't a duplicate of an existing virtual or real resource.
    # @param [String] child_druid druid
    # @param [Nokogiri::XML::Element] child_resource
    # @return [Nokogiri::XML::Element] the new resource that was added to the contentMetadata
    def add_virtual_resource(child_druid, child_resource)
      # create a virtual resource element with attributes linked to the child and omit label
      ng_xml_will_change!
      sequence_max = ng_xml.search('//resource').map { |node| node[:sequence].to_i }.max || 0
      resource = Nokogiri::XML::Element.new('resource', ng_xml)
      resource[:sequence] = sequence_max + 1
      resource[:id] = "#{pid.gsub(/^druid:/, '')}_#{resource[:sequence]}"
      resource[:type] = child_resource[:type]

      # iterate over all the published files and link to them
      child_resource.search('file[@publish=\'yes\']').each do |file|
        resource << generate_external_file_node(child_druid, child_resource[:id], file[:id], file[:mimetype])
      end
      resource << generate_also_available_as_node(child_druid)

      # attach the virtual resource as a sibling and return
      ng_xml.root << resource
      resource
    end

    # @param [String] file_name ID of the file element
    # @param [String] publish
    # @param [String] shelve
    # @param [String] preserve
    def update_attributes(file_name, publish, shelve, preserve, attributes = {})
      ng_xml_will_change!
      file_node = ng_xml.search('//file[@id=\'' + file_name + '\']').first
      file_node['publish'] = publish
      file_node['shelve'] = shelve
      file_node['preserve'] = preserve
      attributes.each do |key, value|
        file_node[key] = value
      end
    end

    # @param file [Object] some hash-like file
    # @param old_file_id [String] unique id attribute of the file element
    def update_file(file, old_file_id)
      ng_xml_will_change!
      file_node = ng_xml.search('//file[@id=\'' + old_file_id + '\']').first
      file_node['id'] = file[:name]
      %i[md5 sha1].each do |algo|
        next if file[algo].nil?

        checksum_node = ng_xml.search('//file[@id=\'' + old_file_id + '\']/checksum[@type=\'' + algo.to_s + '\']').first
        if checksum_node.nil?
          checksum_node = Nokogiri::XML::Node.new('checksum', ng_xml)
          file_node.add_child(checksum_node)
        end
        checksum_node['type'] = algo.to_s
        checksum_node.content = file[algo]
      end

      %i[size shelve preserve publish role].each do |x|
        file_node[x.to_s] = file[x] if file[x]
      end
    end

    # @param old_name [String] unique id attribute of the file element
    # @param new_name [String] new unique id value being assigned
    # @return [Nokogiri::XML::Element] the file node
    def rename_file(old_name, new_name)
      ng_xml_will_change!
      file_node = ng_xml.search('//file[@id=\'' + old_name + '\']').first
      file_node['id'] = new_name
      file_node
    end

    # Updates old label OR creates a new one if necessary
    # @param resource_name [String] unique id attribute of the resource
    # @param new_label [String] label value being assigned
    # @return [Nokogiri::XML::Element] the resource node
    def update_resource_label(resource_name, new_label)
      ng_xml_will_change!
      node = singular_node('//resource[@id=\'' + resource_name + '\']')
      labels = node.xpath('./label')
      if labels.length == 0
        label_node = Nokogiri::XML::Node.new('label', ng_xml) # create a label
        label_node.content = new_label
        node.add_child(label_node)
      else
        labels.first.content = new_label
      end
      node
    end

    # @param resource_name [String] unique id attribute of the resource
    # @param new_type [String] type value being assigned
    def update_resource_type(resource_name, new_type)
      ng_xml_will_change!
      singular_node('//resource[@id=\'' + resource_name + '\']')['type'] = new_type
    end

    # You just *had* to have ordered lists in XML, didn't you?
    # Re-enumerate the sequence numbers affected
    # @param resource_name [String] unique id attribute of the resource
    # @param new_position [Integer, String] new sequence number of the resource, or a string that looks like one
    # @return [Nokogiri::XML::Element] the resource node
    def move_resource(resource_name, new_position)
      ng_xml_will_change!
      node = singular_node('//resource[@id=\'' + resource_name + '\']')
      position = node['sequence'].to_i
      new_position = new_position.to_i # tolerate strings as a Legacy behavior
      return node if position == new_position

      # otherwise, is the resource being moved earlier in the sequence or later?
      up = new_position > position
      others = new_position..(up ? position - 1 : position + 1) # a range
      others.each do |i|
        item = ng_xml.at_xpath('/resource[@sequence=\'' + i.to_s + '\']')
        item['sequence'] = (up ? i - 1 : i + 1).to_s # if you're going up, everything else comes down and vice versa
      end
      node['sequence'] = new_position.to_s # set the node we already had last, so we don't hit it twice!
      node
    end

    # Set the content type (e.g. "book") and the resource type (e.g. "book") for all resources
    # @param [String] old_type the old content type
    # @param [String] old_resource_type the old type for all resources
    # @param [String] new_type the new content type
    # @param [String] new_resource_type the new type for all resources
    def set_content_type(old_type, old_resource_type, new_type, new_resource_type)
      ng_xml_will_change!
      ng_xml.search('/contentMetadata[@type=\'' + old_type + '\']').each do |node|
        node['type'] = new_type
        ng_xml.search('//resource[@type=\'' + old_resource_type + '\']').each do |resource|
          resource['type'] = new_resource_type
        end
      end
    end

    # maintain AF < 8 indexing behavior
    def prefix
      ''
    end
  end
end

1	# frozen_string_literal: true
2
3	require 'set'	1✔
4
5	module Dor	1✔
6	class ContentMetadataDS < ActiveFedora::OmDatastream	1✔
7	set_terminology do \|t\|	1✔
8	t.root path: 'contentMetadata', index_as: [:not_searchable]	1✔
9	t.contentType path: '/contentMetadata/@type', index_as: [:not_searchable]	1✔
10	t.stacks path: '/contentMetadata/@stacks', index_as: [:not_searchable]	1✔
11	t.resource(index_as: [:not_searchable]) do	1✔
12	t.id_ path: { attribute: 'id' }	1✔
13	t.sequence path: { attribute: 'sequence' } # , :data_type => :integer	1✔
14	t.type_ path: { attribute: 'type' }, index_as: [:displayable]	1✔
15	t.attribute(path: 'attr', index_as: [:not_searchable]) do	1✔
16	t.name path: { attribute: 'name' }, index_as: [:not_searchable]	1✔
17	end
18	t.file(index_as: [:not_searchable]) do	1✔
19	t.id_ path: { attribute: 'id' }	1✔
20	t.mimeType path: { attribute: 'mimeType' }, index_as: [:displayable]	1✔
21	t.dataType path: { attribute: 'dataType' }, index_as: [:displayable]	1✔
22	t.size path: { attribute: 'size' }, index_as: [:displayable] # , :data_type => :long	1✔
23	t.role path: { attribute: 'role' }, index_as: [:not_searchable]	1✔
24	t.shelve path: { attribute: 'shelve' }, index_as: [:not_searchable] # , :data_type => :boolean	1✔
25	t.publish path: { attribute: 'publish' }, index_as: [:not_searchable] # , :data_type => :boolean	1✔
26	t.preserve path: { attribute: 'preserve' }, index_as: [:not_searchable] # , :data_type => :boolean	1✔
27	t.checksum do	1✔
28	t.type_ path: { attribute: 'type' }	1✔
29	end
30	end
31	t.shelved_file(path: 'file', attributes: { shelve: 'yes' }, index_as: [:not_searchable]) do	1✔
32	t.id_ path: { attribute: 'id' }, index_as: %i[displayable stored_searchable]	1✔
33	end
34	end
35	t.shelved_file_id proxy: %i[resource shelved_file id], index_as: %i[displayable stored_searchable]	1✔
36	end
37
38	### READ ONLY METHODS
39
40	# Only use this when you want the behavior of raising an exception if anything besides exactly one matching node
41	# is found. Otherwise just use .xpath, .at_xpath or .search.
42	# @param xpath [String] accessor invocation for Nokogiri xpath
43	# @return [Nokogiri::XML::Element] the matched element
44	def singular_node(xpath)	1✔
45	node = ng_xml.search(xpath)	5✔
46	len = node.length	5✔
47	raise "#{xpath} not found" if len < 1	5✔
48	raise "#{xpath} duplicated: #{len} found" if len != 1	5✔
49
50	node.first	5✔
51	end
52
53	# Generates the XML tree for externalFile references. For example:
54	# <externalFile objectId="druid:mn123pq4567" resourceId="Image01" fileId="image_01.jp2000" mimetype="image/jp2" />
55	# @param [String] objectId the linked druid
56	# @param [String] resourceId the linked druid's resource identifier
57	# @param [String] fileId the linked druid's resource's file identifier
58	# @param [String] mimetype the file's MIME type
59	# @return [Nokogiri::XML::Element]
60	def generate_external_file_node(objectId, resourceId, fileId, mimetype)	1✔
61	externalFile = ng_xml.create_element 'externalFile'	4✔
62	externalFile[:objectId] = objectId	4✔
63	externalFile[:resourceId] = resourceId	4✔
64	externalFile[:fileId] = fileId	4✔
65	externalFile[:mimetype] = mimetype	4✔
66	externalFile	4✔
67	end
68
69	# Generates the XML tree for virtual resource relationship reference. For example:
70	# <relationship type="alsoAvailableAs" objectId="druid:mn123pq4567" />
71	# @param [String] objectId the linked druid
72	# @return [Nokogiri::XML::Element]
73	def generate_also_available_as_node(objectId)	1✔
74	relationship = ng_xml.create_element 'relationship'	3✔
75	relationship[:type] = 'alsoAvailableAs'	3✔
76	relationship[:objectId] = objectId	3✔
77	relationship	3✔
78	end
79
80	# Terminology-based solrization is going to be painfully slow for large
81	# contentMetadata streams. Just select the relevant elements instead.
82	# TODO: Call super()?
83	def to_solr(solr_doc = {}, *_args)	1✔
84	doc = ng_xml	5✔
85	return solr_doc unless doc.root['type']	5✔
86
87	preserved_size = 0	2✔
88	shelved_size = 0	2✔
89	counts = Hash.new(0) # default count is zero	2✔
90	resource_type_counts = Hash.new(0) # default count is zero	2✔
91	file_roles = ::Set.new	2✔
92	mime_types = ::Set.new	2✔
93	first_shelved_image = nil	2✔
94
95	doc.xpath('contentMetadata/resource').sort { \|a, b\| a['sequence'].to_i <=> b['sequence'].to_i }.each do \|resource\|	2✔
96	counts['resource'] += 1	2✔
97	resource_type_counts[resource['type']] += 1 if resource['type']	2✔
98	resource.xpath('file').each do \|file\|	2✔
99	counts['content_file'] += 1	5✔
100	preserved_size += file['size'].to_i if file['preserve'] == 'yes'	5✔
101	shelved_size += file['size'].to_i if file['shelve'] == 'yes'	5✔
102	if file['shelve'] == 'yes'	5✔
103	counts['shelved_file'] += 1	2✔
104	first_shelved_image \|\|= file['id'] if file['id'] =~ /jp2$/	2✔
105	end
106	mime_types << file['mimetype']	5✔
107	file_roles << file['role'] if file['role']	5✔
108	end
109	end
110	solr_doc['content_type_ssim'] = doc.root['type']	2✔
111	solr_doc['content_file_mimetypes_ssim'] = mime_types.to_a	2✔
112	solr_doc['content_file_count_itsi'] = counts['content_file']	2✔
113	solr_doc['shelved_content_file_count_itsi'] = counts['shelved_file']	2✔
114	solr_doc['resource_count_itsi'] = counts['resource']	2✔
115	solr_doc['preserved_size_dbtsi'] = preserved_size # double (trie) to support very large sizes	2✔
116	solr_doc['shelved_size_dbtsi'] = shelved_size # double (trie) to support very large sizes	2✔
117	solr_doc['resource_types_ssim'] = resource_type_counts.keys if resource_type_counts.size > 0	2✔
118	solr_doc['content_file_roles_ssim'] = file_roles.to_a if file_roles.size > 0	2✔
119	resource_type_counts.each do \|key, count\|	2✔
120	solr_doc["#{key}_resource_count_itsi"] = count	2✔
121	end
122	# first_shelved_image is neither indexed nor multiple
123	solr_doc['first_shelved_image_ss'] = first_shelved_image unless first_shelved_image.nil?	2✔
124	solr_doc	2✔
125	end
126
127	### END: READ ONLY METHODS
128	### DATSTREAM WRITING METHODS
129
130	def unshelve_and_unpublish	1✔
131	ng_xml.xpath('/contentMetadata/resource//file').each_with_index do \|file_node, index\|	3✔
132	ng_xml_will_change! if index == 0	4✔
133	file_node['publish'] = 'no'	4✔
134	file_node['shelve'] = 'no'	4✔
135	end
136	end
137
138	# Copies the child's resource into the parent (self) as a virtual resource.
139	# Assumes the resource isn't a duplicate of an existing virtual or real resource.
140	# @param [String] child_druid druid
141	# @param [Nokogiri::XML::Element] child_resource
142	# @return [Nokogiri::XML::Element] the new resource that was added to the contentMetadata
143	def add_virtual_resource(child_druid, child_resource)	1✔
144	# create a virtual resource element with attributes linked to the child and omit label
145	ng_xml_will_change!	3✔
146	sequence_max = ng_xml.search('//resource').map { \|node\| node[:sequence].to_i }.max \|\| 0	5✔
147	resource = Nokogiri::XML::Element.new('resource', ng_xml)	3✔
148	resource[:sequence] = sequence_max + 1	3✔
149	resource[:id] = "#{pid.gsub(/^druid:/, '')}_#{resource[:sequence]}"	3✔
150	resource[:type] = child_resource[:type]	3✔
151
152	# iterate over all the published files and link to them
153	child_resource.search('file[@publish=\'yes\']').each do \|file\|	3✔
154	resource << generate_external_file_node(child_druid, child_resource[:id], file[:id], file[:mimetype])	4✔
155	end
156	resource << generate_also_available_as_node(child_druid)	3✔
157
158	# attach the virtual resource as a sibling and return
159	ng_xml.root << resource	3✔
160	resource	3✔
161	end
162
163	# @param [String] file_name ID of the file element
164	# @param [String] publish
165	# @param [String] shelve
166	# @param [String] preserve
167	def update_attributes(file_name, publish, shelve, preserve, attributes = {})	1✔
168	ng_xml_will_change!	×
169	file_node = ng_xml.search('//file[@id=\'' + file_name + '\']').first	×
170	file_node['publish'] = publish	×
171	file_node['shelve'] = shelve	×
172	file_node['preserve'] = preserve	×
173	attributes.each do \|key, value\|	×
174	file_node[key] = value	×
175	end
176	end
177
178	# @param file [Object] some hash-like file
179	# @param old_file_id [String] unique id attribute of the file element
180	def update_file(file, old_file_id)	1✔
181	ng_xml_will_change!	2✔
182	file_node = ng_xml.search('//file[@id=\'' + old_file_id + '\']').first	2✔
183	file_node['id'] = file[:name]	2✔
184	%i[md5 sha1].each do \|algo\|	1✔
185	next if file[algo].nil?	2✔
186
187	checksum_node = ng_xml.search('//file[@id=\'' + old_file_id + '\']/checksum[@type=\'' + algo.to_s + '\']').first	×
188	if checksum_node.nil?	×
189	checksum_node = Nokogiri::XML::Node.new('checksum', ng_xml)	×
190	file_node.add_child(checksum_node)	×
191	end
192	checksum_node['type'] = algo.to_s	×
193	checksum_node.content = file[algo]	×
194	end
195
196	%i[size shelve preserve publish role].each do \|x\|	1✔
197	file_node[x.to_s] = file[x] if file[x]	5✔
198	end
199	end
200
201	# @param old_name [String] unique id attribute of the file element
202	# @param new_name [String] new unique id value being assigned
203	# @return [Nokogiri::XML::Element] the file node
204	def rename_file(old_name, new_name)	1✔
205	ng_xml_will_change!	1✔
206	file_node = ng_xml.search('//file[@id=\'' + old_name + '\']').first	1✔
207	file_node['id'] = new_name	1✔
208	file_node	1✔
209	end
210
211	# Updates old label OR creates a new one if necessary
212	# @param resource_name [String] unique id attribute of the resource
213	# @param new_label [String] label value being assigned
214	# @return [Nokogiri::XML::Element] the resource node
215	def update_resource_label(resource_name, new_label)	1✔
216	ng_xml_will_change!	3✔
217	node = singular_node('//resource[@id=\'' + resource_name + '\']')	3✔
218	labels = node.xpath('./label')	3✔
219	if labels.length == 0	3✔
220	label_node = Nokogiri::XML::Node.new('label', ng_xml) # create a label	2✔
221	label_node.content = new_label	2✔
222	node.add_child(label_node)	2✔
223	else
224	labels.first.content = new_label	1✔
225	end
226	node	3✔
227	end
228
229	# @param resource_name [String] unique id attribute of the resource
230	# @param new_type [String] type value being assigned
231	def update_resource_type(resource_name, new_type)	1✔
232	ng_xml_will_change!	1✔
233	singular_node('//resource[@id=\'' + resource_name + '\']')['type'] = new_type	1✔
234	end
235
236	# You just had to have ordered lists in XML, didn't you?
237	# Re-enumerate the sequence numbers affected
238	# @param resource_name [String] unique id attribute of the resource
239	# @param new_position [Integer, String] new sequence number of the resource, or a string that looks like one
240	# @return [Nokogiri::XML::Element] the resource node
241	def move_resource(resource_name, new_position)	1✔
242	ng_xml_will_change!	1✔
243	node = singular_node('//resource[@id=\'' + resource_name + '\']')	1✔
244	position = node['sequence'].to_i	1✔
245	new_position = new_position.to_i # tolerate strings as a Legacy behavior	1✔
246	return node if position == new_position	1✔
247
248	# otherwise, is the resource being moved earlier in the sequence or later?
249	up = new_position > position	1✔
250	others = new_position..(up ? position - 1 : position + 1) # a range	1✔
251	others.each do \|i\|	1✔
252	item = ng_xml.at_xpath('/resource[@sequence=\'' + i.to_s + '\']')	×
253	item['sequence'] = (up ? i - 1 : i + 1).to_s # if you're going up, everything else comes down and vice versa	×
254	end
255	node['sequence'] = new_position.to_s # set the node we already had last, so we don't hit it twice!	1✔
256	node	1✔
257	end
258
259	# Set the content type (e.g. "book") and the resource type (e.g. "book") for all resources
260	# @param [String] old_type the old content type
261	# @param [String] old_resource_type the old type for all resources
262	# @param [String] new_type the new content type
263	# @param [String] new_resource_type the new type for all resources
264	def set_content_type(old_type, old_resource_type, new_type, new_resource_type)	1✔
265	ng_xml_will_change!	1✔
266	ng_xml.search('/contentMetadata[@type=\'' + old_type + '\']').each do \|node\|	1✔
267	node['type'] = new_type	1✔
268	ng_xml.search('//resource[@type=\'' + old_resource_type + '\']').each do \|resource\|	1✔
269	resource['type'] = new_resource_type	1✔
270	end
271	end
272	end
273
274	# maintain AF < 8 indexing behavior
275	def prefix	1✔
276	''	×
277	end
278	end
279	end

sul-dlss / dor-services / 3526

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous