sober_swag 0.10.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 528d6bf46f7f7821eb2009cafaa55fd5536a29dbfffd8a3ada81319089e08f89
-  data.tar.gz: b484dd89af8defeb7c878403f843793f03b2695af543a07843ca72417f9cc4ec
+  metadata.gz: ff24aa407a6b8360569931c050bee2958cb6e3169f34f57f1d455f0d573327af
+  data.tar.gz: 61bf1feb701ae67e2a2fd85f41ab2d8ccd25d5e512a4cd26e3849f65e78a14e9
 SHA512:
-  metadata.gz: db8538a1e6416be18ce5b08517a1cf90c48192936b820a689af79870b6fc4b12e392a97a4fdbb01086952aa443212fc1d5bb87c64f389a86ee2696c2fd8a8868
-  data.tar.gz: cf386e6e54f6dafb5bd307196b5d193577d04ce56e986c03e1b69bb14592963fd6c226a7220b0074c7ea446582d3b361f05250033203448eeec84313da2b26b5
+  metadata.gz: 46c72426dcabb170bf8c5416e8583c254a9c627f8a6cf48424145dc688c9abcb2f7c6e61c87c55da0b8f66f9d076254cce3f815616c9f03eaa88aa14b19c72e4
+  data.tar.gz: a13ac7c92fdaec126d93a3400e13f93287c993bd19c82caa76cc662112e82983a64de5233adfce1cd30a32bfdca6ecc794b5f06a15f7cc2ffda0bbd155b1d0a5

data/.github/workflows/lint.yml

@@ -1,15 +1,52 @@
-name: Linters
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
 
-on: [push]
+name: Ruby Lint
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
 
 jobs:
-  build:
+  test:
+
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [ '2.6', '2.7' ]
+
     steps:
-    - uses: actions/checkout@v1
-    - name: Rubocop Linter
-      uses: andrewmcodes/rubocop-linter-action@v3.0.0
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@ec106b438a1ff6ff109590de34ddc62c540232e0
+      with:
+        ruby-version:  ${{ matrix.ruby }}
+    - uses: actions/cache@v2
+      with:
+        path: vendor/bundle
+        key: ${{ runner.os }}-${{ matrix.ruby }}-gem-deps-${{ hashFiles('**/Gemfile.lock') }}
+        restore-keys: |
+          ${{ runner.os }}-${{ matrix.ruby }}-gem-deps-
+    - name: Install dependencies
+      run: |
+        bundle config path vendor/bundle
+        bundle install
+        gem install rubocop
+        gem install rubocop-rspec
+    - name: Run Lints
+      run: rubocop lib spec example
+    - uses: actions/cache@v2
       with:
-        action_config_path: '.github/config/rubocop_linter_action.yml' # Note: this is the default location
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        path: example/vendor/bundle
+        key: ${{ runner.os }}-${{ matrix.ruby }}-example-deps-${{ hashFiles('example/**/Gemfile.lock') }}
+        restore-keys: |
+          ${{ runner.os }}-${{ matrix.ruby }}-example-deps-

data/.rubocop.yml

@@ -24,6 +24,8 @@ RSpec/ImplicitBlockExpectation:
   Enabled: false
 RSpec/ImplicitExpect:
   EnforcedStyle: should
+RSpec/LeadingSubject:
+  Enabled: false
 Style/MultilineBlockChain:
   Enabled: false
 Metrics/AbcSize:
@@ -79,3 +81,5 @@ Style/RedundantRegexpEscape:
   Enabled: true
 Style/SlicingWithRange:
   Enabled: true
+RSpec/NestedGroups:
+  Max: 5

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## V0.15.0: 2020-09-02
+
+- Add `multi` to Output Objects, as a way to define more than one field of the same type at once.
+- Add an `inherits:` key to output objects, for view inheritance.
+- Add `SoberSwag::Types::CommaArray`, which parses comma-separated strings into arrays.
+  This also sets `style` to `form` and `explode` to `false` when generating Swagger docs.
+  This class is mostly useful for query parameters where you want a simpler format: `tag=foo,bar` instead of `tag[]=foo,tag[]=bar`.
+- Add support for using `meta` to specify alternative `style` and `explode` keys for query and path params.
+  Note that this support *does not* extend to parsing: If you modify the `style` or `explode` keywords, you will need to make those input formats work with the actual type yourself.

