json_model_rb 0.1.1

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Primitive
+      class Integer < Numeric
+        # @param [Hash] options
+        def initialize(**options)
+          super('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

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

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

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

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Primitive
+      class Numeric < Primitive
+        # @param [String] 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(
+          type,
+          multiple_of: nil,
+          minimum: nil,
+          maximum: nil,
+          exclusive_minimum: nil,
+          exclusive_maximum: nil
+        )
+          super(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

@@ -0,0 +1,150 @@
+# 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|
+            SecureRandom(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 [String, nil] format
+        def initialize(min_length: nil, max_length: nil, pattern: nil, format: nil)
+          super('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
+
+        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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Primitive < TypeSpec
+      # @param [String] type
+      def initialize(type)
+        super()
+        @type = type
+      end
+
+      # @param [Hash] _options
+      # @return [Hash]
+      def as_schema(**_options)
+        { type: @type }
+      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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative('type_spec/array')
+require_relative('type_spec/composition')
+require_relative('type_spec/enum')
+require_relative('type_spec/object')
+require_relative('type_spec/primitive')
+
+module JsonModel
+  class TypeSpec
+    # @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
+
+    class << self
+      # @param [Object] type
+      # @param [Hash] options
+      # @return [TypeSpec]
+      def resolve(type, **options)
+        case type
+        when TypeSpec
+          type
+        when Class
+          resolve_type_from_class(type, **options)
+        when T::AllOf, T::AnyOf, T::Boolean, T::OneOf, T::Array, T::Enum
+          type.to_type_spec(**options)
+        else
+          raise(ArgumentError, "Unsupported type: #{type}")
+        end
+      end
+
+      private
+
+      # @param [Object] type
+      # @param [Hash] options
+      # @return [TypeSpec]
+      def resolve_type_from_class(type, **options)
+        if type == String
+          Primitive::String.new(**options)
+        elsif type == Integer
+          Primitive::Integer.new(**options)
+        elsif type == Float
+          Primitive::Number.new(**options)
+        elsif [TrueClass, FalseClass].include?(type)
+          Primitive::Boolean.new(**options)
+        elsif type == NilClass
+          Primitive::Null.new(**options)
+        elsif type < Schema
+          TypeSpec::Object.new(type, **options)
+        else
+          raise(ArgumentError, "Unsupported type: #{type}")
+        end
+      end
+    end
+  end
+end

data/lib/json_model/types/all_of.rb

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

data/lib/json_model/types/any_of.rb

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

data/lib/json_model/types/array.rb

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

data/lib/json_model/types/boolean.rb

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

data/lib/json_model/types/enum.rb

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

data/lib/json_model/types/one_of.rb

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

data/lib/json_model/types.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative('types/all_of')
+require_relative('types/any_of')
+require_relative('types/boolean')
+require_relative('types/one_of')
+require_relative('types/array')
+require_relative('types/enum')

data/lib/json_model/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JsonModel
+  VERSION = '0.1.1'
+end

data/lib/json_model.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require('active_model')
+require('active_support/concern')
+require('active_support/core_ext/class/attribute')
+require('active_support/descendants_tracker')
+require('uri')
+require('json_model/config')
+require('json_model/errors')
+require('json_model/properties')
+require('json_model/property')
+require('json_model/ref_mode')
+require('json_model/schema_meta')
+require('json_model/schema')
+require('json_model/type_spec')
+require('json_model/types')
+require('json_model/version')
+
+module JsonModel
+  class << self
+    # @return [Config]
+    def configure(&)
+      yield(Config)
+    end
+
+    # @return [Config]
+    def config
+      Config
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe(JsonModel::Config) do
+  describe('#property_naming_strategy') do
+    it('defaults to identity') do
+      value = SecureRandom.uuid.to_sym
+      expect(described_class.property_naming_strategy.call(value))
+        .to(eq(value))
+    end
+
+    it('can be changed to a proc') do
+      value = SecureRandom.uuid.to_sym
+      JsonModel.configure { |config| config.property_naming_strategy = ->(value) { value.to_s.upcase.to_sym } }
+
+      expect(described_class.property_naming_strategy.call(value))
+        .to(eq(value.to_s.upcase.to_sym))
+    end
+
+    it('can be changed to pascal case') do
+      JsonModel.configure { |config| config.property_naming_strategy = :pascal_case }
+
+      expect(described_class.property_naming_strategy.call(:foo_bar))
+        .to(eq('FooBar'))
+    end
+
+    it('can be changed to camel case') do
+      JsonModel.configure { |config| config.property_naming_strategy = :camel_case }
+
+      expect(described_class.property_naming_strategy.call(:foo_bar))
+        .to(eq('fooBar'))
+    end
+  end
+
+  describe('#validate_after_instantiation') do
+    it('defaults to true') do
+      expect(JsonModel.config.validate_after_instantiation)
+        .to(eq(true))
+    end
+
+    it('can be changed to false') do
+      JsonModel.configure { |config| config.validate_after_instantiation = false }
+
+      expect(JsonModel.config.validate_after_instantiation)
+        .to(eq(false))
+    end
+  end
+
+  describe('#schema_id_base_uri') do
+    it('defaults to nil') do
+      expect(JsonModel.config.schema_id_base_uri)
+        .to(be_nil)
+    end
+
+    it('can be changed to false') do
+      JsonModel.configure { |config| config.schema_id_base_uri = 'https://example.com/schemas/' }
+
+      expect(JsonModel.config.schema_id_base_uri)
+        .to(eq('https://example.com/schemas/'))
+    end
+  end
+
+  describe('#schema_id_naming_strategy') do
+    let(:klass) do
+      Class.new do
+        def self.name
+          'Baz::FooBar'
+        end
+      end
+    end
+
+    it('defaults to none') do
+      expect(JsonModel.config.schema_id_naming_strategy.call(klass))
+        .to(be_nil)
+    end
+
+    it('can be changed to class_name') do
+      JsonModel.configure { |config| config.schema_id_naming_strategy = :class_name }
+
+      expect(JsonModel.config.schema_id_naming_strategy.call(klass))
+        .to(eq('FooBar'))
+    end
+
+    it('can be changed to kebab_case_class_name') do
+      JsonModel.configure { |config| config.schema_id_naming_strategy = :kebab_case_class_name }
+
+      expect(JsonModel.config.schema_id_naming_strategy.call(klass))
+        .to(eq('foo-bar'))
+    end
+
+    it('can be changed to snake_case_class_name') do
+      JsonModel.configure { |config| config.schema_id_naming_strategy = :snake_case_class_name }
+
+      expect(JsonModel.config.schema_id_naming_strategy.call(klass))
+        .to(eq('foo_bar'))
+    end
+
+    it('can use a custom proc') do
+      JsonModel.configure { |config| config.schema_id_naming_strategy = ->(klass) { klass.name.downcase } }
+
+      expect(JsonModel.config.schema_id_naming_strategy.call(klass))
+        .to(eq('baz::foobar'))
+    end
+  end
+end

data/spec/json_model_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe(JsonModel) do
+  it('has a version number') do
+    expect(JsonModel::VERSION).not_to(be(nil))
+  end
+end