sober_swag 0.1.0 → 0.6.0

data/lib/sober_swag/output_object/definition.rb

@@ -0,0 +1,30 @@
+module SoberSwag
+  class OutputObject
+    ##
+    # Container to define a single output object.
+    # This is the DSL used in the base of {SoberSwag::OutputObject.define}.
+    class Definition
+      def initialize
+        @fields = []
+        @views = []
+      end
+
+      attr_reader :fields, :views
+
+      include FieldSyntax
+
+      def add_field!(field)
+        @fields << field
+      end
+
+      def view(name, &block)
+        @views << View.define(name, fields, &block)
+      end
+
+      def identifier(arg = nil)
+        @identifier = arg if arg
+        @identifier
+      end
+    end
+  end
+end

data/lib/sober_swag/{blueprint → output_object}/field.rb

@@ -1,5 +1,8 @@
 module SoberSwag
-  class Blueprint
+  class OutputObject
+    ##
+    # A single field in an output object.
+    # Later used to make an actual serializer from this.
     class Field
       def initialize(name, serializer, from: nil, &block)
         @name = name
@@ -11,12 +14,20 @@ module SoberSwag
       attr_reader :name
 
       def serializer
-        @serializer ||= @root_serializer.serializer.via_map(&transform_proc)
+        @serializer ||= resolved_serializer.serializer.via_map(&transform_proc)
+      end
+
+      def resolved_serializer
+        if @root_serializer.is_a?(Proc)
+          @root_serializer.call
+        else
+          @root_serializer
+        end
       end
 
       private
 
-      def transform_proc
+      def transform_proc # rubocop:disable Metrics/MethodLength
         if @block
           @block
         else
@@ -30,7 +41,6 @@ module SoberSwag
           end
         end
       end
-
     end
   end
 end

data/lib/sober_swag/{blueprint → output_object}/field_syntax.rb

@@ -1,5 +1,5 @@
 module SoberSwag
-  class Blueprint
+  class OutputObject
     ##
     # Syntax for definitions that can add fields.
     module FieldSyntax
@@ -10,7 +10,7 @@ module SoberSwag
       ##
       # Given a symbol to this, we will use a primitive name
       def primitive(name)
-        SoberSwag::Serializer.Primitive(SoberSwag::Types.const_get(name))
+        SoberSwag::Serializer.primitive(SoberSwag::Types.const_get(name))
       end
     end
   end

data/lib/sober_swag/{blueprint → output_object}/view.rb

@@ -1,14 +1,16 @@
 module SoberSwag
-  class Blueprint
+  class OutputObject
+    ##
+    # DSL for defining a view.
+    # Used in `view` blocks within {SoberSwag::OutputObject.define}.
     class View
-
       def self.define(name, base_fields, &block)
-        self.new(name, base_fields).tap do |view|
+        new(name, base_fields).tap do |view|
           view.instance_eval(&block)
         end
       end
 
-      class NestingError < Error; end;
+      class NestingError < Error; end
 
       include FieldSyntax
 
@@ -19,8 +21,16 @@ module SoberSwag
 
       attr_reader :name, :fields
 
+      def serialize(obj, opts = {})
+        serializer.serialize(obj, opts)
+      end
+
+      def type
+        serializer.type
+      end
+
       def except!(name)
-        @fields.select! { |f| f.name != name }
+        @fields.reject! { |f| f.name == name }
       end
 
       def view(*)
@@ -38,7 +48,6 @@ module SoberSwag
         @serializer ||=
           SoberSwag::Serializer::FieldList.new(fields)
       end
-
     end
   end
 end

data/lib/sober_swag/parser.rb

@@ -1,12 +1,18 @@
 module SoberSwag
+  ##
+  # Parses a *Dry-Types Schema* into a set of nodes we can use to compile.
+  # This is mostly because the vistior pattern sucks and catamorphisms are nice.
   class Parser
     def initialize(node)
       @node = node
       @found = Set.new
     end
 
-    def to_syntax
+    def to_syntax # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
       case @node
+      when Dry::Types::Default
+        # we handle this elsewhere, so
+        bind(Parser.new(@node.type))
       when Dry::Types::Array::Member
         Nodes::List.new(bind(Parser.new(@node.member)))
       when Dry::Types::Enum