data/bin/console

@@ -1,48 +1,36 @@
 #!/usr/bin/env ruby
-# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'sober_swag'
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-module Types
-  include Dry.Types()
-end
+require 'pry'
 
 Bio = SoberSwag.input_object do
-  attribute :name, primitive(:String).meta(description: 'A very basic bio name')
+  attribute :description, SoberSwag::Types::String
+  attribute :gender, SoberSwag::Types::String.enum('male', 'female') | SoberSwag::Types::String
 end
 
 Person = SoberSwag.input_object do
-  attribute :name, primitive(:String).meta(description: 'The full name description')
-  attribute :age, param(:Integer).constrained(gt: 0).optional.meta(description: 'My cool age')
-  attribute? :mood, Types::String
+  attribute :name, SoberSwag::Types::String
+  attribute? :bio, Bio.optional
 end
 
-##
-# Demonstration of subclass-style.
-class PersonSearch < SoberSwag::InputObject
-  attribute? :name, Types::String
-  attribute? :age, Types::Integer
+MultiFloorLocation = SoberSwag.input_object do
+  attribute :building, SoberSwag::Types::String.enum('science', 'mathematics', 'literature')
+  attribute :floor, SoberSwag::Types::String
+  attribute :room, SoberSwag::Types::Integer
 end
 
-##
-# Demonstration of subclass-style *and* recursion in structs.
-class LinkedList < SoberSwag::InputObject
-  attribute :value, Types::String
-  attribute? :next, LinkedList
+SingleFloorLocation = SoberSwag.input_object do
+  attribute :building, SoberSwag::Types::String.enum('philosophy', 'computer science')
+  attribute :room, SoberSwag::Types::Integer
 end
 
-Foo = SoberSwag::OutputObject.define do
-  field :name, primitive(:String)
-  field :age, primitive(:String)
-
-  view :foo do
-    field :bar, primitive(:String).optional
-  end
+SchoolClass = SoberSwag.input_object do
+  attribute :prof, Person.meta(description: 'The person who teaches this class.')
+  attribute :students, SoberSwag::Types::Array.of(Person)
+  attribute :location, (SingleFloorLocation | MultiFloorLocation).meta(description: 'What building and room this is in')
 end
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-require 'pry'
+SortDirections = SoberSwag::Types::CommaArray.of(SoberSwag::Types::String.enum('created_at', 'updated_at', '-created_at', '-updated_at'))
+
 Pry.start

data/docs/serializers.md

@@ -135,6 +135,22 @@ We can see a few things here:
 2. You must provide types with field names
 3. You can use blocks to do data formatting, which lets you pick different fields and such.
 
+
+### Multi
+
+If you have a few fields of the same type, you can use `#multi` to define them all at once:
+
+```ruby
+StudentOutputObject = SoberSwag::OutputObject.define do
+  multi [:first_name, :last_name], primitive(:String)
+  field :recent_grades, primitive(:Integer).array do |student|
+    student.graded_assignments.limit(100).pluck(:grade)
+  end
+end
+```
+
+This saves a bit of typing, and can help with refactoring later.
+
 ### Views
 
 Sometimes, you might want to add "variant" ways to look at data.
@@ -201,3 +217,50 @@ end
 ```
 
 For clarity (and to prevent infinitely-looping serializers on accident, we recommend you *always* use an explicit view for dependent output objects.
+
+### "Inheritance"
+
+Output objects don't support inheritance.
+You can't have one output object based on another.
+You *can*, however, merge one into another!
+Consdier this case:
+
+```ruby
+GenericBioOutput = SoberSwag::OutputObject.define do
+  field :name, primitive(:String)
+  field :brief_history, primtiive(:String)
+end
+
+ExecutiveBioOutput = SoberSwag::OutputObject.define do
+  merge GenericBioOutput
+  field :company, primitive(:String)
+  field :position, primitive(:String)
+end
+```
+
+Using `#merge` lets you add in all the fields from one output object into another.
+You can even use `merge` from within a view.
+
+Note that `merge` does *not* copy anything but fields.
+Identifiers and views will not be copied over.
+
+### View Inheritance
+
+While defining a new Output Object, you *do not* have access to the definition of that output object.
+So, how do I say that one view should be an extension of another?
+Simple: use the `inherits:` kwarg:
+
+```ruby
+BioOutput = SoberSwag::OutputObject.define do
+  field :name, primitive(:String)
+  view :detail do
+    field :bio, primitive(:String)
+  end
+  view :super_detail, inherits: :detail do
+    field :age, primitive(:Integer)
+  end
+end
+```
+
+`inherits` will automatically merge in all the fields of the referenced view.
+This means that the view `super_detail`  will include fields `name`, `bio`, and `age`.

