nested_record 0.1.1 → 1.0.0.beta

data/lib/nested_record/type.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 class NestedRecord::Type < ActiveRecord::Type::Json
+  require 'nested_record/type/many'
+  require 'nested_record/type/one'
+
   def initialize(setup)
     @setup = setup
   end
@@ -22,43 +25,4 @@ class NestedRecord::Type < ActiveRecord::Type::Json
   def record_class
     @setup.record_class
   end
-
-  class HasMany < self
-    private
-
-    def collection_class
-      @setup.collection_class
-    end
-
-    def cast_value(data)
-      return unless data
-      collection = collection_class.new
-      data.each do |obj|
-        if obj.is_a? Hash
-          collection << record_class.instantiate(obj)
-        elsif obj.kind_of?(record_class)
-          collection << obj
-        else
-          raise "Cannot cast #{obj.inspect}"
-        end
-      end
-      collection
-    end
-  end
-
-  class HasOne < self
-    private
-
-    def cast_value(obj)
-      return unless obj
-
-      if obj.is_a? Hash
-        record_class.instantiate(obj)
-      elsif obj.kind_of?(record_class)
-        obj
-      else
-        raise "Cannot cast #{obj.inspect}"
-      end
-    end
-  end
 end

data/lib/nested_record/type/many.rb

@@ -0,0 +1,24 @@
+class NestedRecord::Type
+  class Many < self
+    private
+
+    def collection_class
+      @setup.collection_class
+    end
+
+    def cast_value(data)
+      return unless data
+      collection = collection_class.new
+      data.each do |obj|
+        if obj.is_a? Hash
+          collection << record_class.instantiate(obj)
+        elsif obj.kind_of?(record_class)
+          collection << obj
+        else
+          raise "Cannot cast #{obj.inspect}"
+        end
+      end
+      collection
+    end
+  end
+end

data/lib/nested_record/type/one.rb

@@ -0,0 +1,17 @@
+class NestedRecord::Type
+  class One < self
+    private
+
+    def cast_value(obj)
+      return unless obj
+
+      if obj.is_a? Hash
+        record_class.instantiate(obj)
+      elsif obj.kind_of?(record_class)
+        obj
+      else
+        raise "Cannot cast #{obj.inspect}"
+      end
+    end
+  end
+end

data/lib/nested_record/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NestedRecord
-  VERSION = '0.1.1'
+  VERSION = '1.0.0.beta'
 end

data/spec/nested_record/base_spec.rb

@@ -58,6 +58,20 @@ RSpec.describe NestedRecord::Base do
   end
 
   describe '.new' do
+    context 'with after_initialize callbacks' do
+      nested_model(:Foo) do
+        attribute :x, :integer
+        attribute :y, :integer
+        attribute :z, :integer
+
+        after_initialize { self.z = 1234 }
+      end
+
+      it 'calls them' do
+        expect(Foo.new(x: 1, y: 2)).to match an_object_having_attributes(x: 1, y: 2, z: 1234)
+      end
+    end
+
     context 'with inheritance' do
       nested_model(:Bar)
       nested_model(:Foo, :Bar)
@@ -80,21 +94,21 @@ RSpec.describe NestedRecord::Base do
         expect { Bar.new(type: 'Buzz') }.to raise_error(NestedRecord::InvalidTypeError)
       end
 
-      context 'with namespaced models and inherited_types full: true' do
+      context 'with namespaced models and subtypes full: true' do
         nested_model('A::Bar') do
-          inherited_types full: true
+          subtypes full: true
         end
         nested_model('A::Foo', 'A::Bar')
 
         it 'looks up for a subclass globally' do
-          expect(A::Bar.new(type: 'A::Foo')).to be_an_instance_of(A::Foo)
+         expect(A::Bar.new(type: 'A::Foo')).to be_an_instance_of(A::Foo)
           expect { A::Bar.new(type: 'Foo') }.to raise_error(NestedRecord::InvalidTypeError)
         end
       end
 
-      context 'with namespaced models and inherited_types full: false' do
+      context 'with namespaced models and subtypes full: false' do
         nested_model('A::Bar') do