@@ -18,7 +24,7 @@ module SoberSwag
       when Dry::Types::Schema::Key
         Nodes::Attribute.new(
           @node.name,
-          @node.required?,
+          @node.required? && !@node.type.default?,
           bind(Parser.new(@node.type))
         )
       when Dry::Types::Sum
@@ -41,7 +47,7 @@ module SoberSwag
         bind(Parser.new(@node.type))
       when Dry::Types::Nominal
         # start off with the moral equivalent of NodeTree[String]
-        Nodes::Primitive.new(@node.primitive)
+        Nodes::Primitive.new(@node.primitive, @node.meta)
       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
@@ -68,6 +74,5 @@ module SoberSwag
       @found += other.found
       result
     end
-
   end
 end

data/lib/sober_swag/serializer.rb

@@ -1,4 +1,7 @@
 module SoberSwag
+  ##
+  # Container module for serializers.
+  # The interface for these is described in {SoberSwag::Serializer::Base}.
   module Serializer
     autoload(:Base, 'sober_swag/serializer/base')
     autoload(:Primitive, 'sober_swag/serializer/primitive')
@@ -7,6 +10,7 @@ module SoberSwag
     autoload(:Mapped, 'sober_swag/serializer/mapped')
     autoload(:Optional, 'sober_swag/serializer/optional')
     autoload(:FieldList, 'sober_swag/serializer/field_list')
+    autoload(:Meta, 'sober_swag/serializer/meta')
 
     class << self
       ##
@@ -14,10 +18,9 @@ module SoberSwag
       # in values raw.
       #
       # @param contained {Class} Dry::Type to use
-      def Primitive(contained)
+      def primitive(contained)
         SoberSwag::Serializer::Primitive.new(contained)
       end
     end
-
   end
 end

data/lib/sober_swag/serializer/array.rb

@@ -7,6 +7,18 @@ module SoberSwag
         @element_serializer = element_serializer
       end
 
+      def lazy_type?
+        @element_serializer.lazy_type?
+      end
+
+      def lazy_type
+        SoberSwag::Types::Array.of(@element_serializer.lazy_type)
+      end
+
+      def finalize_lazy_type!
+        @element_serializer.finalize_lazy_type!
+      end
+
       attr_reader :element_serializer
 
       def serialize(object, options = {})

data/lib/sober_swag/serializer/base.rb

@@ -1,7 +1,10 @@
 module SoberSwag
   module Serializer
+    ##
+    # Base interface class that all other serializers are subclasses of.
+    # This also defines methods as stubs, which is sort of bad ruby style, but makes documentation
+    # easier to generate.
     class Base
-
       ##
       # Return a new serializer that is an *array* of elements of this serializer.
       def array
@@ -14,6 +17,46 @@ module SoberSwag
         SoberSwag::Serializer::Optional.new(self)
       end
 
+      ##
+      # Is this type lazily defined?
+      #
+      # Used for mutual recursion.
+      def lazy_type?
+        false
+      end
+
+      ##
+      # The lazy version of this type, for mutual recursion.
+      def lazy_type
+        type
+      end
+
+      ##
+      # Finalize a lazy type.
+      #
+      # Should be idempotent: call it once, and it does nothing on subsequent calls (but returns the type).
+      def finalize_lazy_type!
+        type
+      end
+
+      ##
+      # Serialize an object.
+      def serialize(_object, _options = {})
+        raise ArgumentError, 'not implemented!'
+      end
+
+      ##
+      # Get the type that we serialize to.
+      def type
+        raise ArgumentError, 'not implemented!'
+      end
+
+      ##
+      # Add metadata onto the *type* of a serializer.
+      def meta(hash)
+        SoberSwag::Serializer::Meta.new(self, hash)
+      end
+
       ##
       # If I am a serializer for type 'a', and you give me a way to turn 'a's into 'b's,
       # I can give you a serializer for type 'b' by running the funciton you gave.
@@ -33,6 +76,12 @@ module SoberSwag
         self
       end
 
+      ##
+      # Get the type name of this to be used externally, or set it if an argument is provided
+      def identifier(arg = nil)
+        @identifier = arg if arg
+        @identifier
+      end
     end
   end
 end

data/lib/sober_swag/serializer/conditional.rb