data/example/app/controllers/application_controller.rb

@@ -1,2 +1,7 @@
+##
+# Standard application controller.
 class ApplicationController < ActionController::API
+  rescue_from Dry::Struct::Error do
+    head :bad_request
+  end
 end

data/lib/sober_swag.rb

@@ -21,6 +21,7 @@ module SoberSwag
   autoload :Controller, 'sober_swag/controller'
   autoload :InputObject, 'sober_swag/input_object'
   autoload :Server, 'sober_swag/server'
+  autoload :Type, 'sober_swag/type'
 
   ##
   # Define a struct of something.

data/lib/sober_swag/compiler.rb

@@ -6,6 +6,7 @@ module SoberSwag
   class Compiler
     autoload(:Type, 'sober_swag/compiler/type')
     autoload(:Error, 'sober_swag/compiler/error')
+    autoload(:Primitive, 'sober_swag/compiler/primitive')
     autoload(:Path, 'sober_swag/compiler/path')
     autoload(:Paths, 'sober_swag/compiler/paths')
 

data/lib/sober_swag/compiler/primitive.rb

@@ -0,0 +1,75 @@
+module SoberSwag
+  class Compiler
+    ##
+    # Compiles a primitive type.
+    # Almost always constructed with the values from
+    # {SoberSwag::Nodes::Primitive}.
+    class Primitive
+      def initialize(type)
+        @type = type
+
+        raise Error, "#{type.inspect} is not a class!" unless @type.is_a?(Class)
+      end
+
+      attr_reader :type
+
+      def swagger_primitive?
+        SWAGGER_PRIMITIVE_DEFS.include?(type)
+      end
+
+      ##
+      # Is the wrapped type a named type, causing us to make a ref?
+      def named?
+        type <= SoberSwag::Type::Named
+      end
+
+      ##
+      # Turn this type into a swagger hash with a proper type key.
+      def type_hash
+        if swagger_primitive?
+          SWAGGER_PRIMITIVE_DEFS.fetch(type)
+        else
+          {
+            oneOf: [
+              { '$ref'.to_sym => named_ref }
+            ]
+          }
+        end
+      end
+
+      DATE_PRIMITIVE = { type: :string, format: :date }.freeze
+      DATE_TIME_PRIMITIVE = { type: :string, format: :'date-time' }.freeze
+
+      SWAGGER_PRIMITIVE_DEFS =
+        {
+          NilClass => :null,
+          TrueClass => :boolean,
+          FalseClass => :boolean,
+          Float => :number,
+          Integer => :integer,
+          String => :string
+        }.transform_values { |v| { type: v.freeze } }
+        .to_h.merge(
+          Date => DATE_PRIMITIVE,
+          DateTime => DATE_TIME_PRIMITIVE,
+          Time => DATE_TIME_PRIMITIVE
+        ).transform_values(&:freeze).freeze
+
+      def ref_name
+        raise Error, 'is not a type that is named!' if swagger_primitive?
+
+        if type <= SoberSwag::Type::Named
+          type.root_alias.identifier
+        else
+          type.name.gsub('::', '.')
+        end
+      end
+
+      private
+
+      def named_ref
+        "#/components/schemas/#{ref_name}"
+      end
+    end
+  end
+end

data/lib/sober_swag/compiler/type.rb

@@ -4,46 +4,6 @@ module SoberSwag
     # A compiler for DRY-Struct data types, essentially.
     # It only consumes one type at a time.
     class Type # rubocop:disable Metrics/ClassLength
