json_model_rb 0.1.19 → 0.1.22

data/spec/examples/file_system_spec.rb

@@ -6,62 +6,87 @@ RSpec.describe('File system schema') do
   before do
     stub_const(
       'DiskDevice',
-      Class.new do
+      Class.new(Dry::Struct) do
         include(JsonModel::Schema)
 
-        property(:type, type: T::Const['disk'])
-        property(:device, type: T::String[pattern: %r{\A/dev/[^/]+(/[^/]+)*\z}])
+        def self.name
+          'DiskDevice'
+        end
+
+        attribute(:type, JsonModel::Types::String.constrained(eql: 'disk'))
+        attribute(:device, JsonModel::Types::String.constrained(format: %r{\A/dev/[^/]+(/[^/]+)*\z}))
       end,
     )
 
     stub_const(
       'DiskUuid',
-      Class.new do
+      Class.new(Dry::Struct) do
         include(JsonModel::Schema)
 
-        property(:type, type: T::Enum['diskUUID', 'diskuuid'])
-        property(
+        def self.name
+          'DiskUuid'
+        end
+
+        attribute(:type, JsonModel::Types::String.enum('diskUUID', 'diskuuid'))
+        attribute(
           :label,
-          type: T::String[pattern: /\A[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\z/],
+          JsonModel::Types::String.constrained(
+            format: /\A[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\z/,
+          ),
         )
       end,
     )
 
     stub_const(
       'Nfs',
-      Class.new do
+      Class.new(Dry::Struct) do
         include(JsonModel::Schema)
 
-        property(:type, type: T::Const['nfs'])
-        property(:remote_path, type: T::String[pattern: %r{\A(/[^/]+)+\z}], as: :remotePath)
-        property(:server, type: T::String[format: :ipv4])
+        def self.name
+          'Nfs'
+        end
+
+        attribute(:type, JsonModel::Types::String.constrained(eql: 'nfs'))
+        attribute(:remote_path, JsonModel::Types::String.constrained(format: %r{\A(/[^/]+)+\z}).as(:remotePath))
+        attribute(:server, JsonModel::Types::IPv4)
       end,
     )
 
     stub_const(
       'Tmpfs',
-      Class.new do
+      Class.new(Dry::Struct) do
         include(JsonModel::Schema)
 
-        property(:type, type: T::Const['tmpfs'])
-        property(:size_in_mb, type: T::Integer[minimum: 16, maximum: 512], as: :sizeInMB)
+        def self.name
+          'Tmpfs'
+        end
+
+        attribute(:type, JsonModel::Types::String.constrained(eql: 'tmpfs'))
+        attribute(:size_in_mb, JsonModel::Types::Integer.constrained(gteq: 16, lteq: 512).as(:sizeInMB))
       end,
     )
 
     stub_const(
       'Fstab',
-      Class.new do
+      Class.new(Dry::Struct) do
         include(JsonModel::Schema)
 
         description('JSON Schema for an fstab entry')
-        property(
+        attribute(
           :storage,
-          type: T::OneOf[DiskDevice, DiskUuid, Nfs, Tmpfs, discriminator: :type],
-          ref_mode: JsonModel::RefMode::LOCAL,
+          JsonModel::Types.one_of(:type) do
+            on('disk', DiskDevice.local)
+            on('diskUUID', 'diskuuid', DiskUuid.local)
+            on('nfs', Nfs.local)
+            on('tmpfs', Tmpfs.local)
+          end,
         )
-        property(:fstype, type: T::Enum['ext3', 'ext4', 'btrfs'], optional: true)
-        property(:options, type: T::Array[String, min_items: 1, unique_items: true], optional: true)
-        property(:readonly, type: T::Boolean, optional: true)
+        attribute(:fstype, JsonModel::Types::String.enum('ext3', 'ext4', 'btrfs'))
+        attribute(
+          :options,
+          JsonModel::Types::Array.of(JsonModel::Types::String).constrained(min_size: 1, unique: true).optional,
+        )
+        attribute?(:readonly, JsonModel::Types::Bool.optional)
       end,
     )
   end
@@ -73,7 +98,7 @@ RSpec.describe('File system schema') do
           {
             description: 'JSON Schema for an fstab entry',
             type: 'object',
-            required: %i(storage),
+            required: %i(fstype storage),
             properties: {
               storage: {
                 oneOf: [
@@ -87,15 +112,23 @@ RSpec.describe('File system schema') do
                 enum: %w(ext3 ext4 btrfs),
               },
               options: {
-                type: 'array',
-                minItems: 1,
-                items: {
-                  type: 'string',
-                },
-                uniqueItems: true,
+                anyOf: [
+                  { type: 'null' },
+                  {
+                    type: 'array',
+                    minItems: 1,
+                    items: {
+                      type: 'string',
+                    },
+                    uniqueItems: true,
+                  },
+                ],
               },
               readonly: {
-                type: 'boolean',
+                anyOf: [
+                  { type: 'null' },
+                  { type: 'boolean' },
+                ],
               },
             },
             '$defs': {
@@ -103,6 +136,7 @@ RSpec.describe('File system schema') do
                 properties: {
                   type: {
                     const: 'disk',
+                    type: 'string',
                   },
                   device: {
                     type: 'string',
@@ -125,7 +159,10 @@ RSpec.describe('File system schema') do
               },
               Nfs: {
                 properties: {
-                  type: { const: 'nfs' },
+                  type: {
+                    const: 'nfs',
+                    type: 'string',
+                  },
                   remotePath: {
                     type: 'string',
                     pattern: '\\A(/[^/]+)+\\z',
@@ -140,7 +177,10 @@ RSpec.describe('File system schema') do
               },
               Tmpfs: {
                 properties: {
-                  type: { const: 'tmpfs' },
+                  type: {
+                    const: 'tmpfs',
+                    type: 'string',
+                  },
                   sizeInMB: { type: 'integer', minimum: 16, maximum: 512 },
                 },
                 required: %i(sizeInMB type),

data/spec/examples/user_spec.rb

@@ -4,38 +4,38 @@ require('spec_helper')
 
 RSpec.describe('User schema') do
   before do
-    address_class = Class.new do
+    address_class = Class.new(Dry::Struct) do
       include(JsonModel::Schema)
 
       def self.name
         'Address'
       end
 
-      property(:street, type: String)
-      property(:city, type: String)
-      property(:state, type: String, optional: true)
-      property(:postal_code, type: T::String[pattern: /\A\d{5}(-\d{4})?\z/], optional: true)
-      property(:country, type: String, default: 'USA')
+      attribute(:street, JsonModel::Types::String)
+      attribute(:city, JsonModel::Types::String)
+      attribute?(:state, JsonModel::Types::String.optional)
+      attribute?(:postal_code, JsonModel::Types::String.constrained(format: /\A\d{5}(-\d{4})?\z/).optional)
+      attribute(:country, JsonModel::Types::String.default('USA'))
     end
 
     stub_const('Address', address_class)
 
-    user_class = Class.new do
+    user_class = Class.new(Dry::Struct) do
       include(JsonModel::Schema)
 
       def self.name
         'User'
       end
 
-      property(:name, type: String)
-      property(:email, type: T::String[format: :email])
-      property(:age, type: T::Integer[minimum: 0, maximum: 120], optional: true)
-      property(:active, type: T::Boolean, default: true, optional: true)
-      property(:addresses, type: T::Array[Address], ref_mode: JsonModel::RefMode::LOCAL)
-      property(:tags, type: T::Array[String], optional: true)
-      property(:birthday, type: Date, optional: true)
-      property(:websites, type: T::Array[URI], optional: true)
-      property(:height, type: Float, optional: true)
+      attribute(:name, JsonModel::Types::String.constrained(min_size: 3))
+      attribute(:email, JsonModel::Types::Email)
+      attribute?(:age, JsonModel::Types::Integer.constrained(gteq: 0, lteq: 120).optional)
+      attribute(:active, JsonModel::Types::Bool.optional.default(true))
+      attribute(:addresses, JsonModel::Types::Array.of(Address.local))
+      attribute?(:tags, JsonModel::Types::Array.of(JsonModel::Types::String).optional)
+      attribute(:birthday, JsonModel::Types::Date.optional)
+      attribute?(:websites, JsonModel::Types::Array.of(JsonModel::Types::URI).optional)
+      attribute?(:height, JsonModel::Types::Float.optional)
     end
 
     stub_const('User', user_class)
@@ -48,18 +48,49 @@ RSpec.describe('User schema') do
           {
             type: 'object',
             properties: {
-              name: { type: 'string' },
+              name: { type: 'string', minLength: 3 },
               email: { type: 'string', format: 'email' },
-              age: { type: 'integer', minimum: 0, maximum: 120 },
-              active: { type: 'boolean', default: true },
+              age: {
+                anyOf: [
+                  { type: 'null' },
+                  { type: 'integer', minimum: 0, maximum: 120 },
+                ],
+              },
+              active: {
+                anyOf: [
+                  { type: 'null' },
+                  { type: 'boolean' },
+                ],
+                default: true,
+              },
               addresses: {
                 type: 'array',
                 items: { '$ref': '#/$defs/Address' },
               },
-              tags: { type: 'array', items: { type: 'string' } },
-              birthday: { type: 'string', format: 'date' },
-              websites: { type: 'array', items: { type: 'string', format: 'uri' } },
-              height: { type: 'number' },
+              tags: {
+                anyOf: [
+                  { type: 'null' },
+                  { type: 'array', items: { type: 'string' } },
+                ],
+              },
+              birthday: {
+                anyOf: [
+                  { type: 'null' },
+                  { type: 'string', format: 'date' },
+                ],
+              },
+              websites: {
+                anyOf: [
+                  { type: 'null' },
+                  { type: 'array', items: { type: 'string', format: 'uri' } },
+                ],
+              },
+              height: {
+                anyOf: [
+                  { type: 'null' },
+                  { type: 'number' },
+                ],
+              },
             },
             required: %i(addresses email name),
             '$defs': {
@@ -68,8 +99,18 @@ RSpec.describe('User schema') do
                 properties: {
                   city: { type: 'string' },
                   country: { type: 'string', default: 'USA' },
-                  postal_code: { type: 'string', pattern: '\A\d{5}(-\d{4})?\z' },
-                  state: { type: 'string' },
+                  postal_code: {
+                    anyOf: [
+                      { type: 'null' },
+                      { type: 'string', pattern: '\A\d{5}(-\d{4})?\z' },
+                    ],
+                  },
+                  state: {
+                    anyOf: [
+                      { type: 'null' },
+                      { type: 'string' },
+                    ],
+                  },
                   street: { type: 'string' },
                 },
                 required: %i(city country street),
@@ -85,7 +126,7 @@ RSpec.describe('User schema') do
       name: 'Foo',
       email: 'foo@example.com',
       addresses: [{ street: '123 Main St', city: 'Anytown' }],
-      birthday: '2000-01-01',
+      birthday: Date.new(2000, 1, 1),
     )
 
     expect(user.name).to(eq('Foo'))

data/spec/schema_meta_spec.rb

@@ -95,44 +95,4 @@ RSpec.describe(JsonModel::SchemaMeta) do
         .to(eq('This is a test title.'))
     end
   end
-
-  describe('.additional_properties') do
-    let(:klass) do
-      Class.new do
-        include(JsonModel::SchemaMeta)
-      end
-    end
-
-    it('is missing by default') do
-      expect(klass.meta_attributes)
-        .to(eq({}))
-    end
-
-    it('can be changed') do
-      klass.additional_properties(true)
-
-      expect(klass.meta_attributes)
-        .to(eq({ additionalProperties: true }))
-    end
-  end
-
-  describe('.additional_properties') do
-    let(:klass) do
-      Class.new do
-        include(JsonModel::SchemaMeta)
-      end
-    end
-
-    it('is missing by default') do
-      expect(klass.meta_attributes)
-        .to(eq({}))
-    end
-
-    it('can be changed') do
-      klass.unevaluated_properties(true)
-
-      expect(klass.meta_attributes)
-        .to(eq({ unevaluatedProperties: true }))
-    end
-  end
 end

data/spec/schema_spec.rb

@@ -5,10 +5,10 @@ require('spec_helper')
 RSpec.describe(JsonModel::Schema) do
   describe('.initialize') do
     let(:klass) do
-      Class.new do
+      Class.new(Dry::Struct) do
         include(JsonModel::Schema)
 
-        property(:foo, type: String, optional: true)
+        attribute?(:foo, JsonModel::Types::String.optional)
 
         def self.name
           'Foo'
@@ -28,49 +28,25 @@ RSpec.describe(JsonModel::Schema) do
     end
 
     it('raises an error for unknown attributes when additional properties are not allowed') do
+      klass.schema(klass.schema.strict)
+
       expect { klass.new(bar: 'baz') }
-        .to(raise_error(JsonModel::Errors::UnknownAttributeError))
+        .to(raise_error(Dry::Struct::Error))
     end
 
     it('does not raise an error for unknown attributes when additional properties are allowed') do
-      klass.additional_properties(true)
-
       klass.new(bar: 'baz')
     end
   end
 
-  describe('#valid?') do
-    let(:klass) do
-      Class.new do
-        include(JsonModel::Schema)
-
-        property(:foo, type: T::String[min_length: 3])
-      end
-    end
-
-    before do
-      JsonModel.configure { |config| config.validate_after_instantiation = false }
-    end
-
-    it('returns false for invalid values') do
-      expect(klass.new(foo: 'ba').valid?)
-        .to(be(false))
-    end
-
-    it('returns true for valid values') do
-      expect(klass.new(foo: 'bar').valid?)
-        .to(be(true))
-    end
-  end
-
   describe('.from_json') do
     before do
       stub_const(
         'Foo',
-        Class.new do
+        Class.new(Dry::Struct) do
           include(JsonModel::Schema)
 
-          property(:foo_bar, type: String, as: :fooBar)
+          attribute(:foo_bar, JsonModel::Types::String.as(:fooBar))
         end,
       )
 
@@ -93,7 +69,7 @@ RSpec.describe(JsonModel::Schema) do
 
   describe('.as_schema') do
     let(:klass) do
-      Class.new do
+      Class.new(Dry::Struct) do
         include(JsonModel::Schema)
       end
     end
@@ -119,11 +95,11 @@ RSpec.describe(JsonModel::Schema) do
 
     it('returns properties as schema') do
       klass.schema_id('https://example.com/schemas/example.json')
-      klass.property(:foo, type: String)
-      klass.property(:bar, type: Float, optional: true)
-      klass.property(:baz, type: T::Enum[1, 'a', nil])
-      klass.property(:bam, type: T::Array[T::AllOf[String, Float]])
-      klass.property(:bal, type: klass, ref_mode: JsonModel::RefMode::EXTERNAL, optional: true)
+      klass.attribute(:foo, JsonModel::Types::String)
+      klass.attribute(:bar, JsonModel::Types::Float.optional)
+      klass.attribute(:baz, JsonModel::Types::String.enum(1, 'a', nil))
+      klass.attribute(:bam, JsonModel::Types::Array.of(JsonModel::Types::String & JsonModel::Types::Float))
+      klass.attribute(:bal, klass.external.optional)
 
       expect(klass.as_schema)
         .to(
@@ -132,14 +108,24 @@ RSpec.describe(JsonModel::Schema) do
               '$id': 'https://example.com/schemas/example.json',
               type: 'object',
               properties: {
-                bal: { '$ref': 'https://example.com/schemas/example.json' },
+                bal: {
+                  anyOf: [
+                    { type: 'null' },
+                    { '$ref': 'https://example.com/schemas/example.json' },
+                  ],
+                },
                 bam: {
                   type: 'array',
                   items: {
                     allOf: [{ type: 'string' }, { type: 'number' }],
                   },
                 },
-                bar: { type: 'number' },
+                bar: {
+                  anyOf: [
+                    { type: 'null' },
+                    { type: 'number' },
+                  ],
+                },
                 baz: { enum: [1, 'a', nil] },
                 foo: { type: 'string' },
               },
@@ -150,40 +136,38 @@ RSpec.describe(JsonModel::Schema) do
     end
 
     it('collects local references in $defs') do
-      klass.property(
+      klass.attribute(
         :foo,
-        type: Class.new do
+        Class.new(Dry::Struct) do
           include(JsonModel::Schema)
 
-          property(:foo, type: String)
+          attribute(:foo, JsonModel::Types::String)
         end,
       )
-      klass.property(
+      klass.attribute(
         :bam,
-        type: Class.new do
+        Class.new(Dry::Struct) do
           include(JsonModel::Schema)
 
-          property(:bam, type: String)
           schema_id('https://example.com/schemas/bam.json')
-        end,
-        ref_mode: JsonModel::RefMode::EXTERNAL,
+          attribute(:bam, JsonModel::Types::String)
+        end.external,
       )
-      klass.property(
+      klass.attribute(
         :bar,
-        type: T::Array[
-          T::Array[
-            Class.new do
+        JsonModel::Types::Array.of(
+          JsonModel::Types::Array.of(
+            Class.new(Dry::Struct) do
               include(JsonModel::Schema)
 
-              property(:bar, type: String)
+              attribute(:bar, JsonModel::Types::String)
 
               def self.name
                 'Bar'
               end
-            end,
-          ],
-        ],
-        ref_mode: JsonModel::RefMode::LOCAL,
+            end.local,
+          ),
+        ),
       )
 
       expect(klass.as_schema)
@@ -223,20 +207,20 @@ RSpec.describe(JsonModel::Schema) do
       let(:child) do
         Class.new(klass) do
           schema_id('https://example.com/schemas/child.json')
-          property(:baz, type: String)
+          attribute(:baz, JsonModel::Types::String)
         end
       end
       let(:second_child) do
         Class.new(klass) do
           schema_id('https://example.com/schemas/second-child.json')
           title('SecondChild')
-          property(:bar, type: String)
+          attribute(:bar, JsonModel::Types::String)
         end
       end
 
       it('uses $ref for inherited schemas if they have a schema id') do
         klass.schema_id('https://example.com/schemas/example.json')
-        klass.property(:foo, type: String)
+        klass.attribute(:foo, JsonModel::Types::String)
 
         expect(child.as_schema)
           .to(