embedson 0.0.2 → 1.0.1

data/lib/embedson/model/embeds_builder.rb

@@ -0,0 +1,68 @@
+module Embedson
+  module Model
+    class EmbedsBuilder
+      attr_reader :builder, :klass
+
+      def initialize(builder)
+        @builder = builder
+        @klass = builder.klass
+      end
+
+      def define
+        methods_embeds.each do |meth|
+          klass.class_exec builder, &send(meth)
+        end
+      end
+
+      private
+
+      def methods_embeds
+        [:writer, :reader, :related_model, :build_related_model]
+      end
+
+      def writer
+        proc do |builder|
+          define_method("#{builder.field_name}=") do |arg|
+            verify_arg_klass(arg)
+            send_self_to_related(arg)
+
+            instance_variable_set(builder.instance_var_name, arg)
+            write_attribute(builder.column_name, arg.nil? ? arg : arg.to_h)
+          end
+        end
+      end
+
+      def reader
+        proc do |builder|
+          define_method(builder.field_name) do
+            return if read_attribute(builder.column_name).nil?
+
+            build_related_model if instance_variable_get(builder.instance_var_name).nil?
+            instance_variable_get(builder.instance_var_name)
+          end
+        end
+      end
+
+      def related_model
+        proc do |builder|
+          private
+
+          define_method('related_model') do
+            builder.related_klass_name.constantize.new(read_attribute(builder.column_name))
+          end
+        end
+      end
+
+      def build_related_model
+        proc do |builder|
+          private
+
+          define_method('build_related_model') do
+            instance_variable_set(builder.instance_var_name, related_model)
+            related_model.public_send(builder.inverse_set, self) if related_model.respond_to?(builder.inverse_set)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/embedson/model/method_builder.rb

@@ -0,0 +1,81 @@
+module Embedson
+  module Model
+
+    class MethodBuilder
+
+      attr_reader :klass, :field_name, :options
+
+      def initialize(klass, name, options)
+        @klass = klass
+        @field_name = name
+        @options = options
+      end
+
+      def embeds
+        EmbedsBuilder.new(self).define
+        generate_common
+      end
+
+      def embedded
+        EmbeddedBuilder.new(self).define
+        generate_common
+      end
+
+      def column_name
+        @column_name ||= options.fetch(:column_name, nil) || field_name
+      end
+
+      def related_klass_name
+        @related_klass_name ||= (options.fetch(:class_name, nil) || field_name).to_s.classify
+      end
+
+      def instance_var_name
+        @instance_var_name ||= "@#{field_name}"
+      end
+
+      def inverse_get
+        @inverse_get ||= options.fetch(:inverse_of, nil) || klass.name.demodulize.tableize.singularize
+      end
+
+      def inverse_set
+        @inverse_set ||= "#{inverse_get}="
+      end
+
+      private
+
+      def generate_common
+        methods_for_both.each do |meth|
+          klass.class_exec self, &send(meth)
+        end
+      end
+
+      def methods_for_both
+        [:send_self_to_related, :verify_arg_klass]
+      end
+
+      def verify_arg_klass
+        proc do |builder|
+          private
+
+          define_method('verify_arg_klass') do |arg|
+            unless arg.nil? || arg.is_a?(builder.related_klass_name.constantize)
+              raise ClassTypeError.new(arg.class.name, builder.related_klass_name)
+            end
+          end
+        end
+      end
+
+      def send_self_to_related
+        proc do |builder|
+          private
+
+          define_method('send_self_to_related') do |arg|
+            if arg.respond_to?(builder.inverse_set) && arg.public_send(builder.inverse_get) != self
+              arg.public_send(builder.inverse_set, self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/embedson/version.rb

@@ -1,3 +1,3 @@
 module Embedson
-  VERSION = "0.0.2"
+  VERSION = "1.0.1"
 end

data/spec/embedson/model_spec.rb

@@ -7,61 +7,60 @@ describe Embedson::Model do
 
       with_model :Parent do
         table do |t|
-          t.json :embedded
+          t.json :embeddeda
         end
 
         model do
-          extend Embedson::Model
-
-          embeds_one :embedded
+          embeds_one :embeddeda
         end
       end
 
-      class Embedded < OpenStruct
+      class Embeddeda
 
         def to_h
           { defined: 'in', embedded: true }
         end
       end
 
-      let(:parent) { Parent.new() }
-      let(:embedded) { Embedded.new() }
+      let(:parent) { Parent.new }
+      let(:embedded) { Embeddeda.new }
 
       it 'adds "embeds_one" method' do
         expect(Parent).to respond_to(:embeds_one)
       end
 
-      it 'adds "embedded" method' do
-        expect(Parent.new()).to respond_to(:embedded)
+      it 'adds "embeddeda" method' do
+        expect(parent).to respond_to(:embeddeda)
       end
 
-      it 'adds "embedded=" method' do
-        expect(Parent.new()).to respond_to("embedded=")
+      it 'adds "embeddeda=" method' do
+        expect(parent).to respond_to("embeddeda=")
       end
 
-      describe 'defined .embedded= method' do
-        it 'assigns value of embedded class' do
+      describe 'defined .embeddeda= method' do
+        it 'assigns value of Embeddeda class' do
+
           expect {
-            parent.embedded = embedded
-          }.to change{ parent.embedded }.from(nil).to(embedded)
+            parent.embeddeda = embedded
+          }.to change{ parent.embeddeda }.from(nil).to(embedded)
         end
 
         context 'when assigning nil' do