-      class << self
-        def get_ref(klass)
-          "#/components/schemas/#{safe_name(klass)}"
-        end
-
-        def safe_name(klass)
-          if klass.respond_to?(:identifier)
-            klass.identifier
-          else
-            klass.to_s.gsub('::', '.')
-          end
-        end
-
-        def primitive?(value)
-          primitive_def(value) != nil
-        end
-
-        def primitive_def(value)
-          value = value.primitive if value.is_a?(Dry::Types::Nominal)
-
-          return nil unless value.is_a?(Class)
-
-          if (name = primitive_name(value))
-            { type: name }
-          elsif value == Date
-            { type: 'string', format: 'date' }
-          elsif [Time, DateTime].any?(&value.ancestors.method(:include?))
-            { type: 'string', format: 'date-time' }
-          end
-        end
-
-        def primitive_name(value)
-          return 'null' if value == NilClass
-          return 'integer' if value == Integer
-          return 'number' if value == Float
-          return 'string' if value == String
-          return 'boolean' if [TrueClass, FalseClass].include?(value)
-        end
-      end
-
       class TooComplicatedError < ::SoberSwag::Compiler::Error; end
       class TooComplicatedForPathError < TooComplicatedError; end
       class TooComplicatedForQueryError < TooComplicatedError; end
@@ -65,7 +25,15 @@ module SoberSwag
 
       def object_schema
         @object_schema ||=
-          normalize(parsed_type).cata(&method(:to_object_schema))
+          make_object_schema
+      end
+
+      def object_schema_meta
+        return {} unless standalone? && type <= SoberSwag::Type::Named
+
+        {
+          description: type.description
+        }.reject { |_, v| v.nil? }
       end
 
       def schema_stub
@@ -81,14 +49,16 @@ module SoberSwag
         raise TooComplicatedForPathError, e.message
       end
 
+      DEFAULT_QUERY_SCHEMA_ATTRS = { in: :query, style: :deepObject, explode: true }.freeze
+
       def query_schema
-        path_schema_stub.map { |e| e.merge(in: :query, style: :deepObject, explode: true) }
+        path_schema_stub.map { |e| DEFAULT_QUERY_SCHEMA_ATTRS.merge(e) }
       rescue TooComplicatedError => e
         raise TooComplicatedForQueryError, e.message
       end
 
       def ref_name
-        self.class.safe_name(type)
+        SoberSwag::Compiler::Primitive.new(type).ref_name
       end
 
       def found_types
@@ -99,6 +69,10 @@ module SoberSwag
           end
       end
 
+      def mapped_type
+        @mapped_type ||= parsed_type.map { |v| SoberSwag::Compiler::Primitive.new(v).type_hash }
+      end
+
       def parsed_type
         @parsed_type ||=
           begin
@@ -121,20 +95,11 @@ module SoberSwag
 
       private
 
-      def generate_schema_stub # rubocop:disable Metrics/MethodLength
-        return self.class.primitive_def(type) if self.class.primitive?(type)
-
-        case type
-        when Class
-          { :$ref => self.class.get_ref(type) }
-        when Dry::Types::Constrained
-          self.class.new(type.type).schema_stub
-        when Dry::Types::Array::Member
-          { type: :array, items: self.class.new(type.member).schema_stub }
-        when Dry::Types::Sum
-          { oneOf: normalize(parsed_type).elements.map { |t| self.class.new(t.value).schema_stub } }
+      def generate_schema_stub
+        if type.is_a?(Class)
+          SoberSwag::Compiler::Primitive.new(type).type_hash
         else
-          raise SoberSwag::Compiler::Error, "Cannot generate a schema stub for #{type} (#{type.class})"
+          object_schema
         end
       end
 
@@ -147,6 +112,10 @@ module SoberSwag
         end
       end
 
+      def make_object_schema(metadata_keys: METADATA_KEYS)
+        normalize(mapped_type).cata { |e| to_object_schema(e, metadata_keys) }.merge(object_schema_meta)
+      end
+
       def normalize(object)
         object.cata { |e| rewrite_sums(e) }.cata { |e| flatten_one_ofs(e) }
       end
@@ -178,29 +147,14 @@ module SoberSwag
         end
       end
 
-      def to_object_schema(object) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      def to_object_schema(object, metadata_keys = METADATA_KEYS) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         case object
         when Nodes::List
-          {
-            type: :array,
-            items: object.deconstruct.first
-          }
+          { type: :array, items: object.element }
         when Nodes::Enum
-          {
-            type: :string,
-            enum: object.deconstruct.first
-          }
+          { type: :string, enum: object.values }
         when Nodes::OneOf
