00dac745-55d3-4397-95bf-de4f70881e93

Build # 00dac745-55d3-4397-95bf-de4f70881e93

Build Type

circleci

Committed by Hector Correa

Commit Message

Add tests for new logic

Pull Request Pull Request #995: Handles external user ids

Run Details

8 of 8 new or added lines in 1 file covered. (100.0%)

936 of 1902 relevant lines covered (49.21%)

9.91 hits per line

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

88.39

/app/models/pdc_metadata/resource.rb

# frozen_string_literal: true
module PDCMetadata
  # Represents a PUL Datacite resource
  # https://support.datacite.org/docs/datacite-metadata-schema-v44-properties-overview

  def self.fuzzy_match(obj, value)
    obj.key.to_s == value or obj.value.casecmp(value).zero?
  end

  class Resource
    attr_accessor :creators, :titles, :publisher, :publication_year, :resource_type, :resource_type_general,
      :description, :doi, :ark, :rights, :version_number, :collection_tags, :keywords, :related_objects,
      :funders, :organizational_contributors, :domains

    # rubocop:disable Metrics/MethodLength
    def initialize(doi: nil, title: nil, resource_type: nil, resource_type_general: nil, creators: [], description: nil)
      @titles = []
      @titles << PDCMetadata::Title.new(title: title) unless title.nil?
      @description = description
      @collection_tags = []
      @creators = creators
      @resource_type = resource_type || "Dataset"
      @resource_type_general = resource_type_general || self.class.default_resource_type_general
      @publisher = "Princeton University"
      @publication_year = Time.zone.today.year
      @ark = nil
      @doi = doi
      @rights = nil
      @version_number = "1"
      @related_objects = []
      @keywords = []
      @contributors = []
      @organizational_contributors = []
      @funders = []
      @domains = []
    end
    # rubocop:enable Metrics/MethodLength

    def accessors
      setters = methods.map(&:to_s).filter { |s| s.match?(/\w=$/) }
      setters.map { |s| s.delete("=").to_sym }
    end

    def individual_contributors
      @contributors
    end

    def individual_contributors=(value)
      @contributors = value
    end

    def identifier
      @doi
    end

    def identifier_type
      return nil if @doi.nil?
      "DOI"
    end

    def main_title
      @titles.find(&:main?)&.title
    end

    def other_titles
      @titles.select { |title| title.main? == false }
    end

    def to_xml
      xml_declaration = '<?xml version="1.0"?>'
      xml_body = PDCSerialization::Datacite.new_from_work_resource(self).to_xml
      xml_declaration + "\n" + xml_body + "\n"
    end

    class << self
      # Creates a PDCMetadata::Resource from a JSONB postgres field
      #  This jsonb_hash can be created by running JSON.parse(pdc_metadata_resource.to_json)
      #   or by loading it from the work.metadata jsonb field
      def new_from_jsonb(jsonb_hash)
        resource = PDCMetadata::Resource.new
        return resource if jsonb_hash.blank?

        set_basics(resource, jsonb_hash)
        set_curator_controlled_metadata(resource, jsonb_hash)
        set_additional_metadata(resource, jsonb_hash)
        set_titles(resource, jsonb_hash)
        set_creators(resource, jsonb_hash)
        set_individual_contributors(resource, jsonb_hash)
        set_organizational_contributors(resource, jsonb_hash)
        set_related_objects(resource, jsonb_hash)
        set_funders(resource, jsonb_hash)

        resource
      end

      def resource_type_general_values
        Datacite::Mapping::ResourceTypeGeneral.map(&:value)
      end

      def default_resource_type_general
        "Dataset"
      end

      private

        def rights(form_rights)
          PDCMetadata::Rights.find(form_rights["identifier"]) if form_rights
        end

        def set_basics(resource, hash)
          resource.description = hash["description"]
          resource.publisher = hash["publisher"]
          resource.publication_year = hash["publication_year"]
          resource.rights = rights(hash["rights"])
          resource.domains = hash["domains"] || []
        end

        def set_curator_controlled_metadata(resource, hash)
          resource.doi = hash["doi"]
          resource.ark = hash["ark"]
          resource.version_number = hash["version_number"]
          resource.collection_tags = hash["collection_tags"] || []
          resource.resource_type = hash["resource_type"]

          # TODO: Older records have a different format.
          # When we migrate these, then this can be removed.
          resource_type_general = hash["resource_type_general"]
          unless resource_type_general.blank? || Datacite::Mapping::ResourceTypeGeneral.find_by_value(resource_type_general)
            resource_type_general = ::Datacite::Mapping::ResourceTypeGeneral.find do |obj|
              ::PDCMetadata.fuzzy_match(obj, resource_type_general)
            end.value
          end
          resource.resource_type_general = resource_type_general
        end

        def set_additional_metadata(resource, hash)
          resource.keywords = hash["keywords"] || []
        end

        def set_titles(resource, hash)
          titles = hash["titles"] || []

          titles.each do |title|
            resource.titles << PDCMetadata::Title.new(title: title["title"], title_type: title["title_type"])
          end
        end

        def set_related_objects(resource, hash)
          related_objects = hash["related_objects"] || []

          related_objects.each do |related_object|
            next if related_object["related_identifier"].blank? && related_object["related_identifier_type"].blank?
            resource.related_objects << PDCMetadata::RelatedObject.new(
                                          related_identifier: related_object["related_identifier"],
                                          related_identifier_type: related_object["related_identifier_type"],
                                          relation_type: related_object["relation_type"]
                                        )
          end
        end

        def set_creators(resource, hash)
          creators = hash["creators"] || []

          creators.each do |creator|
            resource.creators << Creator.from_hash(creator)
          end
          resource.creators.sort_by!(&:sequence)
        end

        def set_individual_contributors(resource, hash)
          individual_contributors = hash["contributors"] || []

          individual_contributors.each do |contributor|
            resource.individual_contributors << Creator.individual_contributor_from_hash(contributor)
          end
          resource.individual_contributors.sort_by!(&:sequence)
        end

        def set_organizational_contributors(resource, hash)
          organizational_contributors = hash["organizational_contributors"] || []

          organizational_contributors.each do |contributor|
            resource.organizational_contributors << Creator.organizational_contributor_from_hash(contributor)
          end
        end

        def set_funders(resource, hash)
          funders = hash["funders"] || []

          funders.each do |funder|
            resource.funders << Funder.funder_from_hash(funder)
          end
          # TODO: Make funders reorderable
          # resource.funders.sort_by!(&:sequence)
        end
    end
  end