-          inherited_types full: false
+          subtypes full: false
         end
         nested_model('A::Foo', 'A::Bar')
 
@@ -104,9 +118,9 @@ RSpec.describe NestedRecord::Base do
         end
       end
 
-      context 'with inherited_types :namespace option' do
+      context 'with subtypes :namespace option' do
         nested_model('A::Bar') do
-          inherited_types namespace: 'A::Bars'
+          subtypes namespace: 'A::Bars'
         end
         nested_model('A::Bars::Foo', 'A::Bar')
         nested_model('A::Foo', 'A::Bar')
@@ -124,9 +138,9 @@ RSpec.describe NestedRecord::Base do
         end
       end
 
-      context 'with inherited_types underscored: true' do
+      context 'with subtypes underscored: true' do
         nested_model('A::Bar') do
-          inherited_types underscored: true, full: false
+          subtypes underscored: true, full: false
         end
         nested_model('A::Bar::Foo', 'A::Bar')
 
@@ -138,6 +152,89 @@ RSpec.describe NestedRecord::Base do
           expect(A::Bar::Foo.new.type).to eq 'a/bar/foo'
         end
       end
+
+      context 'with local subtypes' do
+        nested_model('Baz') do
+          subtypes underscored: true
+          attribute :x, :integer
+
+          subtype :foo do
+            attribute :y, :integer
+          end
+
+          subtype :bar do
+            attribute :z, :integer
+          end
+        end
+
+        it 'looks up local subtypes' do
+          foo = Baz.new(type: 'foo', x: 1, y: 2)
+          bar = Baz.new(type: 'bar', x: 1, z: 3)
+          expect(foo).to be_an_instance_of Baz::LocalTypes::Foo
+          expect(bar).to be_an_instance_of Baz::LocalTypes::Bar
+          expect(foo).to match an_object_having_attributes(x: 1, y: 2)
+          expect(bar).to match an_object_having_attributes(x: 1, z: 3)
+        end
+
+        it 'sets a local type when called on subtypes' do
+          expect(Baz::LocalTypes::Foo.new).to match an_object_having_attributes(type: 'foo')
+          expect(Baz::LocalTypes::Bar.new).to match an_object_having_attributes(type: 'bar')
+        end
+      end
+
+      context 'with local subtypes in anonymous records' do
+        nested_model('Baz') do
+          has_one_nested :aux do
+            subtypes underscored: true
+            attribute :x, :integer
+
+            subtype :foo do
+              attribute :y, :integer
+            end
+
+            subtype :bar do
+              attribute :z, :integer
+            end
+          end
+        end
+
+        it 'looks up local subtypes' do
+          baz = Baz.new
+          foo = baz.build_aux(type: 'foo', x: 1, y: 2)
+          expect(foo).to match an_object_having_attributes(x: 1, y: 2)
+          bar = baz.build_aux(type: 'bar', x: 1, z: 3)
+          expect(bar).to match an_object_having_attributes(x: 1, z: 3)
+        end
+      end
+    end
+  end
+
+  describe '.instantiate' do
+    context 'with after_initialize callbacks' do
+      nested_model(:Foo) do
+        attribute :x, :integer
+        attribute :y, :integer
+        attribute :z, :integer
+
+        after_initialize { self.z = 1234 }
+      end
+
+      it 'calls them' do
+        expect(Foo.instantiate('x' => 1, 'y' => 2)).to match an_object_having_attributes(x: 1, y: 2, z: 1234)
+      end
+    end
+  end
+
+  describe '.subtype' do
+    nested_model('Baz') do
+      subtype :foo
+      subtype :bar
+    end
+
+    it 'defines subclasses in Subtypes namespace' do
+      expect(Baz::LocalTypes).to be_an_instance_of Module
+      expect(Baz::LocalTypes::Foo).to be < Baz
+      expect(Baz::LocalTypes::Bar).to be < Baz
     end
   end
 

