cocina-models 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76b2604162a420ba454bf72d767dd17cffd588c585644e7af5713a626528c354
-  data.tar.gz: a120a35df55448923beb33b256001ea711de2a41b89a6b353e7eb8770aea160c
+  metadata.gz: ae254699614b4355dea34dab3e0ef324123b21d30d592c24ceffbad5fed3515e
+  data.tar.gz: da8eecbff7bec360ed56445d61fc558b4a18684df9f0f92bc4a98668e2d16dac
 SHA512:
-  metadata.gz: 8339f6d67fa9ce0d717383e377d68c935ec77b6eab99248a74ea0b70ef74379c449a9a004942d5495df97f3a00aedb671323cdd9a1f040961d7b85c285094c64
-  data.tar.gz: c1e9c0dd4dbd1c079e863d914519e7c173d79eb85e164a1c2121b69b23d87b3323823c93e52fcd4227fde46338c6987bef4ec75d85b3517a62869ac5eb40a259
+  metadata.gz: 4c6c2e1beb7cd1b28d73bee2641be223497e18764bbffae9953fde54995336ae970be70e8d1ac31fa96f131ad9c17a02b2a5ef7b9e9beb098ecf9925899333ad
+  data.tar.gz: 53246fecec8a7e4516aa3fef318dddfa644158678f4894d1eeb1285d0c247b6a2bdafd68a491ae18b19e41fa5a195bc2f078ba303adb9f83f37b26c4121585cf

data/.rubocop.yml

@@ -4,13 +4,16 @@ inherit_from: .rubocop_todo.yml
 require:
   - rubocop-rspec
 
+Metrics/LineLength:
+  Max: 114
+  Exclude:
+    - lib/cocina/models/*
+
 Metrics/BlockLength:
   Exclude:
+    - cocina-models.gemspec
     - spec/cocina/**/*
 
-Metrics/LineLength:
-  Max: 114
-
 Metrics/MethodLength:
   Max: 14
 
@@ -19,3 +22,7 @@ RSpec/MultipleExpectations:
 
 RSpec/ExampleLength:
   Max: 18