-          let(:parent) { Parent.new(embedded: embedded) }
+          let(:parent) { Parent.new(embeddeda: embedded) }
 
           it 'removes assignmnent' do
             parent
             expect {
-              parent.embedded = nil
-            }.to change { parent.embedded }.from(embedded).to(nil)
+              parent.embeddeda = nil
+            }.to change { parent.embeddeda }.from(embedded).to(nil)
           end
         end
 
         context 'when assigning wrong class' do
-          it 'raises TypeError' do
+          it 'raises ClassTypeError' do
             expect{
-              parent.embedded = 'something'
-            }.to raise_error(TypeError)
+              parent.embeddeda = 'something'
+            }.to raise_error(Embedson::ClassTypeError)
           end
         end
 
@@ -72,41 +71,41 @@ describe Embedson::Model do
 
           it 'marks parent as changed' do
             expect {
-              parent.embedded = embedded
+              parent.embeddeda = embedded
             }.to change{ parent.changed? }.from(false).to(true)
           end
 
           context 'and saved after change' do
-            it 'saves Embedded class to json column' do
+            it 'saves Embeddeda class in column' do
               expect{
-                parent.embedded = embedded
+                parent.embeddeda = embedded
                 parent.save!
-              }.to change { parent.reload.read_attribute(:embedded) }.from(nil).to(embedded.to_h.stringify_keys)
+              }.to change { parent.reload.read_attribute(:embeddeda) }.from(nil).to(embedded.to_h.stringify_keys)
             end
           end
         end
       end
 
-      describe 'defined embedded method' do
+      describe 'defined .embedded method' do
         context 'when value column is null' do
           it 'returns nil' do
-            expect(parent.embedded).to be nil
+            expect(parent.embeddeda).to be nil
           end
         end
 
-        it 'returns embedded class' do
-          parent.embedded = embedded
-          expect(parent.embedded).to be_a Embedded
+        it 'returns Embeddeda class' do
+          parent.embeddeda = embedded
+          expect(parent.embeddeda).to be_a Embeddeda
         end
 
         context 'when there is defined value in column' do
           before do
-            parent.embedded = embedded
+            parent.embeddeda = embedded
             parent.save!
           end
 
-          it 'returns embedded class initialized with value from column' do
-            expect(parent.reload.embedded).to eq embedded
+          it 'returns Embeddeda class initialized with value from column' do
+            expect(parent.reload.embeddeda).to eq embedded
           end
         end
       end
@@ -120,13 +119,11 @@ describe Embedson::Model do
         end
 
         model do
-          extend Embedson::Model
-
-          embeds_one :embedded, column_name: :data
+          embeds_one :embeddedb, column_name: :data
         end
       end
 
-      class Embedded < OpenStruct
+      class Embeddedb < OpenStruct
 
         def to_h
           { defined: 'in', embedded: true }
@@ -134,23 +131,23 @@ describe Embedson::Model do
       end
 
       let(:parent) { Parent.new() }
-      let(:embedded) { Embedded.new() }
+      let(:embedded) { Embeddedb.new() }
 
       it 'adds "embeds_one" method' do
         expect(Parent).to respond_to(:embeds_one)
       end
 
       it 'adds "embedded" method' do
