7031ff5b-e2d7-4285-af8b-e7b55adfc48a

Build # 7031ff5b-e2d7-4285-af8b-e7b55adfc48a

Build Type

circleci

Committed by mccalluc

Commit Message

Finish removal of explicit if-then in js

Pull Request Pull Request #899: Move messages up to sidebar on the right which can be toggled

Run Details

1623 of 1788 relevant lines covered (90.77%)

105.5 hits per line

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

93.81

/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, :contributors, :related_objects,
      :funders

    # 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 = []
      @funders = []
    end
    # rubocop:enable Metrics/MethodLength

    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_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"])
        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_contributors(resource, hash)
          contributors = hash["contributors"] || []

          contributors.each do |contributor|
            resource.contributors << Creator.contributor_from_hash(contributor)
          end
          resource.contributors.sort_by!(&:sequence)
        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, :contributors, :related_objects,
13	:funders
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 = []	1,222✔
18	@titles << PDCMetadata::Title.new(title: title) unless title.nil?	1,222✔
19	@description = description	1,222✔
20	@collection_tags = []	1,222✔
21	@creators = creators	1,222✔
22	@resource_type = resource_type \|\| "Dataset"	1,222✔
23	@resource_type_general = resource_type_general \|\| self.class.default_resource_type_general	1,222✔
24	@publisher = "Princeton University"	1,222✔
25	@publication_year = Time.zone.today.year	1,222✔
26	@ark = nil	1,222✔
27	@doi = doi	1,222✔
28	@rights = nil	1,222✔
29	@version_number = "1"	1,222✔
30	@related_objects = []	1,222✔
31	@keywords = []	1,222✔
32	@contributors = []	1,222✔
33	@funders = []	1,222✔
34	end
35	# rubocop:enable Metrics/MethodLength
36
37	def identifier	1✔
38	@doi	×
39	end
40
41	def identifier_type	1✔
42	return nil if @doi.nil?	×
43	"DOI"	×
44	end
45
46	def main_title	1✔
47	@titles.find(&:main?)&.title	963✔
48	end
49
50	def other_titles	1✔
51	@titles.select { \|title\| title.main? == false }	153✔
52	end
53
54	def to_xml	1✔
55	xml_declaration = '<?xml version="1.0"?>'	17✔
56	xml_body = PDCSerialization::Datacite.new_from_work_resource(self).to_xml	17✔
57	xml_declaration + "\n" + xml_body + "\n"	17✔
58	end
59
60	class << self	1✔
61	# Creates a PDCMetadata::Resource from a JSONB postgres field
62	# This jsonb_hash can be created by running JSON.parse(pdc_metadata_resource.to_json)
63	# or by loading it from the work.metadata jsonb field
64	def new_from_jsonb(jsonb_hash)	1✔
65	resource = PDCMetadata::Resource.new	1,010✔
66	return resource if jsonb_hash.blank?	1,010✔
67
68	set_basics(resource, jsonb_hash)	982✔
69	set_curator_controlled_metadata(resource, jsonb_hash)	982✔
70	set_additional_metadata(resource, jsonb_hash)	982✔
71	set_titles(resource, jsonb_hash)	982✔
72	set_creators(resource, jsonb_hash)	982✔
73	set_contributors(resource, jsonb_hash)	982✔
74	set_related_objects(resource, jsonb_hash)	982✔
75	set_funders(resource, jsonb_hash)	982✔
76
77	resource	982✔
78	end
79
80	def resource_type_general_values	1✔
81	Datacite::Mapping::ResourceTypeGeneral.map(&:value)	33✔
82	end
83
84	def default_resource_type_general	1✔
85	"Dataset"	1,222✔
86	end
87
88	private	1✔
89
90	def rights(form_rights)	1✔
91	PDCMetadata::Rights.find(form_rights["identifier"]) if form_rights	982✔
92	end
93
94	def set_basics(resource, hash)	1✔
95	resource.description = hash["description"]	982✔
96	resource.publisher = hash["publisher"]	982✔
97	resource.publication_year = hash["publication_year"]	982✔
98	resource.rights = rights(hash["rights"])	982✔
99	end
100
101	def set_curator_controlled_metadata(resource, hash)	1✔
102	resource.doi = hash["doi"]	982✔
103	resource.ark = hash["ark"]	982✔
104	resource.version_number = hash["version_number"]	982✔
105	resource.collection_tags = hash["collection_tags"] \|\| []	982✔
106	resource.resource_type = hash["resource_type"]	982✔
107
108	# TODO: Older records have a different format.
109	# When we migrate these, then this can be removed.
110	resource_type_general = hash["resource_type_general"]	982✔
111	unless resource_type_general.blank? \|\| Datacite::Mapping::ResourceTypeGeneral.find_by_value(resource_type_general)	982✔
112	resource_type_general = ::Datacite::Mapping::ResourceTypeGeneral.find do \|obj\|	×
113	::PDCMetadata.fuzzy_match(obj, resource_type_general)	×
114	end.value
115	end
116	resource.resource_type_general = resource_type_general	982✔
117	end
118
119	def set_additional_metadata(resource, hash)	1✔
120	resource.keywords = hash["keywords"] \|\| []	982✔
121	end
122
123	def set_titles(resource, hash)	1✔
124	titles = hash["titles"] \|\| []	982✔
125
126	titles.each do \|title\|	982✔
127	resource.titles << PDCMetadata::Title.new(title: title["title"], title_type: title["title_type"])	985✔
128	end
129	end
130
131	def set_related_objects(resource, hash)	1✔
132	related_objects = hash["related_objects"] \|\| []	982✔
133
134	related_objects.each do \|related_object\|	982✔
135	next if related_object["related_identifier"].blank? && related_object["related_identifier_type"].blank?	94✔
136	resource.related_objects << PDCMetadata::RelatedObject.new(	94✔
137	related_identifier: related_object["related_identifier"],
138	related_identifier_type: related_object["related_identifier_type"],
139	relation_type: related_object["relation_type"]
140	)
141	end
142	end
143
144	def set_creators(resource, hash)	1✔
145	creators = hash["creators"] \|\| []	982✔
146
147	creators.each do \|creator\|	982✔
148	resource.creators << Creator.from_hash(creator)	1,963✔
149	end
150	resource.creators.sort_by!(&:sequence)	982✔
151	end
152
153	def set_contributors(resource, hash)	1✔
154	contributors = hash["contributors"] \|\| []	982✔
155
156	contributors.each do \|contributor\|	982✔
157	resource.contributors << Creator.contributor_from_hash(contributor)	14✔
158	end
159	resource.contributors.sort_by!(&:sequence)	982✔
160	end
161
162	def set_funders(resource, hash)	1✔
163	funders = hash["funders"] \|\| []	982✔
164
165	funders.each do \|funder\|	982✔
166	resource.funders << Funder.funder_from_hash(funder)	64✔
167	end
168	# TODO: Make funders reorderable
169	# resource.funders.sort_by!(&:sequence)
170	end
171	end
172	end
173	end

pulibrary / pdc_describe / 7031ff5b-e2d7-4285-af8b-e7b55adfc48a

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