json_model_rb 0.1.20 → 0.1.23

data/lib/json_model/errors.rb

@@ -1,6 +1,3 @@
 # frozen_string_literal: true
 
 require_relative('errors/error')
-require_relative('errors/invalid_ref_mode_error')
-require_relative('errors/type_error')
-require_relative('errors/unknown_attribute_error')

data/lib/json_model/logic/predicates/methods.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Logic
+    module Predicates
+      module Methods
+        # @param [Array] value
+        # @return [FalseClass, TrueClass]
+        def unique?(value)
+          value.respond_to?(:uniq) && value.uniq.size == value.size
+        end
+      end
+    end
+  end
+end
+
+Dry::Logic::Predicates::Methods.prepend(JsonModel::Logic::Predicates::Methods)

data/lib/json_model/predicates.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative('logic/predicates/methods')

data/lib/json_model/schema.rb

@@ -1,122 +1,98 @@
 # frozen_string_literal: true
 
+require_relative('builder')
+require_relative('schema_meta')
+
 module JsonModel
   module Schema
     extend(ActiveSupport::Concern)
-    include(Composeable)
-    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)
-      else
-        self.class.raise_unknown_attribute_error(name)
-      end
-    end
-
     class_methods do
       # @param [::Object] json
       # @return [::Object, nil]
       def from_json(json)
-        attributes = json.transform_keys { |key| invert_alias(key) || raise_unknown_attribute_error(key) }
+        attributes = json.transform_keys { |key| invert_alias(key) }
         new(attributes)
       end
 
-      # @param [Symbol] name
-      def raise_unknown_attribute_error(name)
-        if !additional_properties && JsonModel.config.validate_after_instantiation
-          raise(Errors::UnknownAttributeError.new(self, name))
-        end
+      # @param [Symbol] key
+      # @return [Symbol]
+      def invert_alias(key)
+        builder = local_builders.find { |b| b.alias.to_s == key.to_s }
+        builder&.type&.name || key
       end
 
-      # @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(**composed_types_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
+      def as_schema
+        {
+          properties: properties_as_schema,
+          required: required_properties_as_schema,
+          '$defs': defs_as_schema,
+        }
+          .merge(type: 'object')
+          .merge(meta_attributes)
+          .compact
       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 }
+        if local_builders.any?
+          local_builders
+            .sort_by(&:alias)
+            .map(&:as_schema)
             .inject({}, &:merge)
         end
       end
 
       # @return [Array, nil]
       def required_properties_as_schema
-        if local_properties.any?
-          local_properties
-            .values
-            .select(&:required?)
+        if local_builders.any?
+          local_builders
+            .reject(&:optional?)
             .map(&:alias)
             .sort
         end
       end
 
+      # @return [Hash, nil]
       def defs_as_schema
-        referenced_schemas = (composed_type_defs + local_properties.values.flat_map(&:referenced_schemas)).uniq
+        referenced_schemas = local_builders
+                               .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 }
+      # @return [Array<Builder>]
+      def local_builders
+        @local_builders ||= @schema
+                              .type
+                              .reject { |type| parent_keys.include?(type) }
+                              .map { |type| Builder.for(type) }
       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.as_schema == property.as_schema }
-          end
-        end
+      # @return [Array<Builder>]
+      def builders
+        @builders ||= @local_builders + @schema
+                                          .type
+                                          .select { |type| parent_keys.include?(type) }
+                                          .map { |type| Builder.for(type) }
+      end
+
+      # @return [Array<Class>]
+      def parent_keys
+        @parent_keys ||= ancestors
+                           .select { |klass| referenceable_parent?(klass) }
+                           .flat_map { |klass| klass.schema.type.keys }
+      end
 
-        @local_properties
+      # @param [Class] klass
+      # @return [FalseClass, TrueClass]
+      def referenceable_parent?(klass)
+        klass < JsonModel::Schema && klass != self && schema_id != klass.schema_id
       end
     end
   end

data/lib/json_model/schema_meta.rb

@@ -16,8 +16,7 @@ module JsonModel
       # @param [Class] subclass
       def self.inherited(subclass)
         super
-        subclass.schema_id(JsonModel.config.schema_id_naming_strategy.call(subclass))
-        subclass.schema_version(JsonModel.config.schema_version)
+        subclass.meta_attributes.merge!(meta_attributes.dup)
         subclass.meta_attributes[:$ref] = schema_id
       end
 
@@ -26,11 +25,6 @@ module JsonModel
     end
 
     class_methods do
-      # @return [Hash]
-      def meta_attributes
-        @meta_attributes ||= {}
-      end
-
       # @param [String, nil] description
       # @return [String, nil]
       def description(description = nil)
