json_model_rb 0.1.20 → 0.1.23

data/lib/json_model/types/enum.rb

@@ -1,23 +0,0 @@
-# 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
-      JsonModel::TypeSpec::Enum.new(*@values)
-    end
-
-    class << self
-      # @param [Array] args
-      # @return [Enum]
-      def [](*args)
-        Enum.new(*args)
-      end
-    end
-  end
-end

data/lib/json_model/types/integer.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module T
-  class Integer
-    # @param [Hash] options
-    def initialize(**options)
-      @options = options
-    end
-
-    # @return [JsonModel::TypeSpec::Composition::Primitive::Integer]
-    def to_type_spec
-      JsonModel::TypeSpec::Primitive::Integer.new(**@options)
-    end
-
-    class << self
-      # @param [Hash] options
-      # @return [T::Integer]
-      def [](**options)
-        Integer.new(**options)
-      end
-    end
-  end
-end

data/lib/json_model/types/null.rb

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

data/lib/json_model/types/number.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module T
-  class Number
-    # @param [Hash] options
-    def initialize(**options)
-      @options = options
-    end
-
-    # @return [JsonModel::TypeSpec::Composition::Primitive::Number]
-    def to_type_spec
-      JsonModel::TypeSpec::Primitive::Number.new(**@options)
-    end
-
-    class << self
-      # @param [Hash] options
-      # @return [Number]
-      def [](**options)
-        Number.new(**options)
-      end
-    end
-  end
-end

data/lib/json_model/types/string.rb

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

data/spec/properties_spec.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::Properties) do
-  describe('.property') do
-    let(:klass) do
-      Class.new do
-        include(JsonModel::Properties)
-      end
-    end
-
-    it('has no default properties') do
-      expect(klass.properties)
-        .to(eq({}))
-    end
-
-    it('adds a property by name') do
-      klass.property(:foo, type: String)
-
-      expect(klass.properties.keys)
-        .to(eq(%i(foo)))
-      expect(klass.properties[:foo])
-        .to(be_a(JsonModel::Property))
-    end
-  end
-
-  describe('getter and setter') do
-    let(:klass) do
-      Class.new do
-        include(JsonModel::Properties)
-
-        property(:foo, type: String)
-      end
-    end
-
-    it('responds to the getter') do
-      expect(klass.new)
-        .to(respond_to(:foo))
-    end
-
-    it('responds to the setter') do
-      expect(klass.new)
-        .to(respond_to(:foo=))
-    end
-
-    it('allows updating the property') do
-      instance = klass.new
-
-      expect(instance.foo)
-        .to(be_nil)
-
-      instance.foo = 'bar'
-
-      expect(instance.foo)
-        .to(eq('bar'))
-    end
-
-    context('with a default value') do
-      before { klass.property(:foo, type: String, default: 'bar') }
-
-      it('returns the default value') do
-        expect(klass.new.foo)
-          .to(eq('bar'))
-      end
-
-      it('returns the updated value') do
-        instance = klass.new
-        instance.foo = 'foo'
-
-        expect(instance.foo)
-          .to(eq('foo'))
-      end
-    end
-  end
-end

data/spec/property_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::Property) do
-  describe('.register_validations') do
-    let(:klass) do
-      Class.new do
-        include(ActiveModel::Validations)
-
-        attr_accessor(:foo)
-      end
-    end
-
-    context('for an optional property') do
-      before do
-        described_class
-          .new(:foo, type: JsonModel::TypeSpec::Primitive::String.new, optional: true)
-          .register_validations(klass)
-      end
-
-      it('does not fail the validation for missing values') do
-        instance = klass.new
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-
-      it('does not fail the validation for present values') do
-        instance = klass.new.tap { |obj| obj.foo = 'bar' }
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-
-    context('for a non-optional property') do
-      before do
-        described_class
-          .new(:foo, type: JsonModel::TypeSpec::Primitive::String.new)
-          .register_validations(klass)
-      end
-
-      it('fails the validation for missing values') do
-        instance = klass.new
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(blank)))
-      end
-
-      it('does not fail the validation for present values') do
-        instance = klass.new.tap { |obj| obj.foo = 'bar' }
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-  end
-
-  describe('#as_schema') do
-    it('renders the property as a schema') do
-      expect(described_class.new(:foo, type: JsonModel::TypeSpec::Primitive::String.new).as_schema)
-        .to(eq({ foo: { type: 'string' } }))
-    end
-
-    it('respects the "as" option') do
-      expect(described_class.new(:foo, type: JsonModel::TypeSpec::Primitive::String.new, as: :bar).as_schema)
-        .to(eq({ bar: { type: 'string' } }))
-    end
-
-    it('falls back to the configured naming strategy') do
-      JsonModel.configure { |config| config.property_naming_strategy = :camel_case }
-
-      expect(described_class.new(:foo_bar, type: JsonModel::TypeSpec::Primitive::String.new).as_schema)
-        .to(eq({ fooBar: { type: 'string' } }))
-    end
-  end
-end

