cocina-models 0.29.0 → 0.33.0

data/lib/cocina/generator/schema_base.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Generator
+    # Base class for generating from openapi
+    class SchemaBase
+      attr_reader :schema_doc, :key, :required, :parent
+
+      def initialize(schema_doc, key: nil, required: false, parent: nil)
+        @schema_doc = schema_doc
+        @key = key
+        @required = required
+        @parent = parent
+      end
+
+      def filename
+        "#{name.underscore}.rb"
+      end
+
+      def name
+        key || schema_doc.name
+      end
+
+      def omittable
+        return '' if required
+
+        '.meta(omittable: true)'
+      end
+
+      def quote(item)
+        return item unless schema_doc.type == 'string'
+
+        "'#{item}'"
+      end
+
+      def description
+        return '' unless schema_doc.description
+
+        "# #{schema_doc.description}\n"
+      end
+
+      def example
+        return '' unless schema_doc.example
+
+        "# example: #{schema_doc.example}\n"
+      end
+
+      def dry_datatype(doc)
+        case doc.type
+        when 'integer'
+          'Strict::Integer'
+        when 'string'
+          string_dry_datatype(doc)
+        when 'boolean'
+          'Strict::Bool'
+        else
+          raise "#{schema_doc.type} not supported"
+        end
+      end
+
+      def string_dry_datatype(doc)
+        case doc.format
+        when 'date-time'
+          'Params::DateTime'
+        else
+          'Strict::String'
+        end
+      end
+    end
+  end
+end

data/lib/cocina/generator/schema_ref.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Generator
+    # Class for generating from an openapi reference
+    class SchemaRef < SchemaBase
+      def generate
+        if required
+          "attribute(:#{name.camelize(:lower)}, #{schema_doc.name}.default { #{schema_doc.name}.new })"
+        else
+          "attribute :#{name.camelize(:lower)}, #{schema_doc.name}.optional.meta(omittable: true)"
+        end
+      end
+    end
+  end
+end

data/lib/cocina/generator/schema_value.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Generator
+    # Class for generating from an openapi value
+    class SchemaValue < SchemaBase
+      # rubocop:disable Metrics/LineLength
+      def generate
+        "#{description}#{example}attribute :#{name.camelize(:lower)}, Types::#{dry_datatype(schema_doc)}#{default}#{enum}#{omittable}"
+      end
+      # rubocop:enable Metrics/LineLength
+
+      private
+
+      def enum
+        return '' unless schema_doc.enum
+
+        items = use_types? ? "*#{parent.name}::TYPES" : schema_doc.enum.map { |item| quote(item) }.join(', ')
+
+        ".enum(#{items})"
+      end
+
+      def use_types?
+        parent.is_a?(Schema) && key == 'type'
+      end
+
+      def default
+        # 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
+        return '' if default.nil?
+
+        ".default(#{quote(default)})"
+      end
+    end
+  end
+end

data/lib/cocina/generator/vocab.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Generator
+    # Class for generating a vocab
+    class Vocab
+      def initialize(schemas)
+        @schemas = schemas
+      end
+
+      def filename
+        'vocab.rb'
+      end
+
+      def generate
+        <<~RUBY
+                    # frozen_string_literal: true
+
+                    module Cocina
+                      module Models
+                        # A digital repository object.  See http://sul-dlss.github.io/cocina-models/maps/DRO.json
+                        class Vocab
+
+          #{vocab_methods}
+
+                        end
+                      end
+          end
+        RUBY
+      end
+
+      private
+
+      attr_reader :schemas
+
+      # rubocop:disable Style/MultilineBlockChain
+      def vocabs
+        schemas.values.map do |schema|
+          type_property = schema.properties['type']
+          type_property.nil? ? [] : type_property.enum.to_a
+        end
+               .flatten
+               .uniq
+               .sort
+               .filter { |vocab| vocab.start_with?('http://cocina.sul.stanford.edu/models') }
+      end
+      # rubocop:enable Style/MultilineBlockChain
+
+      def vocab_methods
+        # Note special handling of 3d
+        vocabs.map do |vocab|
+          name = vocab[38, vocab.size - 45].gsub('-', '_').gsub('3d', 'three_dimensional')
+          <<~RUBY
+            def self.#{name}
+              "#{vocab}"
+            end
+
+          RUBY
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/cocina/models.rb

