cocina-models 0.74.1 → 0.77.0

data/lib/cocina/generator/generator.rb

@@ -54,29 +54,22 @@ module Cocina
 
           <<~MARKDOWN
             #{'#' * (field.count('.') + 1)} #{header_markdown}
-            _Path: #{field}_
+            _Path: #{field}.type_
             #{types_markdown}
           MARKDOWN
-        end.join("\n")
+        end.join
 
         remove_file 'docs/description_types.md'
-        create_file 'docs/description_types.md', h1_markdown + markdown
+        create_file 'docs/description_types.md', markdown
       end
 
       private
 
-      def h1_markdown
-        <<~MARKDOWN
-          # Description types
-
-        MARKDOWN
-      end
-
       def field_markdown_from(field)
         header = field.split('.')
                       .grep_v(/groupedValue|structuredValue/)
                       .join(' ')
-                      .capitalize
+                      .upcase_first
 
         header_suffix = if field.ends_with?('structuredValue')
                           'part types for structured value'
@@ -91,7 +84,9 @@ module Cocina
       def types_markdown_from(types)
         types.map do |type|
           "  * #{type['value']}".tap do |type_value|
-            type_value << ": #{type['description']}" if type['description']
+            type_value << "\n    * #{type['description']}" if type['description']
+            type_value << "\n    * Deprecated." if type['status'] == 'deprecated'
+            type_value << " Preferred usage: #{type['use']}" if type['use']
           end
         end.join("\n")
       end
