json_model_rb 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6055ccf369735b5c3461df4c1e1c84fb376bbfb56db264c4b2cff411a0408f7b
+  data.tar.gz: 269014c71581e5fa7053b00e37cd0e9faa854b2af11b243aab322da3673cc758
+SHA512:
+  metadata.gz: 9e9145acb6866d32cd0a34a507bf9b30658c7197e5098e630f679bd874697639d66cf17c60fd9b8534418c6f01c7470508193077e260d935845b6275ee5f9636
+  data.tar.gz: 1d5c2c8cd76cb864be16eb30787a53349ccc5c28f08d159f6e1984e87264c91dea759184ed7f67ff61720bf912e92deeaa1a014c560338ca86694ab5288585c4

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 gillesbergerp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/json_model/config/options.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Config
+    module Options
+      # @return [Hash]
+      def defaults
+        @defaults ||= {}
+      end
+
+      # @return [Hash]
+      def settings
+        @settings ||= {}
+      end
+
+      def option(name, default: nil, &transformation)
+        define_method(name) { settings[name] }
+        define_method("#{name}=") do |value|
+          settings[name] = transformation.present? ? transformation.call(value) : value
+        end
+        module_function(name)
+        module_function("#{name}=")
+
+        defaults[name] = transformation.present? ? transformation.call(default) : default
+        settings[name] = defaults[name]
+      end
+    end
+  end
+end

data/lib/json_model/config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require('active_support/core_ext/string')
+require_relative('config/options')
+
+module JsonModel
+  module Config
+    extend(JsonModel::Config::Options)
+
+    PROPERTY_NAMING_STRATEGIES = {
+      identity: lambda(&:to_sym),
+      camel_case: ->(property_name) { property_name.to_s.tr('-', '_').camelize(:lower) },
+      pascal_case: ->(property_name) { property_name.to_s.tr('-', '_').camelize },
+    }.freeze
+
+    SCHEMA_ID_NAMING_STRATEGIES = {
+      class_name: ->(klass) { klass.name.demodulize },
+      kebab_case_class_name: ->(klass) { klass.name.demodulize.underscore.tr('_', '-') },
+      none: ->(_) {},
+      snake_case_class_name: ->(klass) { klass.name.demodulize.underscore },
+    }.freeze
+
+    option(:property_naming_strategy, default: :identity) do |value|
+      if value.is_a?(Proc)
+        value
+      else
+        PROPERTY_NAMING_STRATEGIES[value]
+      end
+    end
+
+    option(:schema_id_base_uri, default: nil)
+
+    option(:schema_id_naming_strategy, default: :none) do |value|
+      if value.is_a?(Proc)
+        value
+      else
+        SCHEMA_ID_NAMING_STRATEGIES[value]
+      end
+    end
+
+    option(:validate_after_instantiation, default: true)
+  end
+end

data/lib/json_model/errors/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Errors
+    class Error < StandardError; end
+  end
+end

data/lib/json_model/errors/invalid_ref_mode_error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Errors
+    class InvalidRefModeError < Error
+      # @param [Symbol] ref_mode
+      def initialize(ref_mode)
+        super("Invalid ref_mode: #{ref_mode}.")
+      end
+    end
+  end
+end

data/lib/json_model/errors/unknown_attribute_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Errors
+    class UnknownAttributeError < Error
+      # @param [Class] klass
+      # @param [Symbol] name
+      def initialize(klass, name)
+        super("Unknown attribute '#{name}' for '#{klass}'.")
+      end
+    end
+  end
+end

data/lib/json_model/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative('errors/error')
+require_relative('errors/invalid_ref_mode_error')
+require_relative('errors/unknown_attribute_error')

data/lib/json_model/properties.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Properties
+    extend(ActiveSupport::Concern)
+
+    included do
+      extend(ActiveSupport::DescendantsTracker)
+      include(ActiveModel::Validations)
+
+      class_attribute(:attributes, instance_writer: false, default: {})
+      class_attribute(:properties, instance_writer: false, default: {})
+    end
+
+    class_methods do
+      # @param [Symbol] name
+      # @param [Object] type
+      # @param [Hash] options
+      def property(name, type:, **options)
+        property_options = options.slice(:default, :optional, :ref_mode)
+        resolved_type = TypeSpec.resolve(type, **options.except(:default, :optional, :ref_mode))
+        add_property(name, type: resolved_type, **property_options)
+        descendants.each { |subclass| subclass.add_property(name, type: resolved_type, **property_options) }
+      end
+
+      protected
+
+      # @param [Symbol] name
+      # @param [TypeSpec] type
+      # @param [Hash] options
+      def add_property(name, type:, **options)
+        property = Property.new(name, type: type, **options)
+        properties[name] = property
+        define_accessors(property)
+        define_validations(property)
+      end
+
+      # @param [Property] property
+      def define_accessors(property)
+        define_getter(property)
+        define_setter(property)
+      end
+
+      # @param [Property] property
+      def define_getter(property)
+        define_method(property.name) do
+          if attributes.key?(property.name)
+            attributes[property.name]
+          else
+            property.default
+          end
+        end
+      end
+
+      # @param [Property] property
+      def define_setter(property)
+        define_method("#{property.name}=") { |value| attributes[property.name] = value }
+      end
+
+      # @param [Property] property
+      def define_validations(property)
+        property.register_validations(self)
+      end
+    end
+  end
+end