-        expect(Parent.new()).to respond_to(:embedded)
+        expect(parent).to respond_to(:embeddedb)
       end
 
       it 'adds "embedded=" method' do
-        expect(Parent.new()).to respond_to("embedded=")
+        expect(parent).to respond_to("embeddedb=")
       end
 
       it 'saves embedded class to data column' do
         expect {
-          parent.embedded = embedded
+          parent.embeddedb = embedded
           parent.save!
         }.to change{ parent.read_attribute(:data) }.from(nil).to(embedded.to_h.stringify_keys)
       end
@@ -160,17 +157,15 @@ describe Embedson::Model do
 
       with_model :Parent do
         table do |t|
-          t.json :embedded
+          t.json :embeddedc
         end
 
         model do
-          extend Embedson::Model
-
-          embeds_one :embedded, inverse_of: :parent_m
+          embeds_one :embeddedc, inverse_of: :parent_m
         end
       end
 
-      class Embedded < OpenStruct
+      class Embeddedc < OpenStruct
         extend Embedson::Model
 
         embedded_in :parent_m, class_name: 'Parent'
@@ -180,24 +175,24 @@ describe Embedson::Model do
         end
       end
 
-      let(:parent) { Parent.new() }
-      let(:embedded) { Embedded.new() }
+      let(:parent) { Parent.new }
+      let(:embedded) { Embeddedc.new }
 
       it 'adds "embeds_one" method' do
         expect(Parent).to respond_to(:embeds_one)
       end
 
       it 'adds "embedded" method' do
-        expect(Parent.new()).to respond_to(:embedded)
+        expect(parent).to respond_to(:embeddedc)
       end
 
       it 'adds "embedded=" method' do
-        expect(Parent.new()).to respond_to("embedded=")
+        expect(parent).to respond_to("embeddedc=")
       end
 
       it 'assigns self to parent_m in embedded class' do
-        parent.embedded = embedded
-        expect(parent.embedded.parent_m).to eq parent
+        parent.embeddedc = embedded
+        expect(parent.embeddedc.parent_m).to eq parent
       end
     end
 
@@ -209,13 +204,11 @@ describe Embedson::Model do
         end
 
         model do
-          extend Embedson::Model
-
-          embeds_one :emb, class_name: 'Embedded', column_name: :embedded
+          embeds_one :emb, class_name: 'Embeddedd', column_name: :embedded
         end
       end
 
-      class Embedded < OpenStruct
+      class Embeddedd < OpenStruct
         extend Embedson::Model
 
         embedded_in :parent
@@ -226,23 +219,391 @@ describe Embedson::Model do
       end
 
       let(:parent) { Parent.new(embedded: { some: 'thing' }) }
-      let(:embedded) { Embedded.new() }
+      let(:embedded) { Embeddedd.new() }
 
       it 'adds "embeds_one" method' do
         expect(Parent).to respond_to(:embeds_one)
       end
 
       it 'adds "emb" method' do
-        expect(Parent.new()).to respond_to(:emb)
+        expect(parent).to respond_to(:emb)
       end
 
       it 'adds "emb=" method' do
-        expect(Parent.new()).to respond_to("emb=")
+        expect(parent).to respond_to("emb=")
       end
 
-      it 'assigns self to parent_m in embedded class' do
+      it 'returns emb as Embedded' do
+        expect(parent.emb).to be_a Embeddedd
         expect(parent.emb.some).to eq 'thing'
       end
     end
   end