+
+Style/Documentation:
+  Exclude:
+    - lib/cocina/models/*

data/README.md

@@ -11,6 +11,17 @@ It provides a way for consumers to validate objects against models using dry-str
 
 This is a work in progress that will ultimately implement the full [COCINA data model](http://sul-dlss.github.io/cocina-models/). See also [architecture documentation](https://sul-dlss.github.io/taco-truck/COCINA.html#cocina-data-models--shapes).
 
+## Generate models from openapi.yml
+
+### All
+```
+exe/generator generate
+```
+
+### Single model
+```
+exe/generator generate_schema DRO
+```
 
 ## Generate Documentation
 

data/cocina-models.gemspec

@@ -23,11 +23,16 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_dependency 'activesupport'
   spec.add_dependency 'dry-struct', '~> 1.0'
   spec.add_dependency 'dry-types', '~> 1.1'
+  spec.add_dependency 'openapi3_parser' # Parsing openapi doc
+  spec.add_dependency 'openapi_parser' # Validating openapi requests
+  spec.add_dependency 'thor'
   spec.add_dependency 'zeitwerk', '~> 2.1'
 
   spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'committee'
   spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.74.0'

data/exe/generator

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+$LOAD_PATH.unshift 'lib'
+
+require 'cocina/generator'
+
+Cocina::Generator::Generator.start(ARGV)

data/lib/cocina/generator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+require 'yaml'
+require 'active_support/core_ext/string'
+require 'thor'
+require 'openapi3_parser'
+require 'byebug'
+
+loader = Zeitwerk::Loader.new
+loader.push_dir(File.absolute_path("#{__FILE__}/../.."))
+loader.setup
+
+module Cocina
+  # Module for generating Cocina models from openapi.
+  module Generator
+  end
+end

data/lib/cocina/generator/generator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Generator
+    # Class for generating Cocina models from openapi.
+    class Generator < Thor
+      include Thor::Actions
+
+      class_option :openapi, desc: 'Path of openapi.yml', default: 'openapi.yml'
+      class_option :output, desc: 'Path for output', default: 'lib/cocina/models'
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      desc 'generate', 'generate for all schemas'
+      def generate
+        clean_output
+
+        schemas.keys.each do |schema_name|
+          schema = schema_for(schema_name)
+          generate_for(schema) if schema
+        end
+
+        generate_vocab
+      end
+
+      desc 'generate_schema SCHEMA_NAME', 'generate for SCHEMA_NAME'
+      def generate_schema(schema_name)
+        schema = schema_for(schema_name)
+        raise 'Cannot generate' if schema.nil?
+
+        FileUtils.mkdir_p(options[:output])
+
+        generate_for(schema)
+      end
+
+      desc 'generate_vocab', 'generate vocab'
+      def generate_vocab
+        vocab = Vocab.new(schemas)
+        filepath = "#{options[:output]}/#{vocab.filename}"
+        FileUtils.rm_f(filepath)
+
+        create_file filepath, vocab.generate
+        run("rubocop -a #{filepath}")
+      end
+
+      private
+
+      def schemas
+        @schemas ||= Openapi3Parser.load_file(options[:openapi]).components.schemas
+      end
+
+      def schema_for(schema_name)
+        schema_doc = schemas[schema_name]
+        return nil if schema_doc.nil? || schema_doc.type != 'object'
+
+        Schema.new(schema_doc)
+      end
+
+      def generate_for(schema)
+        filepath = "#{options[:output]}/#{schema.filename}"
+        FileUtils.rm_f(filepath)
+
+        create_file filepath, schema.generate
+        run("rubocop -a #{filepath}")
+      end
+
+      def clean_output
+        FileUtils.mkdir_p(options[:output])
+        files = Dir.glob("#{options[:output]}/*.rb")
+        # Leave alone
+        files.delete("#{options[:output]}/version.rb")
+        files.delete("#{options[:output]}/checkable.rb")
+        files.delete("#{options[:output]}/validator.rb")
+        FileUtils.rm_f(files)
+      end
+    end
+  end
+end

data/lib/cocina/generator/schema.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Generator
+    # Class for generating from an openapi schema
+    class Schema < SchemaBase
+      def schema_properties
+        @schema_properties ||= schema_doc.properties.map do |key, properties_doc|
+          property_class_for(properties_doc).new(properties_doc,
+                                                 key: key,
+                                                 required: schema_doc.requires?(properties_doc),
+                                                 parent: self)
+        end
+      end
+
+      def generate
+        <<~RUBY
+          # frozen_string_literal: true
+
+          module Cocina
+            module Models
+              class #{name} < Struct
+
+                #{types}
+
+                #{model_attributes}
+
+                #{validate}
+              end
+            end
+          end
+        RUBY
+      end
+
+      private
+
+      def property_class_for(properties_doc)
+        case properties_doc.type
+        when 'object'
+          # As a useful simplification, all objects must be references to schemas.
+          raise "Must use a reference for #{schema_doc.inspect}" unless properties_doc.name
+
+          SchemaRef
+        when 'array'
+          SchemaArray
+        else
+          SchemaValue
+        end
+      end
+
+      def model_attributes
+        schema_properties.map(&:generate).join("\n")
+      end
+
+      def types
+        type_properties_doc = schema_doc.properties['type']
+        return '' if type_properties_doc.nil?
+
+        types_list = type_properties_doc.enum.map { |item| "'#{item}'" }.join(",\n ")
+
+        <<~RUBY
+          include Checkable
+
+          TYPES = [#{types_list}].freeze
+        RUBY
+      end
+
+      def validate
+        return '' unless validatable?
+
+        <<~RUBY
+          def self.new(attributes = default_attributes, safe = false, validate = true, &block)
+            Validator.validate(self, attributes.with_indifferent_access) if validate
+            super(attributes, safe, &block)
+                end
+        RUBY
+      end
+
+      def validatable?
+        !schema_doc.node_context.document.paths["/validate/#{schema_doc.name}"].nil?
+      end
+    end
+  end
+end

data/lib/cocina/generator/schema_array.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cocina
+  module Generator
+    # Class for generating from an openapi array
+    class SchemaArray < SchemaBase
+      def generate
+        "attribute :#{name.camelize(:lower)}, Types::Strict::Array.of(#{schema_doc.items.name})#{omittable}"
+      end
+
+      def omittable
+        if required
+          '.default([].freeze)'
+        else
+          '.meta(omittable: true)'
+        end
+      end
+    end
+  end
+end

data/lib/cocina/generator/schema_base.rb

@@ -0,0 +1,49 @@
+# 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
+    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,60 @@
+# 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}#{default}#{enum}#{omittable}"
+      end
+      # rubocop:enable Metrics/LineLength
+
+      private
+
+      def dry_datatype
+        case schema_doc.type
+        when 'integer'
+          'Strict::Integer'
+        when 'string'
+          string_dry_datatype
+        when 'boolean'
+          'Strict::Bool'
+        else
+          raise "#{schema_doc.type} not supported"
+        end
+      end
+
+      def string_dry_datatype
+        case schema_doc.format
+        when 'date-time'
+          'Params::DateTime'
+        else
+          'Strict::String'
+        end
+      end
+
+      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