@@ -122,10 +117,7 @@ module Cocina
 
       NO_CLEAN = [
         'checkable.rb',
-        'dro_rights_description_builder.rb',
         'license.rb',
-        'rights_description_builder.rb',
-        'title_builder.rb',
         'validatable.rb',
         'version.rb',
         'vocabulary.rb'

data/lib/cocina/generator/schema.rb

@@ -101,9 +101,7 @@ module Cocina
         return [] if doc.one_of.nil?
 
         # All properties must be objects.
-        unless doc.one_of.all? { |schema| schema.type == 'object' }
-          raise 'All properties for oneOf must be objects'
-        end
+        raise 'All properties for oneOf must be objects' unless doc.one_of.all? { |schema| schema.type == 'object' }
 
         doc.one_of.flat_map do |one_of_doc|
           one_of_doc.properties.map do |key, properties_doc|

data/lib/cocina/generator/schema_base.rb

@@ -23,14 +23,6 @@ module Cocina
         key || schema_doc.name
       end
 
-      # Allows non-required values to not be provided. This allows smaller
-      # requests as not every field needs to be present.
-      def omittable
-        return '' if required && !relaxed
-
-        '.meta(omittable: true)'
-      end
-
       # Allows nillable values to be set to nil. This is useful when doing
       # an update and you want to clear out a value.
       def optional

data/lib/cocina/generator/schema_ref.rb

@@ -8,7 +8,7 @@ module Cocina
         if required && !relaxed
           "attribute(:#{name.camelize(:lower)}, #{schema_doc.name}.default { #{schema_doc.name}.new })"
         else
-          "attribute :#{name.camelize(:lower)}, #{schema_doc.name}.optional.meta(omittable: true)"
+          "attribute? :#{name.camelize(:lower)}, #{schema_doc.name}.optional"
         end
       end
     end

data/lib/cocina/generator/schema_value.rb

@@ -4,15 +4,25 @@ module Cocina
   module Generator
     # Class for generating from an openapi value
     class SchemaValue < SchemaBase
-      # rubocop:disable Layout/LineLength
       def generate
         # optional has to come before default or the default value that gets set will be nil.
-        "#{description}#{example}#{relaxed_comment}attribute :#{name.camelize(:lower)}, Types::#{dry_datatype(schema_doc)}#{optional}#{default}#{enum}#{omittable}"
+        if required && !relaxed
+          "#{preamble}attribute :#{name.camelize(:lower)}, #{type}"
+        else
+          "#{preamble}attribute? :#{name.camelize(:lower)}, #{type}"
+        end
       end
-      # rubocop:enable Layout/LineLength
 
       private
 
+      def type
+        "Types::#{dry_datatype(schema_doc)}#{optional}#{default}#{enum}"
+      end
+
+      def preamble
+        "#{description}#{example}#{relaxed_comment}"
+      end
+
       def enum
         return '' if !schema_doc.enum || relaxed
 
@@ -32,7 +42,7 @@ module Cocina
         # If type is boolean and default is false, erroneously getting a nil.
         # Assuming that if required, then default is false.
         default = schema_doc.default
-        default = false if default.nil? && schema_doc.type == 'boolean' && required
+        default = false if default.nil? && schema_doc.type == 'boolean'
 
         return '' if default.nil?
 

data/lib/cocina/models/access.rb

@@ -5,15 +5,15 @@ module Cocina
     class Access < Struct
       # Access level.
       # Validation of this property is relaxed. See the openapi for full validation.
-      attribute :view, Types::Strict::String.optional.default('dark').meta(omittable: true)
+      attribute? :view, Types::Strict::String.optional.default('dark')
       # Download access level.
       # Validation of this property is relaxed. See the openapi for full validation.
-      attribute :download, Types::Strict::String.optional.default('none').meta(omittable: true)
+      attribute? :download, Types::Strict::String.optional.default('none')
       # Not used for this access type, must be null.
       # Validation of this property is relaxed. See the openapi for full validation.
-      attribute :location, Types::Strict::String.optional.meta(omittable: true)
+      attribute? :location, Types::Strict::String.optional
       # Validation of this property is relaxed. See the openapi for full validation.
-      attribute :controlledDigitalLending, Types::Strict::Bool.optional.meta(omittable: true)
+      attribute? :controlledDigitalLending, Types::Strict::Bool.optional.default(false)
     end
   end
 end

data/lib/cocina/models/admin_policy.rb

@@ -18,7 +18,7 @@ module Cocina
       attribute :label, Types::Strict::String
       attribute :version, Types::Strict::Integer
       attribute(:administrative, AdminPolicyAdministrative.default { AdminPolicyAdministrative.new })
-      attribute :description, Description.optional.meta(omittable: true)
+      attribute? :description, Description.optional
     end
   end
 end

data/lib/cocina/models/admin_policy_access_template.rb

@@ -3,23 +3,23 @@
 module Cocina
   module Models
     class AdminPolicyAccessTemplate < Struct
-      attribute :view, Types::Strict::String.enum('world', 'stanford', 'location-based', 'citation-only', 'dark').meta(omittable: true)
+      attribute? :view, Types::Strict::String.enum('world', 'stanford', 'location-based', 'citation-only', 'dark')
       # Available for controlled digital lending.
-      attribute :controlledDigitalLending, Types::Strict::Bool.meta(omittable: true)
+      attribute? :controlledDigitalLending, Types::Strict::Bool.default(false)
       # The human readable copyright statement that applies
       # example: Copyright World Trade Organization
-      attribute :copyright, Types::Strict::String.optional.meta(omittable: true)
+      attribute? :copyright, Types::Strict::String.optional
       # Download access level. This is used in the transition from Fedora as a way to set a default download level at registration that is copied down to all the files.
 
-      attribute :download, Types::Strict::String.enum('world', 'stanford', 'location-based', 'none').meta(omittable: true)
+      attribute? :download, Types::Strict::String.enum('world', 'stanford', 'location-based', 'none')
       # If access or download is "location-based", this indicates which location should have access. This is used in the transition from Fedora as a way to set a default location at registration that is copied down to all the files.
 
-      attribute :location, Types::Strict::String.optional.enum('spec', 'music', 'ars', 'art', 'hoover', 'm&m').meta(omittable: true)
+      attribute? :location, Types::Strict::String.optional.enum('spec', 'music', 'ars', 'art', 'hoover', 'm&m')
       # The human readable use and reproduction statement that applies
       # example: Property rights reside with the repository. Literary rights reside with the creators of the documents or their heirs. To obtain permission to publish or reproduce, please contact the Public Services Librarian of the Dept. of Special Collections (http://library.stanford.edu/spc).
-      attribute :useAndReproductionStatement, Types::Strict::String.optional.meta(omittable: true)
+      attribute? :useAndReproductionStatement, Types::Strict::String.optional
       # The license governing reuse of the Collection. Should be an IRI for known licenses (i.e. CC, RightsStatement.org URI, etc.).
-      attribute :license, Types::Strict::String.optional.meta(omittable: true)
+      attribute? :license, Types::Strict::String.optional
     end
   end
 end

data/lib/cocina/models/admin_policy_administrative.rb

@@ -7,7 +7,7 @@ module Cocina
       attribute :registrationWorkflow, Types::Strict::Array.of(Types::Strict::String).default([].freeze)
       # An additional workflow to start for objects managed by this admin policy once the end-accession workflow step is complete
       # example: wasCrawlPreassemblyWF
-      attribute :disseminationWorkflow, Types::Strict::String.meta(omittable: true)
+      attribute? :disseminationWorkflow, Types::Strict::String
       attribute :collectionsForRegistration, Types::Strict::Array.of(Types::Strict::String).default([].freeze)
       # example: druid:bc123df4567
       attribute :hasAdminPolicy, Types::Strict::String

data/lib/cocina/models/admin_policy_with_metadata.rb

@@ -18,11 +18,11 @@ module Cocina
       attribute :label, Types::Strict::String
       attribute :version, Types::Strict::Integer
       attribute(:administrative, AdminPolicyAdministrative.default { AdminPolicyAdministrative.new })
-      attribute :description, Description.optional.meta(omittable: true)
+      attribute? :description, Description.optional
       # When the object was created.
-      attribute :created, Types::Params::DateTime.meta(omittable: true)
+      attribute? :created, Types::Params::DateTime
       # When the object was modified.
-      attribute :modified, Types::Params::DateTime.meta(omittable: true)
+      attribute? :modified, Types::Params::DateTime
       # Key for optimistic locking. The contents of the key is not specified.
       attribute :lock, Types::Strict::String
     end

data/lib/cocina/models/builders/dro_rights_description_builder.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Builders
+      # Rights description builder for items
+      class DroRightsDescriptionBuilder < RightsDescriptionBuilder
+        # @param [Cocina::Models::DRO] cocina_item
+
+        # This overrides the superclass
+        # @return [Cocina::Models::DROAccess]
+        def object_access
+          @object_access ||= cocina.access
+        end
+
+        private
+
+        def object_level_access
+          super + access_level_from_files.uniq.map { |str| "#{str} (file)" }
+        end
+
+        def access_level_from_files
+          # dark access doesn't permit any file access
+          return [] if object_access.view == 'dark'
+
+          file_access_nodes.reject { |fa| same_as_object_access?(fa) }.flat_map do |fa|
+            file_access_from_file(fa)
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def file_access_from_file(file_access)
+          basic_access = if file_access[:view] == 'location-based'
+                           "location: #{file_access[:location]}"
+                         else
+                           file_access[:view]
+                         end
+
+          return [basic_access] if file_access[:view] == file_access[:download]
+
+          basic_access += ' (no-download)' if file_access[:view] != 'dark'
+
+          case file_access[:download]
+          when 'stanford'
+            [basic_access, 'stanford']
+          when 'location-based'
+            # Here we're using location to mean download location.
+            [basic_access, "location: #{file_access[:location]}"]
+          else
+            [basic_access]
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def same_as_object_access?(file_access)
+          (file_access[:view] == object_access.view && file_access[:download] == object_access.download) ||
+            (object_access.view == 'citation-only' && file_access[:view] == 'dark')
+        end
+
+        def file_access_nodes
+          Array(cocina.structural.contains)
+            .flat_map { |fs| Array(fs.structural.contains) }
+            .map { |file| file.access.to_h }
+            .uniq
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/builders/name_title_group_builder.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Builders
+      # Helpers for MODS nameTitleGroups.
+      #   MODS titles need to know if they match a contributor and thus need a nameTitleGroup
+      #   MODS contributors need to know if they match a title and thus need a nameTitleGroup
+      #     If there is a match, the nameTitleGroup number has to be consistent for the matching title(s)
+      #     and the contributor(s)
+      class NameTitleGroupBuilder
+        # When to assign nameTitleGroup to MODS from cocina:
+        #   for cocina title of type "uniform",
+        #     look for cocina title properties :value or :structuredValue (recurse down through :parallelValue
+        #     as needed), and look for associated :note with :type of "associated name" at the level of the
+        #     non-empty title [value|structuredValue]
+        #     The note of type "associated name" will have [value|structuredValue] which will match
+        #     [value|structuredValue] for a contributor (possibly after recursing through :parallelValue).
+        #   Thus, a title [value|structuredValue] and a contributor [value|structuredValue] are associated in
+        #   cocina.
+        #
+        # If those criteria not met in Cocina, do not assign nameTitleGroup in MODS
+        #
+        # @params [Cocina::Models::Title] title
+        # @return [Hash<Hash, Hash>] key:  hash of value or structuredValue property for title
+        #   value: hash of value or structuredValue property for contributor
+        #   e.g. {{:value=>"Portrait of the artist as a young man"}=>{:value=>"James Joyce"}}
+        #   e.g. {{:value=>"Portrait of the artist as a young man"}=>{:structuredValue=>
+        #         [{:value=>"Joyce, James", :type=>"name"},{:value=>"1882-1941", :type=>"life dates"}]}}
+        #   e.g. {{:structuredValue=>[{:value=>"Demanding Food", :type=>"main"},
+        #           {:value=>"A Cat's Life", :type=>"subtitle"}]}=>{:value=>"James Joyce"}}
+        #   this complexity is needed for multilingual titles mapping to multilingual names.
+        def self.build_title_values_to_contributor_name_values(title)
+          result = {}
+          return result if title.blank?
+
+          # pair title value with contributor name value
+          title_value_note_slices(title).each do |value_note_slice|
+            title_val_slice = slice_of_value_or_structured_value(value_note_slice)
+            next if title_val_slice.blank?
+
+            associated_name_note = value_note_slice[:note]&.detect { |note| note[:type] == 'associated name' }
+            next if associated_name_note.blank?
+
+            # relevant note will be Array of either
+            #   {
+            #     value: 'string contributor name',
+            #     type: 'associated name'
+            #   }
+            # OR
+            #   {
+            #     structuredValue: [ structuredValue contributor name ],
+            #     type: 'associated name'
+            #   }
+            # and we want the hash without the :type attribute
+            result[title_val_slice] = slice_of_value_or_structured_value(associated_name_note)
+          end
+          result
+        end
+
+        def self.contributor_for_contributor_name_value_slice(contributor_name_value_slice:, contributors:)
+          Array(contributors).find do |contributor|
+            contrib_name_value_slices = contributor_name_value_slices(contributor)
+            contrib_name_value_slices.include?(contributor_name_value_slice)
+          end
+        end
+
+        # @params [Cocina::Models::Contributor] contributor
+        # @return [Hash] where we are only interested in
+        #   hashes containing (either :value or :structureValue)
+        def self.contributor_name_value_slices(contributor)
+          return if contributor&.name.blank?
+
+          slices = []
+          Array(contributor.name).each do |contrib_name|
+            slices << value_slices(contrib_name)
+          end
+          slices.flatten
+        end
+
+        # @params [Cocina::Models::DescriptiveValue] desc_value
+        # @return [Array<Cocina::Models::DescriptiveValue>] where we are only interested in
+        #   hashes containing (either :value or :structuredValue)
+        def self.value_slices(desc_value)
+          slices = []
+          desc_value_slice = desc_value.to_h.slice(:value, :structuredValue, :parallelValue)
+          if desc_value_slice[:value].present? || desc_value_slice[:structuredValue].present?
+            slices << desc_value_slice.select { |_k, value| value.present? }
+          elsif desc_value_slice[:parallelValue].present?
+            desc_value_slice[:parallelValue].each { |parallel_val| slices << value_slices(parallel_val) }
+          end
+          # ignoring groupedValue
+          slices.flatten
+        end
+        # private_class_method :value_slices
+
+        # for a given Hash (from a Cocina DescriptiveValue or Title or Name or ...)
+        # result will be either
+        #   { value: 'string value' }
+        # OR
+        #   { structuredValue: [ some structuredValue ] }
+        def self.slice_of_value_or_structured_value(hash)
+          if hash[:value].present?
+            hash.slice(:value).select { |_k, value| value.present? }
+          elsif hash[:structuredValue].present?
+            hash.slice(:structuredValue).select { |_k, value| value.present? }
+          end
+        end
+
+        # reduce parallelValues down to value or structuredValue for these slices
+        # @params [Cocina::Models::Title] title
+        # @return [Array<Cocina::Models::DescriptiveValue>] where we are only interested in
+        #   hashes containing (either :value or :structureValue) and :note if present
+        def self.title_value_note_slices(title)
+          slices = []
+          title_slice = title.to_h.slice(:value, :structuredValue, :parallelValue, :note)
+          if title_slice[:value].present? || title_slice[:structuredValue].present?
+            slices << title_slice.select { |_k, value| value.present? }
+          elsif title_slice[:parallelValue].present?
+            title_slice[:parallelValue].each do |parallel_val|
+              slices << title_value_note_slices(parallel_val)
+            end
+          end
+          # ignoring groupedValue
+          slices.flatten
+        end
+      end
+    end
+  end
+end

data/lib/cocina/models/builders/rights_description_builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    module Builders
+      # RightsDescriptionBuilder
+      class RightsDescriptionBuilder
+        # @param [Cocina::Models::AdminPolicy, Cocina::Models::DRO] cocina_object
+        def self.build(cocina_object)
+          new(cocina_object).build
+        end
+
+        def initialize(cocina_object)
+          @cocina = cocina_object
+        end
+
+        # This is set up to work for APOs, but this method is to be overridden on sub classes
+        # @return [Cocina::Models::AdminPolicyDefaultAccess]
+        def object_access
+          @object_access ||= cocina.administrative.accessTemplate
+        end
+
+        def build
+          return 'controlled digital lending' if object_access.controlledDigitalLending
+
+          return ['dark'] if object_access.view == 'dark'
+
+          object_level_access
+        end
+
+        private
+
+        attr_reader :cocina
+
+        # rubocop:disable Metrics/MethodLength
+        def object_level_access
+          case object_access.view
+          when 'citation-only'
+            ['citation']
+          when 'world'
+            world_object_access
+          when 'location-based'
+            case object_access.download
+            when 'none'
+              ["location: #{object_access.location} (no-download)"]
+            else
+              ["location: #{object_access.location}"]
+            end
+          when 'stanford'
+            stanford_object_access
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def stanford_object_access
+          case object_access.download
+          when 'none'
+            ['stanford (no-download)']
+          when 'location-based'
+            # this is an odd case we might want to move away from. See https://github.com/sul-dlss/cocina-models/issues/258
+            ['stanford (no-download)', "location: #{object_access.location}"]
+          else
+            ['stanford']
+          end
+        end
+
+        def world_object_access
+          case object_access.download
+          when 'stanford'
+            ['stanford', 'world (no-download)']
+          when 'none'
+            ['world (no-download)']
+          when 'world'
+            ['world']
+          when 'location-based'
+            # this is an odd case we might want to move away from. See https://github.com/sul-dlss/cocina-models/issues/258
+            ['world (no-download)', "location: #{object_access.location}"]
+          end
+        end
+      end
+    end
+  end
+end