data/spec/nested_record/type/many_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe NestedRecord::Type::Many do
+  nested_model(:Foo) do
+    attribute :id, :integer
+    attribute :x, :integer
+    attribute :s, :string
+
+    after_initialize { self.id = 1000 + x }
+  end
+  let(:collection_class) { Foo.collection_class }
+  let(:setup) { double(record_class: Foo, collection_class: collection_class) }
+  let(:type) { described_class.new(setup) }
+
+  describe '#deserialize' do
+    subject { type.deserialize('[{"x": 1, "s": "yeah"}, {"x": 2, "s": "hoorah"}]') }
+
+    it 'deserializes a json string to record object' do
+      is_expected.to be_an_instance_of(collection_class)
+      is_expected.to match [an_object_having_attributes(id: 1001, x: 1, s: 'yeah'), an_object_having_attributes(id: 1002, x: 2, s: 'hoorah')]
+    end
+  end
+end

data/spec/nested_record/type/one_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe NestedRecord::Type::One do
+  nested_model(:Foo) do
+    attribute :id, :integer
+    attribute :x, :integer
+    attribute :s, :string
+
+    after_initialize { self.id = 1000 }
+  end
+  let(:setup) { double(record_class: Foo) }
+  let(:type) { described_class.new(setup) }
+
+  describe '#deserialize' do
+    subject { type.deserialize('{"x": 123, "s": "yeah"}') }
+
+    it 'deserializes a json string to record object' do
+      is_expected.to be_an_instance_of(Foo)
+      is_expected.to match an_object_having_attributes(id: 1000, x: 123, s: 'yeah')
+    end
+  end
+end

data/spec/nested_record_spec.rb

@@ -37,19 +37,51 @@ RSpec.describe NestedRecord do
       end
     end
 
-    context 'with plural model name' do
-      nested_model(:Points) do
-        attribute :x, :string
-        attribute :y, :integer
-        attribute :z, :boolean
+    describe 'build_ method' do
+      it 'builds an object' do
+        foo = Foo.new
+        foo.build_bar(x: 'xx')
+        expect(foo.bar).to be_an_instance_of(Bar)
+        expect(foo.bar.x).to eq 'xx'
       end
 
-      active_model(:Foo) do
-        has_one_nested :points
+      it 'rewrites the existing object' do
+        foo = Foo.new(bar: Bar.new(x: 'x'))
+        foo.build_bar(x: 'xx')
+        expect(foo.bar).to be_an_instance_of(Bar)
+        expect(foo.bar.x).to eq 'xx'
       end
 
-      it 'properly locates the model class' do
-        expect(Foo.new.build_points).to be_an_instance_of(Points)
+      context 'with plural model name' do
+        nested_model(:Points) do
+          attribute :x, :string
+          attribute :y, :integer
+          attribute :z, :boolean
+        end
+
+        active_model(:Foo) do
+          has_one_nested :points
+        end
+
+        it 'properly locates the model class' do
+          expect(Foo.new.build_points).to be_an_instance_of(Points)
+        end
+      end
+    end
+
+    describe 'bang ! method' do
+      it 'initializes an object if it is missing' do
+        foo = Foo.new(bar: nil)
+        foo.bar!
+        expect(foo.bar).to be_an_instance_of(Bar)
+        expect(foo.bar.x).to be nil
+      end
+
+      it 'uses existing object' do
+        foo = Foo.new(bar: Bar.new(x: 'xx'))
+        foo.bar!
+        expect(foo.bar).to be_an_instance_of(Bar)
+        expect(foo.bar.x).to eq 'xx'
       end
     end
 
@@ -110,11 +142,41 @@ RSpec.describe NestedRecord do
         foo.bar_attributes = { x: 'xx', y: '123', z: '0' }
         expect(foo.bar).to match an_object_having_attributes(x: 'xx', y: 123, z: false)
       end