+
+  describe '#embedded_in' do
+    context 'when only relation name is specified' do
+
+      with_model :Parent do
+        table do |t|
+          t.json :embeddede
+        end
+
+        model do
+          embeds_one :embeddede
+        end
+      end
+
+      class Embeddede < OpenStruct
+        extend Embedson::Model
+
+        embedded_in :parent
+
+        def change=(arg)
+          @change = arg
+        end
+
+        def to_h
+          h = { defined: 'in', embedded: true }
+          h.merge!(change: @change) if @change.present?
+          h
+        end
+      end
+
+      let(:parent) { Parent.new() }
+      let(:embedded) { Embeddede.new() }
+
+      it 'adds "embeds_one" method' do
+        expect(Embeddede).to respond_to(:embedded_in)
+      end
+
+      it 'adds "parent" method' do
+        expect(embedded).to respond_to(:parent)
+      end
+
+      it 'adds "parent=" method' do
+        expect(embedded).to respond_to("parent=")
+      end
+
+      describe 'defined .parent= method' do
+        it 'assigns value of embeding class' do
+          expect {
+            embedded.parent = parent
+          }.to change{ embedded.parent }.from(nil).to(parent)
+        end
+
+        context 'when assigning nil' do
+          let(:embedded) { Embeddede.new(parent: parent) }
+
+          it 'removes assignmnent' do
+            parent
+            expect {
+              embedded.parent = nil
+            }.to change { embedded.parent }.from(parent).to(nil)
+          end
+        end
+
+        context 'when assigning wrong class' do
+          it 'raises ClassTypeError' do
+            expect{
+              embedded.parent = 'something'
+            }.to raise_error(Embedson::ClassTypeError)
+          end
+        end
+
+        context 'when parent is persisted' do
+          before do
+            parent.save!
+          end
+
+          it 'marks parent as changed' do
+            expect {
+              embedded.parent = parent
+            }.to change{ parent.changed? }.from(false).to(true)
+          end
+
+          context 'and saved after change' do
+            it 'saves Embedded class in column' do
+              expect{
+                embedded.parent = parent
+                parent.save!
+              }.to change { parent.reload.read_attribute(:embeddede) }.from(nil).to(embedded.to_h.stringify_keys)
+            end
+          end
+        end
+      end
+
+      describe 'defined .save method' do
+
+        context 'when there is parent' do
+          let(:embedded) { Embeddede.new(parent: parent) }
+
+          it 'calls .save on parent' do
+            expect(parent).to receive(:save)
+            embedded.save
+          end
+
+          it 'saves to_h result in parent column' do
+            parent.save!
+            expect {
+              embedded.save
+            }.to change { parent.reload.read_attribute(:embeddede) }.from(nil).to({ "defined" => "in", "embedded" => true })
+          end
+        end
+
+        context 'when there is no parent' do
+          let(:embedded) { Embeddede.new }
+
+          it 'returns false' do
+            expect(embedded.save).to eq(false)
+          end
+        end
+      end
+
+      describe 'defined .save! method' do
+
+        context 'when there is parent' do
+          let(:embedded) { Embeddede.new(parent: parent) }
+
+          it 'calls .save on parent' do
+            expect(parent).to receive(:save!)
+            embedded.save!
+          end
+
+          it 'saves to_h result in parent column' do
+            parent.save!
+            expect {
+              embedded.save!
+            }.to change { parent.reload.read_attribute(:embeddede) }.from(nil).to({ "defined" => "in", "embedded" => true })
+          end
+        end
+
+        context 'when there is no parent' do
+          it 'raises argument error' do
+            expect { embedded.save! }.to raise_error(Embedson::NoParentError)
+          end
+        end
+      end
+
+      describe 'defined .destroy method' do
+
+        context 'when there is parent' do
+          let(:embedded) { Embeddede.new(parent: parent) }
+
+          it 'calls .save! on parent' do
+            expect(parent).to receive(:save!)
+            embedded.destroy
+          end
+
+          it 'saves nil in parent column' do
+            embedded.save!
+            expect {
+              embedded.destroy
+            }.to change { parent.reload.read_attribute(:embeddede) }.from({ "defined" => "in", "embedded" => true }).to(nil)
+          end
+        end
+
+        context 'when there is no parent' do
+          let(:embedded) { Embeddede.new }
+
+          it 'returns false' do
+            expect(embedded.destroy).to eq(false)
+          end
+        end
+      end
+
+      describe 'defined .embedson_model_changed! method' do
+
+        context 'when there is parent' do
+          let(:embedded) { Embeddede.new(parent: parent) }
+
+          it 'returns true' do
+            expect(embedded.embedson_model_changed!).to eq(true)
+          end
+
+          it 'assigns new value to parent' do
+            embedded.change = 'registered'
+            expect {
+              embedded.embedson_model_changed!
+            }.to change { parent.read_attribute(:embeddede) }.from({ "defined" => "in", "embedded" => true }).to({ "defined" => "in", "embedded" => true, 'change' => 'registered' })
+          end
+        end
+
+        context 'when there is no parent' do
+          it 'raises argument error' do
+            expect { embedded.embedson_model_changed! }.to raise_error(Embedson::NoParentError)
+          end
+        end
+      end
+
+      describe 'defined .initialize method' do
+
+
+        class Embeddedf
+          extend Embedson::Model
+
+          attr_reader :one, :two
+
+          def initialize(attributes = {})
+            @one = attributes[:one]
+            @two = attributes[:two]
+          end
+
+          # when you put it before initialize
+          # Embeddedf.new(parent: parent)
+          # will not owkr
+          embedded_in :parent
+
+          def to_h
+            { one: one, two: two }
+          end
+        end
+
+        let(:embedded) { Embeddedf.new(one: '1', two: '2', parent: parent)}
+
+        it 'allows to initialize with parent' do
+          expect(embedded.parent).to eq parent
+        end
+
+        it 'keeps initialize working' do
+          expect(embedded.to_h).to eq({ one: '1', two: '2' })
+        end
+      end
+    end
+
+    context 'when options include inverse_of' do
+
+      with_model :Parent do
+        table do |t|
+          t.json :emb
+        end
+
+        model do
+          embeds_one :emb, class_name: Embeddedg
+        end
+      end
+
+      class Embeddedg < OpenStruct
+        extend Embedson::Model
+
+        embedded_in :parent, inverse_of: :emb
+
+        def to_h
+          { defined: 'in', embedded: true }
+        end
+      end
+
+      let(:parent) { Parent.new() }
+      let(:embedded) { Embeddedg.new() }
+
+      it 'adds "embeds_one" method' do
+        expect(Embeddedg).to respond_to(:embedded_in)
+      end
+
+      it 'adds "parent" method' do
+        expect(embedded).to respond_to(:parent)
+      end
+
+      it 'adds "parent=" method' do
+        expect(embedded).to respond_to("parent=")
+      end
+
+      it 'assigns self to inverse_of value in parent class' do
+        embedded.parent = parent
+        expect(embedded.parent.emb).to eq embedded
+      end
+    end
+
+    context 'when options include class_name' do
+
+      with_model :Parented do
+        table do |t|
+          t.json :embeddedh
+        end
+
+        model do
+          embeds_one :embeddedh
+        end
+      end
+
+      class Embeddedh < OpenStruct
+        extend Embedson::Model
+
+        embedded_in :parent, class_name: 'Parented'
+
+        def to_h
+          { defined: 'in', embedded: true }
+        end
+      end
+
+      let(:parent) { Parented.new }
+      let(:embedded) { Embeddedh.new }
+
+      it 'adds "embeds_one" method' do
+        expect(Embeddedh).to respond_to(:embedded_in)
+      end
+
+      it 'adds "parent" method' do
+        expect(embedded).to respond_to(:parent)
+      end
+
+      it 'adds "parent=" method' do
+        expect(embedded).to respond_to("parent=")
+      end
+
+      describe 'defined .parent method' do
+        let(:embedded) { Embeddedh.new(parent: parent) }
+
+        it 'returns object of Parented class' do
+          expect(embedded.parent).to be_a(Parented)
+        end
+      end
+    end
+
+    context 'when parent model does not have defined embeds_one' do
+
+      with_model :Parent do
+        table do |t|
+          t.json :embeddedi
+        end
+      end
+
+      class Embeddedi < OpenStruct
+        extend Embedson::Model
+
+        embedded_in :parent
+
+        def to_h
+          { defined: 'in', embedded: true }
+        end
+      end
+
+      let(:parent) { Parent.new() }
+      let(:embedded) { Embeddedi.new() }
+
+      it 'adds "embeds_one" method' do
+        expect(Embeddedi).to respond_to(:embedded_in)
+      end
+
+      it 'adds "parent" method' do
+        expect(embedded).to respond_to(:parent)
+      end
+
+      it 'adds "parent=" method' do
+        expect(embedded).to respond_to("parent=")
+      end
+
+      describe 'defined .save method' do
+        let(:embedded) { Embeddedi.new(parent: parent) }
+
+        context 'when there is no to_json method' do
+          it 'raises TypeError' do
+            parent.save!
+            expect {
+              embedded.save!
+            }.to raise_error(TypeError)
+          end
+        end
+      end
+    end
+  end
 end