json_model_rb 0.1.20 → 0.1.22

data/lib/json_model/type_spec/composition.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Composition < TypeSpec
-      attr_reader(:types, :modifier, :discriminator)
-
-      # @param [Symbol] modifier
-      # @param [::Array<TypeSpec>] types
-      def initialize(modifier, *types, discriminator: nil)
-        super()
-        @types = types
-        @modifier = modifier
-        @discriminator = discriminator
-      end
-
-      # @param [Hash] options
-      # @return [Hash]
-      def as_schema(**options)
-        {
-          modifier => types.map { |type| type.as_schema(**options) },
-        }
-      end
-
-      # @return [Array<TypeSpec>]
-      def referenced_schemas
-        types.flat_map(&:referenced_schemas)
-      end
-
-      # @param [::Object] json
-      # @return [::Object, nil]
-      def cast(json)
-        raise(NotImplementedError)
-      end
-
-      protected
-
-      # @return [Hash, nil]
-      def type_map
-        if discriminator.nil?
-          return nil
-        end
-
-        @type_map ||= types.each_with_object({}) do |type, hash|
-          if !type.is_a?(Object)
-            raise('Discriminator property can only be used with Object types')
-          end
-
-          discriminator_property = type.type.properties[discriminator]
-          discriminator_values = if discriminator_property&.type.is_a?(Const)
-                                   [discriminator_property.type.value]
-                                 elsif discriminator_property&.type.is_a?(Enum)
-                                   discriminator_property.type.values
-                                 else
-                                   raise('Discriminator property must be of type Const or Enum')
-                                 end
-          discriminator_values.each do |value|
-            hash[value] ||= []
-            hash[value] << type
-          end
-        end
-      end
-
-      # @param [::Object] json
-      # @return [::Array<TypeSpec>]
-      def types_for(json)
-        if type_map.nil?
-          types
-        else
-          type_map[json[discriminator]]
-        end
-      end
-    end
-  end
-end
-
-require_relative('composition/all_of')
-require_relative('composition/any_of')
-require_relative('composition/one_of')

data/lib/json_model/type_spec/const.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Const < TypeSpec
-      attr_reader(:value)
-
-      # @param [String] value
-      def initialize(value)
-        super()
-        @value = value
-
-        if value.blank?
-          raise(ArgumentError, 'Const type spec requires a non-empty value')
-        end
-      end
-
-      # @param [Hash] _options
-      # @return [Hash]
-      def as_schema(**_options)
-        {
-          const: value,
-        }.compact
-      end
-
-      # @param [Symbol] name
-      # @param [ActiveModel::Validations] klass
-      def register_validations(name, klass)
-        super
-
-        klass.validates(name, inclusion: { in: value }, allow_nil: true)
-      end
-    end
-  end
-end

data/lib/json_model/type_spec/enum.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Enum < TypeSpec
-      attr_reader(:values)
-
-      # @param [Array<Object, nil>] values
-      def initialize(*values)
-        super()
-        @values = values
-
-        if @values.blank?
-          raise(ArgumentError, 'Enum type spec requires a non-empty enum array')
-        end
-      end
-
-      # @param [Hash] _options
-      # @return [Hash]
-      def as_schema(**_options)
-        {
-          enum: values,
-        }.compact
-      end
-
-      # @param [Symbol] name
-      # @param [ActiveModel::Validations] klass
-      def register_validations(name, klass)
-        super
-
-        klass.validates(name, inclusion: { in: values }, allow_nil: true)
-      end
-    end
-  end
-end

data/lib/json_model/type_spec/object.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Object < TypeSpec
-      attr_reader(:type)
-
-      # @param [Schema] type
-      def initialize(type)
-        super()
-        @type = type
-      end
-
-      # @param [Hash] options
-      # @return [Hash]
-      def as_schema(**options)
-        type.as_schema(**options)
-      end
-
-      # @return [Array<TypeSpec>]
-      def referenced_schemas
-        [type]
-      end
-
-      # @param [::Object] json
-      # @return [::Object, nil]
-      def cast(json)
-        type.from_json(**json)
-      end
-    end
-  end
-end

data/lib/json_model/type_spec/primitive/boolean.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Primitive
-      class Boolean < Primitive
-        def initialize
-          super(types: [TrueClass, FalseClass], schema_type: 'boolean')
-        end
-      end
-    end
-  end
-end