data/spec/type_spec/array_spec.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Array) do
-  describe('#as_schema') do
-    it('returns an array schema of primitive types') do
-      expect(
-        described_class.new(JsonModel::TypeSpec::Primitive::String.new).as_schema,
-      )
-        .to(
-          eq(
-            {
-              type: 'array',
-              items: { type: 'string' },
-            },
-          ),
-        )
-    end
-
-    it('returns an array schema of nested array types') do
-      expect(
-        described_class.new(described_class.new(JsonModel::TypeSpec::Primitive::String.new)).as_schema,
-      )
-        .to(
-          eq(
-            {
-              type: 'array',
-              items: { type: 'array', items: { type: 'string' } },
-            },
-          ),
-        )
-    end
-
-    it('includes the minItems attribute') do
-      expect(
-        described_class.new(JsonModel::TypeSpec::Primitive::String.new, min_items: 10).as_schema,
-      )
-        .to(
-          eq(
-            {
-              type: 'array',
-              items: { type: 'string' },
-              minItems: 10,
-            },
-          ),
-        )
-    end
-
-    it('includes the maxItems attribute') do
-      expect(
-        described_class.new(JsonModel::TypeSpec::Primitive::String.new, max_items: 10).as_schema,
-      )
-        .to(
-          eq(
-            {
-              type: 'array',
-              items: { type: 'string' },
-              maxItems: 10,
-            },
-          ),
-        )
-    end
-
-    it('uses external references') do
-      expect(
-        described_class
-          .new(
-            Class.new do
-              include(JsonModel::Schema)
-
-              property(:foo, type: String)
-              schema_id('https://example.com/schemas/foo.json')
-            end,
-          )
-          .as_schema(ref_mode: JsonModel::RefMode::EXTERNAL),
-      )
-        .to(
-          eq(
-            {
-              type: 'array',
-              items: { '$ref': 'https://example.com/schemas/foo.json' },
-            },
-          ),
-        )
-    end
-
-    it('uses local references') do
-      expect(
-        described_class
-          .new(
-            Class.new do
-              include(JsonModel::Schema)
-
-              property(:foo, type: String)
-
-              def self.name
-                'Foo'
-              end
-            end,
-          )
-          .as_schema(ref_mode: JsonModel::RefMode::LOCAL),
-      )
-        .to(
-          eq(
-            {
-              type: 'array',
-              items: { '$ref': '#/$defs/Foo' },
-            },
-          ),
-        )
-    end
-  end
-
-  describe('.register_validations') do
-    let(:klass) do
-      Class.new do
-        include(ActiveModel::Validations)
-
-        attr_accessor(:foo)
-
-        def initialize(foo:)
-          @foo = foo
-        end
-      end
-    end
-
-    context('for min items') do
-      before do
-        described_class
-          .new(JsonModel::TypeSpec::Primitive::String.new, min_items: 5)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for invalid values') do
-        instance = klass.new(foo: ['a'] * 4)
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(too_short)))
-      end
-
-      it('succeeds the validation for valid values') do
-        instance = klass.new(foo: ['a'] * 5)
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-
-    context('for max items') do
-      before do
-        described_class
-          .new(JsonModel::TypeSpec::Primitive::String.new, max_items: 5)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for invalid values') do
-        instance = klass.new(foo: ['a'] * 6)
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(too_long)))
-      end
-
-      it('succeeds the validation for valid values') do
-        instance = klass.new(foo: ['a'] * 5)
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-
-    context('for unique items') do
-      before do
-        described_class
-          .new(JsonModel::TypeSpec::Primitive::String.new, unique_items: true)
-          .register_validations(:foo, klass)
-      end
-
-      it('fails the validation for invalid values') do
-        instance = klass.new(foo: %w(a b a))
-
-        expect(instance.valid?)
-          .to(be(false))
-        expect(instance.errors.map(&:type))
-          .to(eq(%i(uniqueness)))
-      end
-
-      it('succeeds the validation for valid values') do
-        instance = klass.new(foo: %w(a b c))
-
-        expect(instance.valid?)
-          .to(be(true))
-        expect(instance.errors)
-          .to(be_empty)
-      end
-    end
-  end
-end

data/spec/type_spec/castable_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Castable) do
-  describe('#as_schema') do
-    it('returns a string schema') do
-      expect(described_class.new(format: 'date') { |v| v }.as_schema)
-        .to(eq({ type: 'string', format: 'date' }))
-    end
-  end
-
-  describe('#cast') do
-    it('casts a string') do
-      expect(described_class.new(format: 'date') { |v| Date.parse(v) }.cast('2020-01-01'))
-        .to(eq(Date.new(2020, 1, 1)))
-    end
-  end
-end