-          if object.deconstruct.include?({ type: 'null' })
-            rejected = object.deconstruct.reject { |e| e[:type] == 'null' }
-            if rejected.length == 1
-              rejected.first.merge(nullable: true)
-            else
-              { oneOf: rejected, nullable: true }
-            end
-          else
-            { oneOf: object.deconstruct }
-          end
+          one_of_to_schema(object)
         when Nodes::Object
           # openAPI requires that you give a list of required attributes
           # (which IMO is the *totally* wrong thing to do but whatever)
@@ -214,40 +168,50 @@ module SoberSwag
             required: required
           }
         when Nodes::Attribute
-          name, req, value = object.deconstruct
+          name, req, value, meta = object.deconstruct
+          value = value.merge(meta&.select { |k, _| metadata_keys.include?(k) } || {})
           if req
             [name, value.merge(required: true)]
           else
             [name, value]
           end
-        # can't match on value directly as ruby uses `===` to match,
-        # and classes use `===` to mean `is an instance of`, as
-        # opposed to direct equality lmao
         when Nodes::Primitive
-          value = object.value
-          metadata = object.metadata
-          if self.class.primitive?(value)
-            md = self.class.primitive_def(value)
-            METADATA_KEYS.select(&metadata.method(:key?)).reduce(md) do |definition, key|
-              definition.merge(key => metadata[key])
-            end
+          object.value.merge(object.metadata.select { |k, _| metadata_keys.include?(k) })
+        else
+          raise ArgumentError, "Got confusing node #{object} (#{object.class})"
+        end
+      end
+
+      def one_of_to_schema(object)
+        if object.deconstruct.include?({ type: :null })
+          rejected = object.deconstruct.reject { |e| e[:type] == :null }
+          if rejected.length == 1
+            rejected.first.merge(nullable: true)
           else
-            { '$ref': self.class.get_ref(value) }
+            { oneOf: flatten_oneofs_hash(rejected), nullable: true }
           end
         else
-          raise ArgumentError, "Got confusing node #{object} (#{object.class})"
+          { oneOf: flatten_oneofs_hash(object.deconstruct) }
         end
       end
 
+      def flatten_oneofs_hash(object)
+        object.map { |h|
+          h[:oneOf] || h
+        }.flatten
+      end
+
       def path_schema_stub
         @path_schema_stub ||=
-          object_schema[:properties].map do |k, v|
+          make_object_schema(metadata_keys: METADATA_KEYS | %i[style explode])[:properties].map do |k, v|
             # ensure_uncomplicated(k, v)
             {
               name: k,
-              schema: v.reject { |key, _| %i[required nullable].include?(key) },
-              required: object_schema[:required].include?(k) || false
-            }
+              schema: v.reject { |key, _| %i[required nullable explode style].include?(key) },
+              required: object_schema[:required].include?(k) || false,
+              style: v[:style],
+              explode: v[:explode]
+            }.reject { |_, v2| v2.nil? }
           end
       end
 

data/lib/sober_swag/controller.rb

@@ -17,12 +17,6 @@ module SoberSwag
       include ::Dry::Types()
     end
 
-    included do
-      rescue_from Dry::Struct::Error do
-        head :bad_request
-      end
-    end
-
     class_methods do
       ##
       # Define a new action with the given HTTP method, action name, and path.

data/lib/sober_swag/input_object.rb

@@ -7,15 +7,28 @@ module SoberSwag
   # Please see the documentation for that class to see how it works.
   class InputObject < Dry::Struct
     transform_keys(&:to_sym)
+    include SoberSwag::Type::Named
 
     class << self
       ##
       # The name to use for this type in external documentation.
       def identifier(arg = nil)
         @identifier = arg if arg
+
         @identifier || name.to_s.gsub('::', '.')
       end
 
+      def meta(*args)
+        original = self
+
+        super(*args).tap do |result|
+          return result unless result.is_a?(Class)
+
+          result.define_singleton_method(:alias?) { true }
+          result.define_singleton_method(:alias_of) { original }
+        end
+      end
+
       def primitive(sym)
         SoberSwag::Types.const_get(sym)
       end

data/lib/sober_swag/nodes/attribute.rb

@@ -2,29 +2,30 @@ module SoberSwag
   module Nodes
     ##
     # One attribute of an object.
