json_model_rb 0.1.20 → 0.1.23

data/lib/json_model/builder/alias_builder.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative('nested_builder')
+
+module JsonModel
+  module Builder
+    class AliasBuilder < NestedBuilder
+    end
+  end
+end

data/lib/json_model/builder/array_builder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative('nested_builder')
+
+module JsonModel
+  module Builder
+    class ArrayBuilder < NestedBuilder
+      # @return [Hash]
+      def as_schema
+        {
+          type: 'array',
+          items: builder.as_schema,
+        }
+      end
+
+      protected
+
+      # @return [Type]
+      def nested_type
+        type.member
+      end
+    end
+  end
+end

data/lib/json_model/builder/base_builder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Builder
+    class BaseBuilder
+      attr_reader(:type)
+
+      # @param [Dry::Types::Type] type
+      def initialize(type)
+        @type = type
+      end
+
+      # @return [Hash]
+      def as_schema
+        raise(NotImplementedError)
+      end
+
+      # @return [Array<JsonModel::Builder::BaseBuilder>]
+      def referenced_schemas
+        []
+      end
+    end
+  end
+end

data/lib/json_model/builder/composition/any_of_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative('builder')
+
+module JsonModel
+  module Builder
+    module Composition
+      class AnyOfBuilder < Builder
+        # @param [Dry::Types::Intersection] type
+        def initialize(type)
+          super(type.type, :anyOf)
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/composition/builder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative('../base_builder')
+
+module JsonModel
+  module Builder
+    module Composition
+      class Builder < BaseBuilder
+        # @param [Dry::Types::Type] type
+        # @param [Symbol] modifier
+        def initialize(type, modifier)
+          super(type)
+          @modifier = modifier
+        end
+
+        # @return [Hash]
+        def as_schema
+          {
+            @modifier => builders.map(&:as_schema).uniq,
+          }
+        end
+
+        # @return [Array<JsonModel::Builder::BaseBuilder>]
+        def referenced_schemas
+          builders.flat_map(&:referenced_schemas).uniq
+        end
+
+        private
+
+        # @return [Array<JsonModel::Builder::BaseBuilder>]
+        def builders
+          @builders ||= types(type).uniq.map { |type| JsonModel::Builder.for(type) }
+        end
+
+        # @param [Dry::Types::Type] type
+        # @return [Array<Dry::Types::Type>]
+        def types(type)
+          if type.is_a?(Dry::Types::Composition)
+            types(type.left) + types(type.right)
+          else
+            [type]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/composition/intersection_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative('builder')
+
+module JsonModel
+  module Builder
+    module Composition
+      class IntersectionBuilder < Builder
+        # @param [Dry::Types::Intersection] type
+        def initialize(type)
+          super(type, :allOf)
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/composition/one_of_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative('builder')
+
+module JsonModel
+  module Builder
+    module Composition
+      class OneOfBuilder < Builder
+        # @param [Dry::Types::Sum] type
+        def initialize(type)
+          super(type.type, :oneOf)
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/composition/sum_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative('builder')
+
+module JsonModel
+  module Builder
+    module Composition
+      class SumBuilder < Builder
+        # @param [Dry::Types::Sum] type
+        def initialize(type)
+          super(type, :anyOf)
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/composition.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative('composition/any_of_builder')
+require_relative('composition/intersection_builder')
+require_relative('composition/one_of_builder')
+require_relative('composition/sum_builder')

data/lib/json_model/builder/constrained_builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative('nested_builder')
+
+module JsonModel
+  module Builder
+    class ConstrainedBuilder < NestedBuilder
+      CONSTRAINT_MAPPING = {
+        eql?: {
+          String => { key: :const },
+        },
+        format?: {
+          String => { key: :pattern, transform: lambda(&:source) },
+        },
+        gt?: {
+          Integer => { key: :exclusiveMinimum },
+        },
+        gteq?: {
+          Integer => { key: :minimum },
+        },
+        lt?: {
+          Integer => { key: :exclusiveMaximum },
+        },
+        lteq?: {
+          Integer => { key: :maximum },
+        },
+        max_size?: {
+          String => { key: :maxLength },
+          Array => { key: :maxItems },
+        },
+        min_size?: {
+          String => { key: :minLength },
+          Array => { key: :minItems },
+        },
+        unique?: {
+          Array => { key: :uniqueItems, transform: ->(_v) { true } },
+        },
+      }.freeze
+
+      # @return [Hash]
+      def as_schema
+        if type.meta[:format]
+          super
+        else
+          super.merge(*extract_constraints)
+        end
+      end
+
+      private
+
+      # @return [Array<Hash>]
+      def extract_constraints
+        extract_rules(type.rule)
+          .map { |rule| extract_constraint(rule.to_ast) }
+          .compact
+      end
+
+      # @param [Dry::Types::Rule] rule
+      # @return [Array<Dry::Types::Rule>]
+      def extract_rules(rule)
+        if rule.respond_to?(:rules)
+          rule.rules.flat_map { |rule| extract_rules(rule) }
+        else
+          [rule]
+        end
+      end
+
+      # @param [Array] ast
+      # @return [Hash, nil]
+      def extract_constraint(ast)
+        predicate, args = ast.last
+        if CONSTRAINT_MAPPING.key?(predicate)
+          mapping = CONSTRAINT_MAPPING.dig(predicate, type.primitive) || CONSTRAINT_MAPPING[predicate].values.first
+          {
+            mapping[:key] => mapping
+                               .fetch(:transform, ->(v) { v })
+                               .call(args.first.last),
+          }
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/default_builder.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative('nested_builder')
+
+module JsonModel
+  module Builder
+    class DefaultBuilder < NestedBuilder
+      # @return [Hash]
+      def as_schema
+        super.merge(default: type.value)
+      end
+    end
+  end
+end