data/spec/type_spec/composition/all_of_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Composition::AllOf) do
-  describe('#as_schema') do
-    it('returns an all of schema') do
-      expect(
-        described_class.new(JsonModel::TypeSpec::Primitive::String.new).as_schema,
-      )
-        .to(
-          eq(
-            {
-              allOf: [{ type: 'string' }],
-            },
-          ),
-        )
-    end
-  end
-
-  describe('#cast') do
-    let(:foo) do
-      Class.new do
-        include(JsonModel::Schema)
-
-        additional_properties(true)
-        property(:foo, type: String)
-      end
-    end
-
-    let(:bar) do
-      Class.new do
-        include(JsonModel::Schema)
-
-        additional_properties(true)
-        property(:bar, type: String)
-      end
-    end
-
-    subject { described_class.new(JsonModel::TypeSpec::Object.new(foo), JsonModel::TypeSpec::Object.new(bar)) }
-
-    it('raises if one of the types fails') do
-      expect { subject.cast({ foo: 'foo' }) }
-        .to(raise_error(JsonModel::Errors::TypeError))
-    end
-
-    it('returns the value if all types pass') do
-      foo_instance, bar_instance = subject.cast({ foo: 'foo', bar: 'bar' })
-
-      expect(foo_instance).to(be_instance_of(foo))
-      expect(foo_instance.foo).to(eq('foo'))
-
-      expect(bar_instance).to(be_instance_of(bar))
-      expect(bar_instance.bar).to(eq('bar'))
-    end
-  end
-end

data/spec/type_spec/composition/any_of_spec.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Composition::AnyOf) do
-  describe('#as_schema') do
-    it('returns an any of schema') do
-      expect(
-        described_class.new(JsonModel::TypeSpec::Primitive::String.new).as_schema,
-      )
-        .to(
-          eq(
-            {
-              anyOf: [{ type: 'string' }],
-            },
-          ),
-        )
-    end
-  end
-
-  describe('#cast') do
-    let(:foo) do
-      Class.new do
-        include(JsonModel::Schema)
-
-        additional_properties(true)
-        property(:foo, type: String)
-      end
-    end
-
-    let(:bar) do
-      Class.new do
-        include(JsonModel::Schema)
-
-        additional_properties(true)
-        property(:bar, type: String)
-      end
-    end
-
-    subject { described_class.new(JsonModel::TypeSpec::Object.new(foo), JsonModel::TypeSpec::Object.new(bar)) }
-
-    it('raises if all of the types fail') do
-      expect { subject.cast({ bam: 'bam' }) }
-        .to(raise_error(JsonModel::Errors::TypeError))
-    end
-
-    it('returns the value if any type passes') do
-      foo_instance = subject.cast({ foo: 'foo' })
-
-      expect(foo_instance).to(be_instance_of(foo))
-      expect(foo_instance.foo).to(eq('foo'))
-    end
-  end
-end

data/spec/type_spec/composition/one_of_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe(JsonModel::TypeSpec::Composition::OneOf) do
-  describe('#as_schema') do
-    it('returns a one of schema') do
-      expect(
-        described_class.new(JsonModel::TypeSpec::Primitive::String.new).as_schema,
-      )
-        .to(
-          eq(
-            {
-              oneOf: [{ type: 'string' }],
-            },
-          ),
-        )
-    end
-  end
-
-  describe('#cast') do
-    let(:foo) do
-      Class.new do
-        include(JsonModel::Schema)
-
-        additional_properties(true)
-        property(:foo, type: String)
-      end
-    end
-
-    let(:bar) do
-      Class.new do
-        include(JsonModel::Schema)
-
-        additional_properties(true)
-        property(:bar, type: String)
-      end
-    end
-
-    subject { described_class.new(JsonModel::TypeSpec::Object.new(foo), JsonModel::TypeSpec::Object.new(bar)) }
-
-    it('raises if all of the types fail') do
-      expect { subject.cast({ bam: 'bam' }) }
-        .to(raise_error(JsonModel::Errors::TypeError))
-    end
-
-    it('raises if more than one type passes') do
-      expect { subject.cast({ foo: 'foo', bar: 'bar' }) }
-        .to(raise_error(JsonModel::Errors::TypeError))
-    end
-
-    it('returns the value if one type passes') do
-      foo_instance = subject.cast({ foo: 'foo' })
-
-      expect(foo_instance).to(be_instance_of(foo))
-      expect(foo_instance.foo).to(eq('foo'))
-    end
-  end
-end