-    class Attribute
-      def initialize(key, required, value)
+    class Attribute < Base
+      def initialize(key, required, value, meta = {})
         @key = key
         @required = required
         @value = value
+        @meta = meta
       end
 
       def deconstruct
-        [key, required, value]
+        [key, required, value, meta]
       end
 
       def deconstruct_keys
-        { key: key, required: required, value: value }
+        { key: key, required: required, value: value, meta: meta }
       end
 
-      attr_reader :key, :required, :value
+      attr_reader :key, :required, :value, :meta
 
       def map(&block)
-        self.class.new(key, required, value.map(&block))
+        self.class.new(key, required, value.map(&block), meta)
       end
 
       def cata(&block)
-        block.call(self.class.new(key, required, value.cata(&block)))
+        block.call(self.class.new(key, required, value.cata(&block), meta))
       end
     end
   end

data/lib/sober_swag/nodes/enum.rb

@@ -10,8 +10,8 @@ module SoberSwag
 
       attr_reader :values
 
-      def map(&block)
-        self.class.new(@values.map(&block))
+      def map
+        dup
       end
 
       def deconstruct

data/lib/sober_swag/nodes/primitive.rb

@@ -11,7 +11,7 @@ module SoberSwag
       attr_reader :value, :metadata
 
       def map(&block)
-        self.class.new(block.call(value))
+        self.class.new(block.call(value), metadata.dup)
       end
 
       def deconstruct

data/lib/sober_swag/output_object/definition.rb

@@ -17,8 +17,14 @@ module SoberSwag
         @fields << field
       end
 
-      def view(name, &block)
-        view = View.define(name, fields, &block)
+      def view(name, inherits: nil, &block)
+        initial_fields =
+          if inherits.nil? || inherits == :base
+            fields
+          else
+            find_view(inherits).fields
+          end
+        view = View.define(name, initial_fields, &block)
 
         view.identifier("#{@identifier}.#{name.to_s.classify}") if identifier
 
@@ -29,6 +35,12 @@ module SoberSwag
         @identifier = arg if arg
         @identifier
       end
+
+      private
+
+      def find_view(name)
+        @views.find { |view| view.name == name } || (raise ArgumentError, "no view #{name.inspect} defined!")
+      end
     end
   end
 end

data/lib/sober_swag/output_object/field_syntax.rb

@@ -7,11 +7,27 @@ module SoberSwag
         add_field!(Field.new(name, serializer, from: from, &block))
       end
 
+      ##
+      # Similar to #field, but adds multiple at once.
+      # Named #multi because #fields was already taken.
+      def multi(names, serializer)
+        names.each { |name| field(name, serializer) }
+      end
+
       ##
       # Given a symbol to this, we will use a primitive name
       def primitive(name)
         SoberSwag::Serializer.primitive(SoberSwag::Types.const_get(name))
       end
+
+      ##
+      # Merge in anything that has a list of fields, and use it.
+      # Note that merging in a full blueprint *will not* also merge in views, just fields defined on the base.
+      def merge(other)
+        other.fields.each do |field|
+          add_field!(field)
+        end
+      end
     end
   end
 end

data/lib/sober_swag/parser.rb

@@ -25,7 +25,8 @@ module SoberSwag
         Nodes::Attribute.new(
           @node.name,
           @node.required? && !@node.type.default?,
-          bind(Parser.new(@node.type))
+          bind(Parser.new(@node.type)),
+          @node.meta
         )
       when Dry::Types::Sum
         left = bind(Parser.new(@node.left))
@@ -46,13 +47,18 @@ module SoberSwag
       when Dry::Types::Constrained
         bind(Parser.new(@node.type))
       when Dry::Types::Nominal
-        # start off with the moral equivalent of NodeTree[String]
-        Nodes::Primitive.new(@node.primitive, @node.meta)
+        if @node.respond_to?(:type) && @node.type.is_a?(Dry::Types::Constrained)
+          bind(Parser.new(@node.type))
+        else
+          old_meta = @node.primitive.respond_to?(:meta) ? @node.primitive.meta : {}
+          # start off with the moral equivalent of NodeTree[String]
+          Nodes::Primitive.new(@node.primitive, old_meta.merge(@node.meta))
+        end
       else
         # Inside of this case we have a class that is some user-defined type
         # We put it in our array of found types, and consider it a primitive
         @found.add(@node)