@@ -61,28 +55,8 @@ module JsonModel
         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 [Boolean, nil] value
-      # @return [Boolean]
-      def unevaluated_properties(value = nil)
-        if value.nil?
-          meta_attributes[:unevaluatedProperties] || false
-        else
-          meta_attributes[:unevaluatedProperties] = value
-        end
-      end
-
       # @param [Symbol, nil] version
-      # @return [Boolean]
+      # @return [TrueClass, FalseClass]
       def schema_version(version = nil)
         if version.nil?
           meta_attributes[:$schema]
@@ -90,6 +64,11 @@ module JsonModel
           meta_attributes[:$schema] = SCHEMA_VERSIONS[version]
         end
       end
+
+      # @return [Hash]
+      def meta_attributes
+        @meta_attributes ||= { unevaluatedProperties: @schema&.strict? ? false : nil }.compact
+      end
     end
   end
 end

data/lib/json_model/types/alias.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Types
+    class Alias < Dry::Types::Constructor
+      # @return [Array]
+      def to_ast
+        [
+          :alias,
+          [
+            options[:as],
+            type.to_ast,
+          ],
+        ]
+      end
+
+      # @return [Symbol]
+      def alias
+        options[:as]
+      end
+
+      module Builder
+        # @param [Symbol] name
+        # @return [Alias]
+        def as(name)
+          Alias.new(self, as: name) { |input| input }
+        end
+      end
+    end
+  end
+end
+
+Dry::Types::Builder.prepend(JsonModel::Types::Alias::Builder)

data/lib/json_model/types/any_of.rb

@@ -1,28 +1,59 @@
 # frozen_string_literal: true
 
-module T
-  class AnyOf
-    # @param [Array<Class>] types
-    # @param [Hash] options
-    def initialize(*types, **options)
-      @types = types
-      @options = options
+module JsonModel
+  module Types
+    class << self
+      # @param [Symbol] tag_key
+      # @return [AnyOf]
+      def any_of(tag_key, &)
+        builder = AnyOf::Builder.new(tag_key)
+        builder.instance_eval(&)
+        builder.build
+      end
     end
 
-    # @return [JsonModel::TypeSpec::Composition::AnyOf]
-    def to_type_spec
-      JsonModel::TypeSpec::Composition::AnyOf.new(
-        *@types.map { |type| JsonModel::TypeSpec.resolve(type) },
-        **@options,
-      )
-    end
+    class AnyOf < Dry::Types::Constructor
+      attr_reader(:tag_key, :mapping)
 
-    class << self
-      # @param [Array] types
-      # @param [Hash] options
-      # @return [AnyOf]
-      def [](*types, **options)
-        AnyOf.new(*types, **options)
+      # @return [Array]
+      def to_ast
+        [
+          :any_of,
+          {
+            tag_key: options[:tag_key],
+            mapping: options[:mapping].transform_values do |type|
+              type.respond_to?(:to_ast) ? type.to_ast : type.class.name
+            end,
+            meta: meta,
+          },
+        ]
+      end
+
+      class Builder
+        attr_reader(:tag_key, :mapping)
+
+        # @param [Symbol] tag_key
+        def initialize(tag_key)
+          @tag_key = tag_key
+          @mapping = {}
+        end
+
+        # @param [Array<Symbol>] tags
+        # @param [Dry::Types::Type] type
+        def on(*tags, type)
+          tags.each { |tag| mapping[tag] = type }
+        end
+
+        # @return [AnyOf]
+        def build
+          AnyOf.new(mapping.values.map(&:type).uniq.reduce(&:|), tag_key: tag_key, mapping: mapping) do |input|
+            tag = input[tag_key]
+            type = mapping[tag]
+            raise(Dry::Types::ConstraintError, "Unknown tag #{tag.inspect}") unless type
+
+            type[input]
+          end
+        end
       end
     end
   end

data/lib/json_model/types/one_of.rb

@@ -1,28 +1,59 @@
 # frozen_string_literal: true
 
-module T
-  class OneOf
-    # @param [Array<Class>] types
-    # @param [Hash] options
-    def initialize(*types, **options)
-      @types = types
-      @options = options
+module JsonModel
+  module Types
+    class << self
+      # @param [Symbol] tag_key
+      # @return [OneOf]
+      def one_of(tag_key, &)
+        builder = OneOf::Builder.new(tag_key)
+        builder.instance_eval(&)
+        builder.build
+      end
     end
 
-    # @return [JsonModel::TypeSpec::Composition::OneOf]
-    def to_type_spec
-      JsonModel::TypeSpec::Composition::OneOf.new(
-        *@types.map { |type| JsonModel::TypeSpec.resolve(type) },
-        **@options,
-      )
-    end
+    class OneOf < Dry::Types::Constructor
+      attr_reader(:tag_key, :mapping)
 