data/lib/json_model/property.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class Property
+    attr_reader(:name, :default, :type, :optional, :alias)
+
+    # @param [Symbol] name
+    # @param [TypeSpec] type
+    # @param [Object, nil] default
+    # @param [Boolean] optional
+    # @param [Symbol] ref_mode
+    # @param [Symbol, nil] as
+    def initialize(name, type:, default: nil, optional: false, ref_mode: RefMode::INLINE, as: nil)
+      @name = name
+      @type = type
+      @default = default
+      @optional = optional
+      @ref_mode = ref_mode
+      @alias = as || JsonModel.config.property_naming_strategy.call(name).to_sym
+    end
+
+    # @param [Hash] options
+    # @return [Hash]
+    def as_schema(**options)
+      {
+        self.alias => type
+                        .as_schema(**options, ref_mode: @ref_mode)
+                        .merge({ default: default }.compact),
+      }
+    end
+
+    # @param [ActiveModel::Validations]
+    def register_validations(klass)
+      if required?
+        klass.validates(name, presence: true)
+      end
+      type.register_validations(name, klass)
+    end
+
+    # @return [Boolean]
+    def required?
+      !optional
+    end
+
+    # @return [Array]
+    def referenced_schemas
+      if @ref_mode == RefMode::LOCAL
+        type.referenced_schemas
+      else
+        []
+      end
+    end
+  end
+end

data/lib/json_model/ref_mode.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module RefMode
+    EXTERNAL = :external
+    INLINE = :inline
+    LOCAL = :local
+  end
+end

data/lib/json_model/schema.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Schema
+    extend(ActiveSupport::Concern)
+    include(Properties)
+    include(SchemaMeta)
+
+    # @param [Hash, nil] attributes
+    def initialize(attributes = nil)
+      return unless attributes
+
+      assign_attributes(attributes)
+
+      if JsonModel.config.validate_after_instantiation
+        validate!
+      end
+    end
+
+    private
+
+    # @param [Hash, nil] attributes
+    def assign_attributes(attributes)
+      attributes.each { |name, value| assign_attribute(name, value) }
+    end
+
+    # @param [Symbol] name
+    # @param [Object] value
+    def assign_attribute(name, value)
+      if respond_to?("#{name}=")
+        send("#{name}=", value)
+      elsif !self.class.additional_properties && JsonModel.config.validate_after_instantiation
+        raise(Errors::UnknownAttributeError.new(self.class, name))
+      end
+    end
+
+    class_methods do
+      # @param [Symbol] ref_mode
+      # @param [Hash] _options
+      # @return [Hash]
+      def as_schema(ref_mode: RefMode::INLINE, **_options)
+        case ref_mode
+        when RefMode::INLINE
+          meta_attributes
+            .merge(
+              properties: properties_as_schema,
+              required: required_properties_as_schema,
+              '$defs': defs_as_schema,
+            )
+            .merge(type: 'object')
+            .compact
+        when RefMode::LOCAL
+          { '$ref': "#/$defs/#{name}" }
+        when RefMode::EXTERNAL
+          { '$ref': schema_id }
+        else
+          raise(Errors::InvalidRefModeError, ref_mode)
+        end
+      end
+
+      # @return [Hash, nil]
+      def properties_as_schema
+        if local_properties.any?
+          local_properties
+            .sort_by { |key, _property| key }
+            .map { |_key, property| property.as_schema }
+            .inject({}, &:merge)
+        end
+      end
+
+      # @return [Array, nil]
+      def required_properties_as_schema
+        if local_properties.any?
+          local_properties
+            .values
+            .select(&:required?)
+            .map(&:alias)
+            .sort
+        end
+      end
+
+      def defs_as_schema
+        referenced_schemas = local_properties
+                               .values
+                               .flat_map(&:referenced_schemas)
+                               .uniq
+
+        if referenced_schemas.any?
+          referenced_schemas.to_h { |type| [type.name.to_sym, type.as_schema] }
+        end
+      end
+
+      # @return [Array<Class>]
+      def parent_schemas
+        @parent_schemas ||= ancestors.select { |klass| klass != self && klass < Schema }
+      end
+
+      # @return [Hash]
+      def local_properties
+        if !defined?(@local_properties)
+          ancestor_properties = parent_schemas.flat_map { |property| property.properties.values }
+          @local_properties = properties.select do |_key, property|
+            ancestor_properties.none? { |ancestor_property| ancestor_property == property }
+          end
+        end
+
+        @local_properties
+      end
+    end
+  end
+end