-        Nodes::Primitive.new(@node)
+        Nodes::Primitive.new(@node, @node.respond_to?(:meta) ? @node.meta : {})
       end
     end
 

data/lib/sober_swag/serializer/base.rb

@@ -17,6 +17,8 @@ module SoberSwag
         SoberSwag::Serializer::Optional.new(self)
       end
 
+      alias nilable optional
+
       ##
       # Is this type lazily defined?
       #

data/lib/sober_swag/serializer/meta.rb

@@ -21,15 +21,23 @@ module SoberSwag
       end
 
       def lazy_type
-        @base.lazy_type.meta(**metadata)
+        @lazy_type ||= @base.lazy_type.meta(**metadata)
       end
 
       def type
-        @base.type.meta(**metadata)
+        @type ||= @base.type.meta(**metadata)
       end
 
       def finalize_lazy_type!
         @base.finalize_lazy_type!
+        # Using .meta on dry-struct returns a *new type* that wraps the old one.
+        # As such, we need to be a bit clever about when we tack on the identifier
+        # for this type.
+        %i[lazy_type type].each do |sym|
+          if @base.public_send(sym).respond_to?(:identifier) && public_send(sym).respond_to?(:identifier)
+            public_send(sym).identifier(@base.public_send(sym).identifier)
+          end
+        end
       end
 
       def lazy_type?

data/lib/sober_swag/type.rb

@@ -0,0 +1,7 @@
+module SoberSwag
+  ##
+  # Namespace for type-definition-related utilities
+  module Type
+    autoload(:Named, 'sober_swag/type/named')
+  end
+end

data/lib/sober_swag/type/named.rb

@@ -0,0 +1,35 @@
+module SoberSwag
+  module Type
+    ##
+    # Mixin module used to identify types that should be considered
+    # standalone, named types from SoberSwag's perspective.
+    module Named
+      ##
+      # Class Methods Module.
+      # Modules that include {SoberSwag::Type::Named}
+      # will automatically extend this module.
+      module ClassMethods
+        def alias?
+          false
+        end
+
+        def alias_of
+          nil
+        end
+
+        def root_alias
+          alias_of || self
+        end
+
+        def description(arg = nil)
+          @description = arg if arg
+          @description
+        end
+      end
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/sober_swag/types.rb

@@ -4,5 +4,7 @@ module SoberSwag
   # You can use constants like SoberSwag::Types::Integer and things as a result of this module existing.
   class Types
     include ::Dry::Types()
+
+    autoload(:CommaArray, 'sober_swag/types/comma_array')
   end
 end

data/lib/sober_swag/types/comma_array.rb

@@ -0,0 +1,17 @@
+module SoberSwag
+  class Types
+    ##
+    # An array that will be parsed from comma-separated values in a string, if given a string.
+    module CommaArray
+      def self.of(other)
+        SoberSwag::Types::Array.of(other).constructor { |val|
+          if val.is_a?(::String)
+            val.split(',').map(&:strip)
+          else
+            val
+          end
+        }.meta(style: :form, explode: false)
+      end
+    end
+  end
+end

data/lib/sober_swag/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SoberSwag
-  VERSION = '0.10.0'
+  VERSION = '0.15.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sober_swag
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Anthony Super
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-24 00:00:00.000000000 Z
+date: 2020-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -179,6 +179,7 @@ files:
 - ".rubocop.yml"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -249,6 +250,7 @@ files:
 - lib/sober_swag/compiler/error.rb
 - lib/sober_swag/compiler/path.rb
 - lib/sober_swag/compiler/paths.rb
+- lib/sober_swag/compiler/primitive.rb
 - lib/sober_swag/compiler/type.rb
 - lib/sober_swag/controller.rb
 - lib/sober_swag/controller/route.rb
@@ -284,7 +286,10 @@ files:
 - lib/sober_swag/serializer/optional.rb
 - lib/sober_swag/serializer/primitive.rb
 - lib/sober_swag/server.rb
+- lib/sober_swag/type.rb
+- lib/sober_swag/type/named.rb
 - lib/sober_swag/types.rb
+- lib/sober_swag/types/comma_array.rb
 - lib/sober_swag/version.rb
 - sober_swag.gemspec
 homepage: https://github.com/SonderMindOrg/sober_swag