@@ -5,23 +5,37 @@ require 'zeitwerk'
 require 'dry-struct'
 require 'dry-types'
 require 'json'
+require 'yaml'
+require 'openapi_parser'
+require 'openapi3_parser'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string'
+require 'thor'
 
 # Help Zeitwerk find some of our classes
 class CocinaModelsInflector < Zeitwerk::Inflector
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/MethodLength
   def camelize(basename, _abspath)
     case basename
     when 'dro'
       'DRO'
-    when 'dro_builder'
-      'DROBuilder'
     when 'request_dro'
       'RequestDRO'
+    when 'dro_access'
+      'DROAccess'
+    when 'dro_structural'
+      'DROStructural'
+    when 'request_dro_structural'
+      'RequestDROStructural'
     when 'version'
       'VERSION'
     else
       super
     end
   end
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/MethodLength
 end
 
 loader = Zeitwerk::Loader.new
@@ -36,43 +50,58 @@ module Cocina
     # Raised when the type attribute is not valid.
     class UnknownTypeError < Error; end
 
+    # Raised when an error occurs validating against openapi.
+    class ValidationError < Error; end
+
     # Base class for Cocina Structs
     class Struct < Dry::Struct
       transform_keys(&:to_sym)
+      schema schema.strict
+    end
+
+    # DRY Types
+    module Types
+      include Dry.Types()
     end
 
     # @param [Hash] dyn a ruby hash representation of the JSON serialization of a collection or DRO
-    # @return [DRO,Collection]
+    # @param [boolean] validate
+    # @return [DRO,Collection,AdminPolicy]
     # @raises [UnknownTypeError] if a valid type is not found in the data
     # @raises [KeyError] if a type field cannot be found in the data
-    def self.build(dyn)
-      case dyn.fetch('type')
-      when *DRO::TYPES
-        DRO.new(dyn)
-      when *Collection::TYPES
-        Collection.new(dyn)
-      when *AdminPolicy::TYPES
-        AdminPolicy.new(dyn)
-      else
-        raise UnknownTypeError, "Unknown type: '#{dyn.fetch('type')}'"
-      end
+    # @raises [ValidationError] if hash representation fails openapi validation
+    def self.build(dyn, validate: true)
+      clazz = case dyn.fetch('type')
+              when *DRO::TYPES
+                DRO
+              when *Collection::TYPES
+                Collection
+              when *AdminPolicy::TYPES
+                AdminPolicy
+              else
+                raise UnknownTypeError, "Unknown type: '#{dyn.fetch('type')}'"
+              end
+      clazz.new(dyn, false, validate)
     end
 
     # @param [Hash] dyn a ruby hash representation of the JSON serialization of a request for a Collection or DRO
+    # @param [boolean] validate
     # @return [RequestDRO,RequestCollection,RequestAdminPolicy]
     # @raises [UnknownTypeError] if a valid type is not found in the data
     # @raises [KeyError] if a type field cannot be found in the data
-    def self.build_request(dyn)
-      case dyn.fetch('type')
-      when *DRO::TYPES
-        RequestDRO.new(dyn)
-      when *Collection::TYPES
-        RequestCollection.new(dyn)
-      when *AdminPolicy::TYPES
-        RequestAdminPolicy.new(dyn)
-      else
-        raise UnknownTypeError, "Unknown type: '#{dyn.fetch('type')}'"
-      end
+    # @raises [ValidationError] if hash representation fails openapi validation
+    def self.build_request(dyn, validate: true)
+      clazz = case dyn.fetch('type')
+              when *DRO::TYPES
+                RequestDRO
+              when *Collection::TYPES
+                RequestCollection
+              when *AdminPolicy::TYPES
+                RequestAdminPolicy
+              else
+                raise UnknownTypeError, "Unknown type: '#{dyn.fetch('type')}'"
+              end
+      clazz.new(dyn, false, validate)
     end
   end
 end

data/lib/cocina/models/access.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    class Access < Struct
+      # Access level
+      attribute :access, Types::Strict::String.default('dark').enum('world', 'stanford', 'location-based', 'citation-only', 'dark').meta(omittable: true)
+      # Download access level for a file
+      attribute :download, Types::Strict::String.default('none').enum('world', 'stanford', 'location-based', 'none').meta(omittable: true)
+      # If access is "location-based", which location should have access.
+      attribute :readLocation, Types::Strict::String.enum('spec', 'music', 'ars', 'art', 'hoover', 'm&m').meta(omittable: true)
+    end
+  end
+end