data/lib/json_model/builder/enum_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative('base_builder')
+
+module JsonModel
+  module Builder
+    class EnumBuilder < BaseBuilder
+      # @return [Hash]
+      def as_schema
+        {
+          enum: type.values,
+        }
+      end
+    end
+  end
+end

data/lib/json_model/builder/format_builder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative('base_builder')
+
+module JsonModel
+  module Builder
+    class FormatBuilder < BaseBuilder
+      class << self
+        # @param [String] format
+        # @return [Factory]
+        def for(format)
+          Factory.new(format)
+        end
+      end
+
+      class Factory
+        attr_reader(:format)
+
+        # @param [String] format
+        def initialize(format)
+          @format = format
+        end
+
+        # @param [Dry::Types::Type] type
+        # @return [FormatBuilder]
+        def new(type)
+          FormatBuilder.new(type, format)
+        end
+      end
+
+      # @param [Dry::Types::Type] type
+      # @param [Symbol] format
+      def initialize(type, format)
+        super(type)
+        @format = format
+      end
+
+      # @return [Hash]
+      def as_schema
+        {
+          type: 'string',
+          format: @format,
+        }
+      end
+    end
+  end
+end

data/lib/json_model/builder/key_builder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative('nested_builder')
+
+module JsonModel
+  module Builder
+    class KeyBuilder < NestedBuilder
+      # @return [Hash]
+      def as_schema
+        {
+          self.alias => builder.as_schema,
+        }
+      end
+
+      # @return [FalseClass, TrueClass]
+      def optional?
+        type.optional?
+      end
+
+      # @return [Symbol]
+      def alias
+        if type.respond_to?(:alias)
+          type.alias
+        else
+          JsonModel.config.property_naming_strategy.call(type.name)
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/nested_builder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative('base_builder')
+
+module JsonModel
+  module Builder
+    class NestedBuilder < BaseBuilder
+      # @return [Hash]
+      def as_schema
+        builder.as_schema
+      end
+
+      # @return [Array<Type>]
+      def referenced_schemas
+        builder.referenced_schemas
+      end
+
+      protected
+
+      # @return [BaseBuilder]
+      def builder
+        @builder ||= Builder.for(nested_type)
+      end
+
+      # @return [Type]
+      def nested_type
+        type.type
+      end
+    end
+  end
+end