data/lib/json_model/type_spec/primitive/integer.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Primitive
-      class Integer < Numeric
-        # @param [Hash] options
-        def initialize(**options)
-          super(types: [::Integer], schema_type: 'integer', **options)
-        end
-
-        # @param [Symbol] name
-        # @param [ActiveModel::Validations] klass
-        def register_validations(name, klass)
-          super
-          klass.validates(name, numericality: { only_integer: true }, allow_nil: true)
-        end
-      end
-    end
-  end
-end

data/lib/json_model/type_spec/primitive/null.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Primitive
-      class Null < Primitive
-        def initialize
-          super(types: [NilClass], schema_type: 'null')
-        end
-      end
-    end
-  end
-end

data/lib/json_model/type_spec/primitive/number.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Primitive
-      class Number < Numeric
-        # @param [Hash] options
-        def initialize(**options)
-          super(types: [Float], schema_type: 'number', **options)
-        end
-      end
-    end
-  end
-end

data/lib/json_model/type_spec/primitive/numeric.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Primitive
-      class Numeric < Primitive
-        # @param [::Array<Class>] types
-        # @param [String] schema_type
-        # @param [Integer, nil] multiple_of
-        # @param [Integer, nil] minimum
-        # @param [Integer, nil] maximum
-        # @param [Integer, nil] exclusive_minimum
-        # @param [Integer, nil] exclusive_maximum
-        def initialize(
-          types:,
-          schema_type:,
-          multiple_of: nil,
-          minimum: nil,
-          maximum: nil,
-          exclusive_minimum: nil,
-          exclusive_maximum: nil
-        )
-          super(types: types, schema_type: schema_type)
-          @multiple_of = multiple_of
-          @minimum = minimum
-          @maximum = maximum
-          @exclusive_minimum = exclusive_minimum
-          @exclusive_maximum = exclusive_maximum
-        end
-
-        # @param [Hash] options
-        # @return [Hash]
-        def as_schema(**options)
-          super
-            .merge(
-              {
-                multipleOf: @multiple_of,
-                minimum: @minimum,
-                maximum: @maximum,
-                exclusiveMinimum: @exclusive_minimum,
-                exclusiveMaximum: @exclusive_maximum,
-              }.compact,
-            )
-        end
-
-        # @param [Symbol] name
-        # @param [ActiveModel::Validations] klass
-        def register_validations(name, klass)
-          super
-          register_multiple_of_validation(name, klass, @multiple_of)
-          if @minimum || @maximum || @exclusive_minimum || @exclusive_maximum
-            klass.validates_numericality_of(
-              name,
-              **{
-                greater_than: @exclusive_minimum,
-                less_than: @exclusive_maximum,
-                greater_than_or_equal_to: @minimum,
-                less_than_or_equal_to: @maximum,
-              }.compact,
-              allow_nil: true,
-            )
-          end
-        end
-
-        private
-
-        # @param [Symbol] name
-        # @param [ActiveModel::Validations] klass
-        # @param [Integer, nil] multiple_of
-        def register_multiple_of_validation(name, klass, multiple_of)
-          if multiple_of.nil?
-            return
-          end
-
-          klass.validate do |record|
-            value = record.send(name)
-            if value.present? && value % multiple_of != 0
-              record.errors.add(name, :multiple_of, message: "must be a multiple of #{multiple_of}")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/json_model/type_spec/primitive/string.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Primitive
-      class String < Primitive
-        JSON_SCHEMA_FORMATS = {
-          date_time: lambda { |v|
-            begin
-              DateTime.iso8601(v)
-              true
-            rescue StandardError
-              false
-            end
-          },
-          date: lambda { |v|
-            begin
-              Date.iso8601(v)
-              true
-            rescue StandardError
-              false
-            end
-          },
-          time: lambda { |v|
-            begin
-              Time.iso8601(v)
-              true
-            rescue StandardError
-              false
-            end
-          },
-          email: ->(v) { v.match?(URI::MailTo::EMAIL_REGEXP) },
-          hostname: ->(v) { v.match?(/\A[a-zA-Z0-9\-.]{1,253}\z/) },
-          ipv4: lambda { |v|
-            begin
-              IPAddr.new(v).ipv4?
-            rescue StandardError
-              false
-            end
-          },
-          ipv6: lambda { |v|
-            begin
-              IPAddr.new(v).ipv6?
-            rescue StandardError
-              false
-            end
-          },
-          uri: lambda { |v|
-            begin
-              URI.parse(v)
-              true
-            rescue StandardError
-              false
-            end
-          },
-          uri_reference: lambda { |v|
-            begin
-              URI.parse(v)
-              true
-            rescue StandardError
-              false
-            end
-          },
-          uuid: lambda { |v|
-            v.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i)
-          },
-          regex: lambda { |v|
-            begin
-              Regexp.new(v)
-              true
-            rescue StandardError
-              false
-            end
-          },
-          json_pointer: ->(v) { v.match?(%r{\A(?:/(?:[^~]|~[01])*)*\z}) },
-          relative_json_pointer: ->(v) { v.match?(%r{\A(?:0|[1-9][0-9]*)(?:#|(?:/(?:[^~]|~[01])*))*\z}) },
-        }.freeze
-
-        # @param [Integer, nil] min_length
-        # @param [Integer, nil] max_length
-        # @param [Regexp, nil] pattern
-        # @param [Symbol, nil] format
-        def initialize(min_length: nil, max_length: nil, pattern: nil, format: nil)
-          super(types: [::String], schema_type: 'string')
-
-          @min_length = min_length
-          @max_length = max_length
-          @pattern = pattern
-          @format = format
-        end
-
-        # @param [Hash] options
-        # @return [Hash]
-        def as_schema(**options)
-          super.merge(
-            {
-              minLength: @min_length,
-              maxLength: @max_length,
-              pattern: @pattern&.source,
-              format: @format&.to_s&.tr('_', '-'),
-            }.compact,
-          )
-        end
-
-        # @param [Symbol] name
-        # @param [ActiveModel::Validations]
-        def register_validations(name, klass)
-          super
-
-          if !@min_length.nil? || !@max_length.nil?
-            klass.validates(name, length: { minimum: @min_length, maximum: @max_length }.compact, allow_nil: true)
-          end
-          if @pattern
-            klass.validates(name, format: { with: @pattern }, allow_nil: true)
-          end
-          if @format
-            if JSON_SCHEMA_FORMATS.key?(@format)
-              register_format_validation(klass, name)
-            else
-              raise(ArgumentError, "Invalid format: #{@format}")
-            end
-          end
-        end
-
-        private
-
-        # @param [Class] klass
-        # @param [Symbol] name
-        def register_format_validation(klass, name)
-          if @format.nil?
-            return
-          end
-
-          format_validator = JSON_SCHEMA_FORMATS[@format]
-          if format_validator.nil?
-            return
-          end
-
-          klass.validate do |record|
-            value = record.send(name)
-
-            if !value.nil? && !format_validator.call(value)
-              record.errors.add(name, :invalid_format, message: "must be a valid #{@format}")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/json_model/type_spec/primitive.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module JsonModel
-  class TypeSpec
-    class Primitive < TypeSpec
-      # @param [::Array<Class>] types
-      # @param [String] schema_type
-      def initialize(types:, schema_type:)
-        super()
-        @types = types
-        @schema_type = schema_type
-      end
-
-      # @param [Hash] _options
-      # @return [Hash]
-      def as_schema(**_options)
-        { type: @schema_type }
-      end
-
-      # @param [::Object] json
-      # @return [::Object, nil]
-      def cast(json)
-        if json.nil?
-          nil
-        elsif @types.any? { |type| json.is_a?(type) }
-          json
-        else
-          raise(Errors::TypeError, "Expected one of #{@types.join('/')}, got #{json.class} (#{json.inspect})")
-        end
-      end
-    end
-  end
-end
-
-require_relative('primitive/boolean')
-require_relative('primitive/numeric')
-require_relative('primitive/integer')
-require_relative('primitive/null')
-require_relative('primitive/number')
-require_relative('primitive/string')

data/lib/json_model/type_spec.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require_relative('type_spec/array')
-require_relative('type_spec/castable')
-require_relative('type_spec/composition')
-require_relative('type_spec/const')
-require_relative('type_spec/enum')
-require_relative('type_spec/object')
-require_relative('type_spec/primitive')
-
-module JsonModel
-  class TypeSpec
-    TYPE_MAP = {
-      Date => Castable.new(format: 'date') { |v| ::DateTime.iso8601(v) },
-      DateTime => Castable.new(format: 'date-time') { |v| ::DateTime.iso8601(v) },
-      FalseClass => Primitive::Boolean.new,
-      Float => Primitive::Number.new,
-      Integer => Primitive::Integer.new,
-      NilClass => Primitive::Null.new,
-      Regexp => Castable.new(format: 'regex') { |v| Regexp.new(v) },
-      String => Primitive::String.new,
-      Time => Castable.new(format: 'time') { |v| ::Time.iso8601(v) },
-      TrueClass => Primitive::Boolean.new,
-      URI => Castable.new(format: 'uri') { |v| URI.parse(v) },
-    }.freeze
-
-    # @param [Hash] options
-    # @return [Hash]
-    def as_schema(**options)
-      raise(NotImplementedError)
-    end
-
-    # @param [Symbol] name
-    # @param [ActiveModel::Validations] klass
-    def register_validations(name, klass) end
-
-    # @return [Array<TypeSpec>]
-    def referenced_schemas
-      []
-    end
-
-    # @param [::Object] json
-    # @return [::Object, nil]
-    def cast(json)
-      json
-    end
-
-    class << self
-      # @param [Object, Class] type
-      # @return [TypeSpec]
-      def resolve(type)
-        if type.is_a?(TypeSpec)
-          return type
-        end
-
-        if TYPE_MAP.key?(type)
-          TYPE_MAP[type]
-        elsif type.respond_to?(:to_type_spec)
-          type.to_type_spec
-        elsif type.is_a?(Class) && type < Schema
-          TypeSpec::Object.new(type)
-        else
-          raise(ArgumentError, "Unsupported type: #{type}")
-        end
-      end
-
-      private
-
-      # @param [Object, Class] type
-      # @return [TypeSpec]
-      def resolve_type_from_class(type)
-        if TYPE_MAP.key?(type)
-          TYPE_MAP[type]
-        elsif type < Schema
-          TypeSpec::Object.new(type)
-        else
-          raise(ArgumentError, "Unsupported type: #{type}")
-        end
-      end
-    end
-  end
-end

data/lib/json_model/types/all_of.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module T
-  class AllOf
-    # @param [Array<Class>] types
-    # @param [Hash] options
-    def initialize(*types, **options)
-      @types = types
-      @options = options
-    end
-
-    # @return [JsonModel::TypeSpec::Composition::AllOf]
-    def to_type_spec
-      JsonModel::TypeSpec::Composition::AllOf.new(
-        *@types.map { |type| JsonModel::TypeSpec.resolve(type) },
-        **@options,
-      )
-    end
-
-    class << self
-      # @param [Array] types
-      # @param [Hash] options
-      # @return [AllOf]
-      def [](*types, **options)
-        AllOf.new(*types, **options)
-      end
-    end
-  end
-end

data/lib/json_model/types/array.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module T
-  class Array
-    # @param [Class] type
-    # @param [Hash] options
-    def initialize(type, **options)
-      @type = type
-      @options = options
-    end
-
-    # @return [JsonModel::TypeSpec::Array]
-    def to_type_spec
-      JsonModel::TypeSpec::Array.new(
-        JsonModel::TypeSpec.resolve(@type),
-        **@options,
-      )
-    end
-
-    class << self
-      # @param [Class] type
-      # @param [Hash] options
-      # @return [Array]
-      def [](type, **options)
-        Array.new(type, **options)
-      end
-    end
-  end
-end

data/lib/json_model/types/boolean.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module T
-  Boolean = Class.new do
-    def to_type_spec = JsonModel::TypeSpec::Primitive::Boolean.new
-  end.new
-end

data/lib/json_model/types/const.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module T
-  class Const
-    # @param [String] value
-    def initialize(value)
-      @value = value
-    end
-
-    # @return [JsonModel::TypeSpec::Const]
-    def to_type_spec
-      JsonModel::TypeSpec::Const.new(*@value)
-    end
-
-    class << self
-      # @param [Array] args
-      # @return [Const]
-      def [](*args)
-        Const.new(*args)
-      end
-    end
-  end
-end