data/lib/cocina/models/admin_policy.rb

@@ -2,67 +2,24 @@
 
 module Cocina
   module Models
-    # An admin policy object.
     class AdminPolicy < Struct
       include Checkable
 
-      TYPES = [
-        Vocab.admin_policy
-      ].freeze
+      TYPES = ['http://cocina.sul.stanford.edu/models/admin_policy.jsonld'].freeze
 
-      # Subschema for access concerns
-      class Access < Struct
-      end
-
-      # Subschema for administrative concerns
-      class Administrative < Struct
-        # This was copied from the ActiveFedora defaults: Dor::AdminPolicyObject.new.defaultObjectRights.content
-        DEFAULT_OBJECT_RIGHTS = <<~XML
-          <?xml version="1.0" encoding="UTF-8"?>
-
-          <rightsMetadata>
-             <access type="discover">
-                <machine>
-                   <world/>
-                </machine>
-             </access>
-             <access type="read">
-                <machine>
-                   <world/>
-                </machine>
-             </access>
-             <use>
-                <human type="useAndReproduction"/>
-                <human type="creativeCommons"/>
-                <machine type="creativeCommons" uri=""/>
-                <human type="openDataCommons"/>
-                <machine type="openDataCommons" uri=""/>
-             </use>
-             <copyright>
-                <human/>
-             </copyright>
-          </rightsMetadata>
-        XML
-
-        # An XML blob that is to be used temporarily until we model rights
-        attribute :default_object_rights, Types::Strict::String.optional.default(DEFAULT_OBJECT_RIGHTS)
-
-        # which workflow to start when registering (used by Web Archive apos to start wasCrawlPreassemblyWF)
-        attribute :registration_workflow, Types::String.optional.default(nil)
-
-        # TODO: Allowing hasAdminPolicy to be omittable for now (until rolled out to consumers),
-        # but I think it's actually required for every Admin Policy
-        attribute :hasAdminPolicy, Types::Strict::String.optional.default(nil)
-      end
-
-      class Identification < Struct
-      end
-
-      class Structural < Struct
-      end
-
-      include AdminPolicyAttributes
+      # example: item
+      attribute :type, Types::Strict::String.enum(*AdminPolicy::TYPES)
+      # example: druid:bc123df4567
       attribute :externalIdentifier, Types::Strict::String
+      attribute :label, Types::Strict::String
+      attribute :version, Types::Strict::Integer
+      attribute(:administrative, AdminPolicyAdministrative.default { AdminPolicyAdministrative.new })
+      attribute :description, Description.optional.meta(omittable: true)
+
+      def self.new(attributes = default_attributes, safe = false, validate = true, &block)
+        Validator.validate(self, attributes.with_indifferent_access) if validate && name
+        super(attributes, safe, &block)
+      end
     end
   end
 end

data/lib/cocina/models/admin_policy_administrative.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    class AdminPolicyAdministrative < Struct
+      attribute :defaultObjectRights, Types::Strict::String.default('<?xml version="1.0" encoding="UTF-8"?><rightsMetadata><access type="discover"><machine><world/></machine></access><access type="read"><machine><world/></machine></access><use><human type="useAndReproduction"/><human type="creativeCommons"/><machine type="creativeCommons" uri=""/><human type="openDataCommons"/><machine type="openDataCommons" uri=""/></use><copyright><human/></copyright></rightsMetadata>').meta(omittable: true)
+      attribute :registrationWorkflow, Types::Strict::String.meta(omittable: true)
+      attribute :hasAdminPolicy, Types::Strict::String.meta(omittable: true)
+    end
+  end
+end

data/lib/cocina/models/administrative.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    class Administrative < Struct
+      # example: druid:bc123df4567
+      attribute :hasAdminPolicy, Types::Strict::String.meta(omittable: true)
+      attribute :releaseTags, Types::Strict::Array.of(ReleaseTag).meta(omittable: true)
+      # Administrative or Internal project this resource is a part of
+      # example: Google Books
+      attribute :partOfProject, Types::Strict::String.meta(omittable: true)
+    end
+  end
+end

data/lib/cocina/models/applies_to.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Models
+    class AppliesTo < Struct
+      attribute :appliesTo, Types::Strict::Array.of(DescriptiveBasicValue).meta(omittable: true)
+    end
+  end
+end