data/lib/json_model/builder/primitive/boolean_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative('builder')
+
+module JsonModel
+  module Builder
+    module Primitive
+      class BooleanBuilder < Builder
+        # @param [Dry::Types::Type] type
+        def initialize(type)
+          super(type, 'boolean')
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/primitive/builder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative('../base_builder')
+
+module JsonModel
+  module Builder
+    module Primitive
+      class Builder < BaseBuilder
+        # @param [Dry::Types::Type] type
+        # @param [String] schema_type
+        def initialize(type, schema_type)
+          super(type)
+          @schema_type = schema_type
+        end
+
+        # @return [Hash]
+        def as_schema
+          {
+            type: @schema_type,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/primitive/integer_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative('builder')
+
+module JsonModel
+  module Builder
+    module Primitive
+      class IntegerBuilder < Builder
+        # @param [Dry::Types::Type] type
+        def initialize(type)
+          super(type, 'integer')
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/primitive/null_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative('builder')
+
+module JsonModel
+  module Builder
+    module Primitive
+      class NullBuilder < Builder
+        # @param [Dry::Types::Type] type
+        def initialize(type)
+          super(type, 'null')
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/primitive/number_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative('builder')
+
+module JsonModel
+  module Builder
+    module Primitive
+      class NumberBuilder < Builder
+        # @param [Dry::Types::Type] type
+        def initialize(type)
+          super(type, 'number')
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/primitive/string_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative('builder')
+
+module JsonModel
+  module Builder
+    module Primitive
+      class StringBuilder < Builder
+        # @param [Dry::Types::Type] type
+        def initialize(type)
+          super(type, 'string')
+        end
+      end
+    end
+  end
+end

data/lib/json_model/builder/primitive.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative('primitive/boolean_builder')
+require_relative('primitive/integer_builder')
+require_relative('primitive/null_builder')
+require_relative('primitive/number_builder')
+require_relative('primitive/string_builder')

data/lib/json_model/builder/ref_builder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative('base_builder')
+
+module JsonModel
+  module Builder
+    class RefBuilder < NestedBuilder
+      # @return [Hash]
+      def as_schema
+        case ref_mode
+        when :local
+          { '$ref': "#/$defs/#{type.name}" }
+        when :external
+          { '$ref': type.schema_id }
+        else
+          type.as_schema
+        end
+      end
+
+      # @return [Array<Type>]
+      def referenced_schemas
+        if ref_mode == :local
+          [type]
+        else
+          super
+        end
+      end
+
+      # @return [Symbol]
+      def ref_mode
+        type.options[:mode]
+      end
+    end
+  end
+end

data/lib/json_model/builder/schema_builder.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative('base_builder')
+
+module JsonModel
+  module Builder
+    class SchemaBuilder < BaseBuilder
+      # @return [Hash]
+      def as_schema
+        type.as_schema
+      end
+    end
+  end
+end

data/lib/json_model/builder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative('builder/alias_builder')
+require_relative('builder/array_builder')
+require_relative('builder/composition')
+require_relative('builder/constrained_builder')
+require_relative('builder/default_builder')
+require_relative('builder/enum_builder')
+require_relative('builder/format_builder')
+require_relative('builder/key_builder')
+require_relative('builder/primitive')
+require_relative('builder/ref_builder')
+require_relative('builder/schema_builder')
+
+require_relative('types')
+
+module JsonModel
+  module Builder
+    class << self
+      PRIMITIVE_TO_BUILDER = {
+        Array => Builder::ArrayBuilder,
+        FalseClass => Builder::Primitive::BooleanBuilder,
+        Float => Builder::Primitive::NumberBuilder,
+        Integer => Builder::Primitive::IntegerBuilder,
+        NilClass => Builder::Primitive::NullBuilder,
+        String => Builder::Primitive::StringBuilder,
+        TrueClass => Builder::Primitive::BooleanBuilder,
+        URI => Builder::FormatBuilder.for('uri'),
+      }.freeze
+
+      TYPE_TO_BUILDER = {
+        Dry::Struct::Sum => Builder::Composition::SumBuilder,
+        Dry::Types::Constrained => Builder::ConstrainedBuilder,
+        Dry::Types::Constructor => Builder::NestedBuilder,
+        Dry::Types::Default => Builder::DefaultBuilder,
+        Dry::Types::Enum => Builder::EnumBuilder,
+        Dry::Types::Intersection => Builder::Composition::IntersectionBuilder,
+        Dry::Types::Intersection::Constrained => Builder::Composition::IntersectionBuilder,
+        Dry::Types::Schema::Key => Builder::KeyBuilder,
+        Dry::Types::Sum => Builder::Composition::SumBuilder,
+        Dry::Types::Sum::Constrained => Builder::Composition::SumBuilder,
+        JsonModel::Types::Alias => Builder::AliasBuilder,
+        JsonModel::Types::AnyOf => Builder::Composition::AnyOfBuilder,
+        JsonModel::Types::OneOf => Builder::Composition::OneOfBuilder,
+        JsonModel::Types::Ref => Builder::RefBuilder,
+      }.freeze
+
+      # @param [Dry::Types::Type] type
+      # @return [Builder::BaseBuilder]
+      def for(type)
+        if TYPE_TO_BUILDER.key?(type.class)
+          TYPE_TO_BUILDER[type.class].new(type)
+        elsif type.respond_to?(:meta) && type.meta[:format]
+          Builder::FormatBuilder.for(type.meta[:format]).new(type)
+        elsif type.respond_to?(:primitive) && PRIMITIVE_TO_BUILDER.key?(type.primitive)
+          PRIMITIVE_TO_BUILDER[type.primitive].new(type)
+        elsif type.is_a?(Class) && type < Schema
+          SchemaBuilder.new(type)
+        else
+          raise("No builder available for type: #{type.inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/json_model/config/options.rb

@@ -13,15 +13,18 @@ module JsonModel
         @settings ||= {}
       end
 
+      # @param [Symbol] name
+      # @param [Object] default
+      # @param [Proc, nil] transformation
       def option(name, default: nil, &transformation)
         define_method(name) { settings[name] }
         define_method("#{name}=") do |value|
-          settings[name] = transformation.present? ? transformation.call(value) : value
+          settings[name] = transformation.nil? ? value : transformation.call(value)
         end
         module_function(name)
         module_function("#{name}=")
 
-        defaults[name] = transformation.present? ? transformation.call(default) : default
+        defaults[name] = transformation.nil? ? default : transformation.call(default)
         settings[name] = defaults[name]
       end
     end

data/lib/json_model/config.rb

@@ -38,8 +38,6 @@ module JsonModel
       end
     end
 
-    option(:validate_after_instantiation, default: true)
-
     option(:schema_version)
   end
 end