+
+      context 'with :upsert strategy' do
+        active_model(:Foo) do
+          has_one_nested :bar, attributes_writer: { strategy: :upsert }
+        end
+
+        it 'updates the existing data' do
+          foo = Foo.new(bar_attributes: { x: 'x', y: 1 })
+          expect(foo.bar).to match an_object_having_attributes(x: 'x', y: 1, z: nil)
+          foo.bar_attributes = { x: 'xx', z: '1' }
+          expect(foo.bar).to match an_object_having_attributes(x: 'xx', y: 1, z: true)
+        end
+      end
+    end
+
+    describe 'validations' do
+      nested_model(:Bar) do
+        attribute :x, :string
+        validates :x, presence: true
+      end
+
+      it 'validates the record and adds an error entry' do
+        foo = Foo.new(bar: Bar.new(x: 'x'))
+        expect(foo).to be_valid
+        expect(foo.errors).to be_empty
+        foo = Foo.new(bar: Bar.new(x: ''))
+        expect(foo).not_to be_valid
+        expect(foo.errors['bar.x']).to eq ["can't be blank"]
+      end
     end
   end
 
   describe 'has_many_nested' do
     nested_model(:Bar) do
+      def_primary_uuid :id
       attribute :x, :string
       attribute :y, :integer
       attribute :z, :boolean
@@ -128,15 +190,89 @@ RSpec.describe NestedRecord do
       expect(Foo.new).to respond_to :bars
     end
 
+    describe 'when used with custom :class_name' do
+      active_model(:Foo) do
+        has_many_nested :bars, class_name: 'Barr'
+      end
+      nested_model(:Barr) do
+        def_primary_uuid :id
+        attribute :a, :integer
+        attribute :b, :integer
+      end
+
+      it 'uses a custom class' do
+        foo = Foo.new(bars_attributes: [{ a: 1, b: 2 }])
+        expect(foo.bars.first).to_not be_an_instance_of(Bar)
+        expect(foo.bars).to match [an_object_having_attributes(a: 1, b: 2)]
+      end
+    end
+
+    describe 'when used with class_name: <unknown>' do
+      it 'raises an error' do
+        expect do
+          new_active_model(:Fooo) do
+            has_many_nested :bars, class_name: []
+          end
+        end.to raise_error(NestedRecord::ConfigurationError, 'Bad :class_name option []')
+      end
+    end
+
     describe 'when used with block' do
       active_model(:Foo) do
         has_many_nested :bars do
-          def filter_by_something; end
+          def_primary_uuid :id
+          attribute :a, :integer
+          attribute :b, :integer
+          collection_methods do
+            def filter_by_something; end
+          end
+        end
+      end
+
+      it 'defines an anonymous record class' do
+        foo = Foo.new(bars_attributes: [{ a: 1, b: 2 }])
+        expect(foo.bars.first).to_not be_an_instance_of(Bar)
+        expect(foo.bars).to match [an_object_having_attributes(a: 1, b: 2)]
+        expect(foo.bars).to respond_to(:filter_by_something)
+      end
+    end
+
+    describe 'when used with block and class_name: true' do
+      active_model(:Foo) do
+        has_many_nested :bars, class_name: true do
+          def_primary_uuid :id
+        end
+      end
+
+      it 'names a class' do
+        expect(Foo::Bar).to be < NestedRecord::Base
+        foo = Foo.new(bars_attributes: [{}])
+        expect(foo.bars.first).to be_an_instance_of(Foo::Bar)
+      end
+    end
+
+    describe 'when used with block and class_name: "String"' do
+      active_model(:Foo) do
+        has_many_nested :bars, class_name: 'Barr' do
+          def_primary_uuid :id
         end
       end
 
-      it 'adds extension method to the collection' do
-        expect(Foo.new.bars).to respond_to(:filter_by_something)
+      it 'names a class' do
+        expect(Foo::Barr).to be < NestedRecord::Base
+        foo = Foo.new(bars_attributes: [{}])
+        expect(foo.bars.first).to be_an_instance_of(Foo::Barr)
+      end
+    end
+
+    describe 'when used with block and class_name: <unknown>' do
+      it 'raises an error' do
+        expect do
+          new_active_model(:Fooo) do
+            has_many_nested :bars, class_name: [] do
+            end
+          end
+        end.to raise_error(NestedRecord::ConfigurationError, 'Bad :class_name option []')
       end
     end
 
@@ -208,6 +344,16 @@ RSpec.describe NestedRecord do
         end
       end
 