end

1	# frozen_string_literal: true
2	module PDCMetadata	1✔
3	# Represents a PUL Datacite resource
4	# https://support.datacite.org/docs/datacite-metadata-schema-v44-properties-overview
5
6	def self.fuzzy_match(obj, value)	1✔
7	obj.key.to_s == value or obj.value.casecmp(value).zero?	×
8	end
9
10	class Resource	1✔
11	attr_accessor :creators, :titles, :publisher, :publication_year, :resource_type, :resource_type_general,	1✔
12	:description, :doi, :ark, :rights, :version_number, :collection_tags, :keywords, :related_objects,
13	:funders, :organizational_contributors, :domains
14
15	# rubocop:disable Metrics/MethodLength
16	def initialize(doi: nil, title: nil, resource_type: nil, resource_type_general: nil, creators: [], description: nil)	1✔
17	@titles = []	117✔
18	@titles << PDCMetadata::Title.new(title: title) unless title.nil?	117✔
19	@description = description	117✔
20	@collection_tags = []	117✔
21	@creators = creators	117✔
22	@resource_type = resource_type \|\| "Dataset"	117✔
23	@resource_type_general = resource_type_general \|\| self.class.default_resource_type_general	117✔
24	@publisher = "Princeton University"	117✔
25	@publication_year = Time.zone.today.year	117✔
26	@ark = nil	117✔
27	@doi = doi	117✔
28	@rights = nil	117✔
29	@version_number = "1"	117✔
30	@related_objects = []	117✔
31	@keywords = []	117✔
32	@contributors = []	117✔
33	@organizational_contributors = []	117✔
34	@funders = []	117✔
35	@domains = []	117✔
36	end
37	# rubocop:enable Metrics/MethodLength
38
39	def accessors	1✔
40	setters = methods.map(&:to_s).filter { \|s\| s.match?(/\w=$/) }	150✔
41	setters.map { \|s\| s.delete("=").to_sym }	19✔
42	end
43
44	def individual_contributors	1✔
45	@contributors	140✔
46	end
47
48	def individual_contributors=(value)	1✔
49	@contributors = value	×
50	end
51
52	def identifier	1✔
53	@doi	×
54	end
55
56	def identifier_type	1✔
57	return nil if @doi.nil?	×
58	"DOI"	×
59	end
60
61	def main_title	1✔
62	@titles.find(&:main?)&.title	73✔
63	end
64
65	def other_titles	1✔
66	@titles.select { \|title\| title.main? == false }	45✔
67	end
68
69	def to_xml	1✔
70	xml_declaration = '<?xml version="1.0"?>'	×
71	xml_body = PDCSerialization::Datacite.new_from_work_resource(self).to_xml	×
72	xml_declaration + "\n" + xml_body + "\n"	×
73	end
74
75	class << self	1✔
76	# Creates a PDCMetadata::Resource from a JSONB postgres field
77	# This jsonb_hash can be created by running JSON.parse(pdc_metadata_resource.to_json)
78	# or by loading it from the work.metadata jsonb field
79	def new_from_jsonb(jsonb_hash)	1✔
80	resource = PDCMetadata::Resource.new	113✔
81	return resource if jsonb_hash.blank?	113✔
82
83	set_basics(resource, jsonb_hash)	112✔
84	set_curator_controlled_metadata(resource, jsonb_hash)	112✔
85	set_additional_metadata(resource, jsonb_hash)	112✔
86	set_titles(resource, jsonb_hash)	112✔
87	set_creators(resource, jsonb_hash)	112✔
88	set_individual_contributors(resource, jsonb_hash)	112✔
89	set_organizational_contributors(resource, jsonb_hash)	112✔
90	set_related_objects(resource, jsonb_hash)	112✔
91	set_funders(resource, jsonb_hash)	112✔
92
93	resource	112✔
94	end
95
96	def resource_type_general_values	1✔
97	Datacite::Mapping::ResourceTypeGeneral.map(&:value)	5✔
98	end
99
100	def default_resource_type_general	1✔
101	"Dataset"	117✔
102	end
103
104	private	1✔
105
106	def rights(form_rights)	1✔
107	PDCMetadata::Rights.find(form_rights["identifier"]) if form_rights	112✔
108	end
109
110	def set_basics(resource, hash)	1✔
111	resource.description = hash["description"]	112✔
112	resource.publisher = hash["publisher"]	112✔
113	resource.publication_year = hash["publication_year"]	112✔
114	resource.rights = rights(hash["rights"])	112✔
115	resource.domains = hash["domains"] \|\| []	112✔
116	end
117
118	def set_curator_controlled_metadata(resource, hash)	1✔
119	resource.doi = hash["doi"]	112✔
120	resource.ark = hash["ark"]	112✔
121	resource.version_number = hash["version_number"]	112✔
122	resource.collection_tags = hash["collection_tags"] \|\| []	112✔
123	resource.resource_type = hash["resource_type"]	112✔
124
125	# TODO: Older records have a different format.
126	# When we migrate these, then this can be removed.
127	resource_type_general = hash["resource_type_general"]	112✔
128	unless resource_type_general.blank? \|\| Datacite::Mapping::ResourceTypeGeneral.find_by_value(resource_type_general)	112✔
129	resource_type_general = ::Datacite::Mapping::ResourceTypeGeneral.find do \|obj\|	×
130	::PDCMetadata.fuzzy_match(obj, resource_type_general)	×
131	end.value
132	end
133	resource.resource_type_general = resource_type_general	112✔
134	end
135
136	def set_additional_metadata(resource, hash)	1✔
137	resource.keywords = hash["keywords"] \|\| []	112✔
138	end
139
140	def set_titles(resource, hash)	1✔
141	titles = hash["titles"] \|\| []	112✔
142
143	titles.each do \|title\|	112✔
144	resource.titles << PDCMetadata::Title.new(title: title["title"], title_type: title["title_type"])	112✔
145	end
146	end
147
148	def set_related_objects(resource, hash)	1✔
149	related_objects = hash["related_objects"] \|\| []	112✔
150
151	related_objects.each do \|related_object\|	112✔
152	next if related_object["related_identifier"].blank? && related_object["related_identifier_type"].blank?	16✔
153	resource.related_objects << PDCMetadata::RelatedObject.new(	16✔
154	related_identifier: related_object["related_identifier"],
155	related_identifier_type: related_object["related_identifier_type"],
156	relation_type: related_object["relation_type"]
157	)
158	end
159	end
160
161	def set_creators(resource, hash)	1✔
162	creators = hash["creators"] \|\| []	112✔
163
164	creators.each do \|creator\|	112✔
165	resource.creators << Creator.from_hash(creator)	216✔
166	end
167	resource.creators.sort_by!(&:sequence)	112✔
168	end
169
170	def set_individual_contributors(resource, hash)	1✔
171	individual_contributors = hash["contributors"] \|\| []	112✔
172
173	individual_contributors.each do \|contributor\|	112✔
174	resource.individual_contributors << Creator.individual_contributor_from_hash(contributor)	×
175	end
176	resource.individual_contributors.sort_by!(&:sequence)	112✔
177	end
178
179	def set_organizational_contributors(resource, hash)	1✔
180	organizational_contributors = hash["organizational_contributors"] \|\| []	112✔
181
182	organizational_contributors.each do \|contributor\|	112✔
183	resource.organizational_contributors << Creator.organizational_contributor_from_hash(contributor)	×
184	end
185	end
186
187	def set_funders(resource, hash)	1✔
188	funders = hash["funders"] \|\| []	112✔
189
190	funders.each do \|funder\|	112✔
191	resource.funders << Funder.funder_from_hash(funder)	×
192	end
193	# TODO: Make funders reorderable
194	# resource.funders.sort_by!(&:sequence)
195	end
196	end
197	end
198	end

pulibrary / pdc_describe / 00dac745-55d3-4397-95bf-de4f70881e93

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