-    class << self
-      # @param [Array] types
-      # @param [Hash] options
-      # @return [OneOf]
-      def [](*types, **options)
-        OneOf.new(*types, **options)
+      # @return [Array]
+      def to_ast
+        [
+          :one_of,
+          {
+            tag_key: options[:tag_key],
+            mapping: options[:mapping].transform_values do |type|
+              type.respond_to?(:to_ast) ? type.to_ast : type.class.name
+            end,
+            meta: meta,
+          },
+        ]
+      end
+
+      class Builder
+        attr_reader(:tag_key, :mapping)
+
+        # @param [Symbol] tag_key
+        def initialize(tag_key)
+          @tag_key = tag_key
+          @mapping = {}
+        end
+
+        # @param [Array<Symbol>] tags
+        # @param [Dry::Types::Type] type
+        def on(*tags, type)
+          tags.each { |tag| mapping[tag] = type }
+        end
+
+        # @return [OneOf]
+        def build
+          OneOf.new(mapping.values.uniq.reduce(&:|), tag_key: tag_key, mapping: mapping) do |input|
+            tag = input[tag_key]
+            type = mapping[tag]
+            raise(Dry::Types::ConstraintError, "Unknown tag #{tag.inspect}") unless type
+
+            type[input]
+          end
+        end
       end
     end
   end

data/lib/json_model/types/ref.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Types
+    class Ref < Dry::Types::Constructor
+      # @return [Array]
+      def to_ast
+        [
+          :ref,
+          [
+            options[:mode],
+            type.to_ast,
+          ],
+        ]
+      end
+
+      module Builder
+        # @return [Ref]
+        def external
+          Ref.new(self, mode: :external) { |input| input }
+        end
+
+        # @return [Ref]
+        def local
+          Ref.new(self, mode: :local) { |input| input }
+        end
+      end
+    end
+  end
+end
+
+Dry::Types::Builder.prepend(JsonModel::Types::Ref::Builder)

data/lib/json_model/types.rb

@@ -1,13 +1,51 @@
 # frozen_string_literal: true
 
-require_relative('types/all_of')
+require('resolv')
+require_relative('types/alias')
 require_relative('types/any_of')
-require_relative('types/array')
-require_relative('types/boolean')
-require_relative('types/const')
-require_relative('types/enum')
-require_relative('types/integer')
-require_relative('types/null')
-require_relative('types/number')
 require_relative('types/one_of')
-require_relative('types/string')
+require_relative('types/ref')
+
+module JsonModel
+  module Types
+    include(Dry.Types())
+
+    Date = Dry::Types['date'].meta(format: 'date')
+
+    DateTime = Dry::Types['date_time'].meta(format: 'date-time')
+
+    Email = String.constrained(format: URI::MailTo::EMAIL_REGEXP).meta(format: 'email')
+
+    Hostname = String.constrained(
+      format: /(?i)^(?:([a-z0-9-]+|\*)\.)?([a-z0-9-]{1,61})\.([a-z0-9]{2,7})$/,
+    ).meta(format: 'hostname')
+
+    IPv4 = String.constrained(
+      format: ::Resolv::IPv4::Regex,
+    ).meta(format: 'ipv4')
+
+    IPv6 = String.constrained(
+      format: ::Resolv::IPv6::Regex,
+    ).meta(format: 'ipv6')
+
+    Time = Dry::Types['time'].meta(format: 'time')
+
+    UUID = String.constrained(
+      format: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+    ).meta(format: 'uuid')
+
+    URI = String.constrained(
+      format: ::URI::DEFAULT_PARSER.make_regexp,
+    ).meta(format: 'uri')
+
+    UriReference = String.constrained(
+      format: %r{^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?},
+    ).meta(format: 'uri-reference')
+
+    Regex = String.constrained(
+      format: %r{\A(/?)(.+)\1([a-z]*)\z}i,
+    ).meta(format: 'regex')
+
+    UniqueArray = Array.constrained(unique: true)
+  end
+end

data/lib/json_model/version.rb

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

data/lib/json_model.rb

@@ -1,19 +1,15 @@
 # frozen_string_literal: true
 
-require('active_model')
 require('active_support/concern')
 require('active_support/core_ext/class/attribute')
 require('active_support/descendants_tracker')
+require('dry-struct')
+require('dry-validation')
 require('uri')
-require('json_model/composeable')
 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/predicates')
 require('json_model/schema')
-require('json_model/type_spec')
 require('json_model/types')
 require('json_model/version')
 

data/spec/config_spec.rb

@@ -33,20 +33,6 @@ RSpec.describe(JsonModel::Config) do
     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)