+      context 'when used with invalid :attributes_writer option' do
+        it 'raises an error' do
+          expect do
+            new_active_model(:Fooo) do
+              has_many_nested :bars, attributes_writer: 'foo'
+            end
+          end.to raise_error(NestedRecord::ConfigurationError, 'Bad :attributes_writer option "foo"')
+        end
+      end
+
       it 'allows initialize with a collection of attributes' do
         foo = Foo.new(bars_attributes: [{ x: 'xx' }, { x: 'yy' }])
         expect(foo.bars).to match [
@@ -246,7 +392,7 @@ RSpec.describe NestedRecord do
                           }
         end
         nested_model(:Bar) do
-          attribute :id, :integer
+          attribute :id, :integer, primary: true
           attr_accessor :_destroy
         end
 
@@ -264,6 +410,193 @@ RSpec.describe NestedRecord do
           ]
         end
       end
+
+      context 'with :unknown strategy' do
+        it 'raises an error' do
+          expect do
+            new_active_model(:Fooo) do
+              has_many_nested :bars, attributes_writer: :unknown do
+                attribute :val, :string
+              end
+            end
+          end.to raise_error(NestedRecord::ConfigurationError, 'Unknown strategy :unknown')
+        end
+      end
+
+      context 'with :rewrite strategy' do
+        active_model(:Foo) do
+          has_many_nested :bars, attributes_writer: :rewrite do
+            attribute :val, :string
+          end
+        end
+
+        it 'replaces the whole contents of the collection' do
+          foo = Foo.new(bars_attributes: [{ val: 'foo' }, { val: 'bar' }])
+          foo.bars_attributes = [{ val: 'ping' }, { val: 'pong' }]
+          expect(foo.bars).to match [an_object_having_attributes(val: 'ping'), an_object_having_attributes(val: 'pong')]
+        end
+      end
+
+      context 'with :upsert strategy when primary key specified on association level' do
+        active_model(:Foo) do
+          has_many_nested :bars, attributes_writer: { strategy: :upsert }, primary_key: :id do
+            attribute :id, :integer
+            attribute :val, :string
+          end
+        end
+
+        it 'upserts the data' do
+          foo = Foo.new(bars_attributes: [{ id: 1, val: 'x' }, { id: 2, val: 'y' }])
+          expect(foo.bars).to match [
+            an_object_having_attributes(id: 1, val: 'x'),
+            an_object_having_attributes(id: 2, val: 'y')
+          ]
+
+          foo.bars_attributes = [{ id: 3, val: 'z' }, { id: 2, val: 'yy' }]
+          expect(foo.bars).to match [
+            an_object_having_attributes(id: 1, val: 'x'),
+            an_object_having_attributes(id: 2, val: 'yy'),
+            an_object_having_attributes(id: 3, val: 'z')
+          ]
+        end
+      end
+
+      context 'with :upsert strategy when primary key specified on model level' do
+        active_model(:Foo) do
+          has_many_nested :bars, attributes_writer: { strategy: :upsert } do
+            primary_key :id
+            attribute :id, :integer
+            attribute :val, :string
+          end
+        end
+
+        it 'upserts the data' do
+          foo = Foo.new(bars_attributes: [{ id: 1, val: 'x' }, { id: 2, val: 'y' }])
+          expect(foo.bars).to match [
+            an_object_having_attributes(id: 1, val: 'x'),
+            an_object_having_attributes(id: 2, val: 'y')
+          ]
+
+          foo.bars_attributes = [{ id: 3, val: 'z' }, { id: 2, val: 'yy' }]
+          expect(foo.bars).to match [
+            an_object_having_attributes(id: 1, val: 'x'),
+            an_object_having_attributes(id: 2, val: 'yy'),
+            an_object_having_attributes(id: 3, val: 'z')
+          ]
+        end
+      end
+
+      context 'with :upsert strategy when primary key specified on model attribute level' do
+        active_model(:Foo) do
+          has_many_nested :bars, attributes_writer: { strategy: :upsert } do
+            attribute :id, :integer, primary: true
+            attribute :val, :string
+          end
+        end
+
+        it 'upserts the data' do
+          foo = Foo.new(bars_attributes: [{ id: 1, val: 'x' }, { id: 2, val: 'y' }])
+          expect(foo.bars).to match [
+            an_object_having_attributes(id: 1, val: 'x'),
+            an_object_having_attributes(id: 2, val: 'y')
+          ]
+
+          foo.bars_attributes = [{ id: 3, val: 'z' }, { id: 2, val: 'yy' }]
+          expect(foo.bars).to match [
+            an_object_having_attributes(id: 1, val: 'x'),
+            an_object_having_attributes(id: 2, val: 'yy'),
+            an_object_having_attributes(id: 3, val: 'z')
+          ]
+        end
+      end
+
+      context 'with :upsert strategy when primary key specified on model attribute level and subtyping is used' do
+        active_model(:Foo) do
+          has_many_nested :bars, attributes_writer: { strategy: :upsert } do
+            attribute :id, :integer, primary: true
+            attribute :value, :string
+            subtype :x
+            subtype :y
+          end
+        end
+
+        it 'upserts the data according to its type' do
+          foo = Foo.new(bars_attributes: [{ type: 'x', id: '1', value: 'x' }, { type: 'y', id: '2', value: 'y2' }])
+          expect(foo.bars).to match [
+            an_object_having_attributes(id: 1, value: 'x'),
+            an_object_having_attributes(id: 2, value: 'y2')
+          ]
+
+          foo.bars_attributes = [{ type: 'y', id: '3', value: 'y3' }, { type: 'x', id: '1', value: 'xx' }, { type: 'y', id: '2', value: 'yy' }]
+          expect(foo.bars).to match [
+            an_object_having_attributes(id: 1, value: 'xx'),
+            an_object_having_attributes(id: 2, value: 'yy'),
+            an_object_having_attributes(id: 3, value: 'y3')
+          ]
+        end
+      end
+
+      context 'with :upsert strategy when primary key is specific for each subtype' do
+        active_model(:Foo) do
+          has_many_nested :bars, attributes_writer: { strategy: :upsert } do
+            attribute :value, :string
+            subtype :x do
+              attribute :xid, :integer, primary: true
+            end
+            subtype :y do
+              attribute :yid, :integer, primary: true
+            end
+          end
+        end
+
+        it 'upserts the data according to its type' do
+          foo = Foo.new(bars_attributes: [{ type: 'x', xid: '1', value: 'x' }, { type: 'y', yid: '2', value: 'y2' }])
+          expect(foo.bars).to match [
+            an_object_having_attributes(xid: 1, value: 'x'),
+            an_object_having_attributes(yid: 2, value: 'y2')
+          ]
+
+          foo.bars_attributes = [{ type: 'x', xid: '2', value: 'x2' }, { type: 'y', yid: '1', value: 'y' }, { type: 'x', xid: '1', value: 'xx' }]
+          expect(foo.bars).to match [
+            an_object_having_attributes(xid: 1, value: 'xx'),
+            an_object_having_attributes(yid: 2, value: 'y2'),
+            an_object_having_attributes(xid: 2, value: 'x2'),
+            an_object_having_attributes(yid: 1, value: 'y')
+          ]
+        end
+      end
+
+      context 'with :upsert strategy when primary key is not specified at all' do
+        active_model(:Foo) do
+          has_many_nested :bars, attributes_writer: { strategy: :upsert } do
+            attribute :id, :integer
+            attribute :val, :string
+          end
+        end
+
+        it 'upserts the data' do
+          foo = Foo.new
+          expect { foo.bars_attributes = [{ id: 0 }] }
+            .to raise_error(NestedRecord::ConfigurationError, /You should specify a primary_key/)
+        end
+      end
+    end
+
+    describe 'validations' do
+      nested_model(:Bar) do
+        def_primary_uuid :id
+        attribute :x, :string
+        validates :x, presence: true
+      end
+
+      it 'validates the record and adds an error entry' do
+        foo = Foo.new(bars: [Bar.new(x: 'x')])
+        expect(foo).to be_valid
+        expect(foo.errors).to be_empty
+        foo = Foo.new(bars: [Bar.new(x: 'y'), Bar.new(x: '')])
+        expect(foo).not_to be_valid
+        expect(foo.errors['bars[1].x']).to eq ["can't be blank"]
+      end
     end
   end