@@ -25,9 +25,10 @@ module SoberSwag
 
       def serialize(object, options = {})
         tag, val = chooser.call(object, options)
-        if tag == :left
+        case tag
+        when :left
           left.serialize(val, options)
-        elsif tag == :right
+        when :right
           right.serialize(val, options)
         else
           raise BadChoiceError, "result of chooser proc was not a left or right, but a #{val.class}"
@@ -44,6 +45,22 @@ module SoberSwag
           left.type | right.type
         end
       end
+
+      def lazy_type
+        if left.lazy_type == right.lazy_type
+          left.lazy_type
+        else
+          left.lazy_type | right.lazy_type
+        end
+      end
+
+      def lazy_type?
+        left.lazy_type? || right.lazy_type?
+      end
+
+      def finalize_lazy_type!
+        [left, right].each(&:finalize_lazy_type!)
+      end
     end
   end
 end

data/lib/sober_swag/serializer/field_list.rb

@@ -4,7 +4,6 @@ module SoberSwag
     # Extract out a hash from a list of
     # name/serializer pairs.
     class FieldList < Base
-
       def initialize(field_list)
         @field_list = field_list
       end
@@ -17,8 +16,7 @@ module SoberSwag
         SoberSwag::Serializer.Primitive(SoberSwag::Types.const_get(symbol))
       end
 
-
-      def serialize(object, options)
+      def serialize(object, options = {})
         field_list.map { |field|
           [field.name, field.serializer.serialize(object, options)]
         }.to_h
@@ -28,17 +26,42 @@ module SoberSwag
         @type ||= make_struct_type!
       end
 
+      def lazy_type?
+        true
+      end
+
+      def lazy_type
+        struct_class
+      end
+
+      def finalize_lazy_type!
+        make_struct_type!
+      end
+
       private
 
-      def make_struct_type!
+      def make_struct_type! # rubocop:disable Metrics/MethodLength
+        # mutual recursion makes this really, really annoying.
+        return struct_class if @made_struct_type
+
         f = field_list
-        Class.new(Dry::Struct) do
+        s = identifier
+        struct_class.instance_eval do
+          identifier(s)
           f.each do |field|
-            attribute field.name, field.serializer.type
+            attribute field.name, field.serializer.lazy_type
           end
         end
+        @made_struct_type = true
+
+        field_list.map(&:serializer).each(&:finalize_lazy_type!)
+
+        struct_class
       end
 
+      def struct_class
+        @struct_class ||= Class.new(SoberSwag::InputObject)
+      end
     end
   end
 end

data/lib/sober_swag/serializer/mapped.rb

@@ -3,16 +3,29 @@ module SoberSwag
     ##
     # A new serializer by mapping over the serialization function
     class Mapped < Base
-
       def initialize(base, map_f)
         @base = base
         @map_f = map_f
       end
 
-      def serialize(object, options)
+      attr_reader :base, :map_f
+
+      def serialize(object, options = {})
         @base.serialize(@map_f.call(object), options)
       end
 
+      def lazy_type?
+        @base.lazy_type?
+      end
+
+      def lazy_type
+        @base.lazy_type
+      end
+
+      def finalize_lazy_type!
+        @base.finalize_lazy_type!
+      end
+
       def type
         @base.type
       end
@@ -23,7 +36,6 @@ module SoberSwag
       def via_map(&block)
         SoberSwag::Serializer::Mapped.new(@base, @map_f >> block)
       end
-
     end
   end
 end

data/lib/sober_swag/serializer/meta.rb

@@ -0,0 +1,35 @@
+module SoberSwag
+  module Serializer
+    ##
+    # Provides metadata on a serializer.
+    # All actions delegate to the base.
+    class Meta < Base
+      def initialize(base, meta)
+        @base = base
+        @meta = meta
+      end
+
+      attr_reader :base, :meta
+
+      def serialize(args, opts = {})
+        base.serialize(args, opts)
+      end
+
+      def lazy_type
+        @base.lazy_type.meta(**meta)
+      end
+
+      def type
+        @base.type.meta(**meta)
+      end
+
+      def finalize_lazy_type!
+        @base.finalize_lazy_type!
+      end
+
+      def lazy_type?
+        @base.lazy_type?
+      end
+    end
+  end
+end