data/lib/json_model/schema_meta.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module SchemaMeta
+    extend(ActiveSupport::Concern)
+
+    SCHEMA_VERSIONS = {
+      draft4: 'http://json-schema.org/draft-04/schema#',
+      draft6: 'http://json-schema.org/draft-06/schema#',
+      draft7: 'http://json-schema.org/draft-07/schema#',
+      draft201909: 'https://json-schema.org/draft/2019-09/schema',
+      draft202012: 'https://json-schema.org/draft/2020-12/schema',
+    }.freeze
+
+    included do
+      class_attribute(:meta_attributes, instance_writer: false, default: {})
+      class_attribute(:ref_schema, instance_writer: false)
+
+      # @param [Class] subclass
+      def self.inherited(subclass)
+        super
+        subclass.meta_attributes[:$ref] = schema_id
+      end
+
+      schema_id(name)
+    end
+
+    class_methods do
+      # @param [String, nil] id
+      # @return [String, nil]
+      def schema_id(id = nil)
+        if id
+          meta_attributes[:$id] = URI.parse("#{JsonModel.config.schema_id_base_uri}#{id}").to_s
+        else
+          meta_attributes[:$id]
+        end
+      end
+
+      # @param [Boolean, nil] value
+      # @return [Boolean]
+      def additional_properties(value = nil)
+        if value.nil?
+          meta_attributes[:additionalProperties] || false
+        else
+          meta_attributes[:additionalProperties] = value
+        end
+      end
+
+      # @param [Symbol, nil] version
+      # @return [Boolean]
+      def schema_version(version = nil)
+        if version.nil?
+          meta_attributes[:$schema]
+        else
+          meta_attributes[:$schema] = SCHEMA_VERSIONS[version]
+        end
+      end
+    end
+  end
+end

data/lib/json_model/type_spec/array.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Array < TypeSpec
+      # @param [TypeSpec] type
+      # @param [Integer, nil] min_items
+      # @param [Integer, nil] max_items
+      # @param [Boolean, nil] unique_items
+      def initialize(type, min_items: nil, max_items: nil, unique_items: nil)
+        super()
+        @type = type
+        @min_items = min_items
+        @max_items = max_items
+        @unique_items = unique_items
+      end
+
+      # @param [Hash] options
+      # @return [Hash]
+      def as_schema(**options)
+        {
+          type: 'array',
+          items: @type.as_schema(**options),
+          minItems: @min_items,
+          maxItems: @max_items,
+          uniqueItems: @unique_items,
+        }.compact
+      end
+
+      # @param [Symbol] name
+      # @param [ActiveModel::Validations] klass
+      def register_validations(name, klass)
+        super
+
+        if @min_items || @max_items
+          klass.validates(name, length: { minimum: @min_items, maximum: @max_items }.compact, allow_nil: true)
+        end
+        if @unique_items
+          register_uniqueness_validation(name, klass)
+        end
+      end
+
+      # @return [Array<TypeSpec>]
+      def referenced_schemas
+        @type.referenced_schemas
+      end
+
+      private
+
+      # @param [Symbol] name
+      # @param [ActiveModel::Validations] klass
+      def register_uniqueness_validation(name, klass)
+        klass.validate do |record|
+          duplicates = record.send(name)&.group_by(&:itself)&.select { |_k, v| v.size > 1 }&.keys
+          if !duplicates.nil? && duplicates.any?
+            record.errors.add(:tags, :uniqueness, message: "contains duplicates: #{duplicates.join(', ')}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_model/type_spec/composition/all_of.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Composition
+      class AllOf < Composition
+        # @param [TypeSpec] types
+        # @param [Hash] options
+        def initialize(*types, **options)
+          super(:allOf, *types, **options)
+        end
+      end
+    end
+  end
+end

data/lib/json_model/type_spec/composition/any_of.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Composition
+      class AnyOf < Composition
+        # @param [TypeSpec] types
+        # @param [Hash] options
+        def initialize(*types, **options)
+          super(:anyOf, *types, **options)
+        end
+      end
+    end
+  end
+end

data/lib/json_model/type_spec/composition/one_of.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Composition
+      class OneOf < Composition
+        # @param [TypeSpec] types
+        # @param [Hash] options
+        def initialize(*types, **options)
+          super(:oneOf, *types, **options)
+        end
+      end
+    end
+  end
+end

data/lib/json_model/type_spec/composition.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Composition < TypeSpec
+      # @param [Symbol] modifier
+      # @param [TypeSpec] types
+      def initialize(modifier, *types)
+        super()
+        @types = types
+        @modifier = modifier
+      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
+    end
+  end
+end
+
+require_relative('composition/all_of')
+require_relative('composition/any_of')
+require_relative('composition/one_of')

data/lib/json_model/type_spec/enum.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Enum < TypeSpec
+      # @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 })
+      end
+    end
+  end
+end

data/lib/json_model/type_spec/object.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Object < TypeSpec
+      # @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
+    end
+  end
+end

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

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