embedson 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: ef3de65a0b403021adc635d027d7ab9d8265c854
-  data.tar.gz: ab1e6d98c11f7b4dc3f03a33f906842384937368
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzBjMmI2NTk4ZWRhMGJkZTZlZWI3MTBjMzI4MzA1ZmU5ODg1MjA5NA==
+  data.tar.gz: !binary |-
+    MTAyNjhmYmY3OGM4ZTYxYTcxZjVhYzgzY2ZhNzYwNTM0ZGFhYjAxYQ==
 SHA512:
-  metadata.gz: b7f1ae0b831c508775371d3667b85b3a7ac9dfa738a9641df620f2789e1128dbf9ab1c5fb82d725ba5bcb40753d73b8eba039fdd4b8eef0ac79dc827ca5b6da6
-  data.tar.gz: c0895ec2264f217f1228f4fb6fe0a014e193f481224d3d44552a2552b595d76f4d7270e5965b7aaaa8599a189f23ad9736a97adfb6577db7708a436e1041525a
+  metadata.gz: !binary |-
+    NjEyYTE2ZmJiZGE2ODA5Njc3Y2U4ZDJiYmM4ODU5MGJjNDNlYzZjYzA4Mzhk
+    ZDJkYjllZWJhMWFlNjNiOGY5MzI5OTFiODlhMTNkYWQ2MjgzYTYyOGFhMTE3
+    YTBjY2FlMDBkNWExYzU0MzcyYjgyZGEwOWQzMzIxYjI2ZDQ5NGQ=
+  data.tar.gz: !binary |-
+    NjZhZDliMWE4YWMyZmIxNDk4YTE2ZDQ5NTVmYzZhMmFiMDZkOWE3MGQ4MWU1
+    YjFiOTFkNmVlZDc1Mzc3YTljODA5OWZjZGI5NTVkNDAyNjAxNzQ1M2NiYWVl
+    OThjODgzZjQ2YjY5YzM0MzM4NzlmMjVjYmJjNzg1ZTk2ZTgxMmI=

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 sufleR
+Copyright (c) 2014 Szymon Frącczak
 
 MIT License
 

data/README.md

@@ -184,3 +184,6 @@ This will **not** work!
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
 
+## License
+
+Copyright (c) 2014 Szymon Frącczak. See LICENSE.txt for further details.

data/TODO.md

@@ -0,0 +1,5 @@
+## ToDo list
+
+- support for inheritance of embedded class
+- support for dirty tracking
+- never enough tests

data/lib/embedson/exceptions.rb

@@ -1,14 +1,8 @@
 module Embedson
   class ClassTypeError < TypeError
-    attr_reader :wrong_name, :correct_name
 
     def initialize(wrong_name, correct_name)
-      @wrong_name, @correct_name = wrong_name, correct_name
-      super(build_message)
-    end
-
-    def build_message
-      "wrong argument type #{wrong_name} (expected #{correct_name})"
+      super("Wrong argument type #{wrong_name} (expected #{correct_name})")
     end
   end
 
@@ -18,4 +12,11 @@ module Embedson
       super("Cannot #{action} embedded #{klass_name} without a parent relation.")
     end
   end
+
+  class NoRelationDefinedError < StandardError
+
+    def initialize(klass_name, inverse_name)
+      super("Parent class #{klass_name} has no '#{inverse_name}' method defined or inverse_of option is not set properly.")
+    end
+  end
 end

data/lib/embedson/model/embedded_builder.rb

@@ -10,7 +10,7 @@ module Embedson
 
       def define
         methods_embedded.each do |meth|
-          klass.class_exec builder, &send(meth)
+          klass.class_exec builder, &self.method(meth)
         end
       end
 
@@ -20,81 +20,104 @@ module Embedson
         self.class.private_instance_methods(false).select{ |m| m.to_s.start_with?('embedded_') }
       end
 
-      def embedded_initializer
-        proc do |builder|
-          alias_method :orig_initialize, :initialize
+      def embedded_alter_initialize(builder)
+        klass.send :alias_method, "#{builder.field_name}_initialize".to_sym, :initialize
+        klass.send :private, "#{builder.field_name}_initialize"
+      end
 
-          define_method("initialize") do |*args|
-            attrs = args[0]
-            attrs ||= {}
-            public_send("#{builder.field_name}=", attrs.fetch(builder.field_name, nil))
-            orig_initialize(*args)
-          end
+      def embedded_initializer(builder)
+        klass.send :define_method, "initialize" do |*args|
+          attrs = args[0] || {}
+          val = attrs.delete(builder.field_name)
+
+          send("#{builder.field_name}_initialize", *args)
+          public_send("#{builder.field_name}=", val) if val.present?
         end
       end
 
-      def embedded_writer
-        proc do |builder|
-          define_method("#{builder.field_name}=") do |arg|
-            verify_arg_klass(arg)
+      def embedded_writer(builder)
+        klass.send :define_method, "#{builder.field_name}=" do |arg|
+          send("#{builder.field_name}_verify_arg_klass", arg)
 
-            instance_variable_set(builder.instance_var_name, arg)
-            parent = public_send(builder.field_name)
+          instance_variable_set(builder.instance_var_name, arg)
 
-            send_self_to_related(parent)
-          end
+          send("#{builder.field_name}_send_to_related", self)
         end
       end
 
-      def embedded_reader
-        proc do |builder|
-          define_method(builder.field_name) do
-            instance_variable_get(builder.instance_var_name)
-          end
+      def embedded_reader(builder)
+        klass.send :define_method, builder.field_name do
+          instance_variable_get(builder.instance_var_name)
         end
       end
 
-      def embedded_destroy
-        proc do |builder|
-          define_method('destroy') do
-            parent = public_send(builder.field_name)
-            return false unless parent.present?
-            parent.public_send(builder.inverse_set, nil)
-            parent.save!
-          end
+      def embedded_destroy(builder)
+        klass.send :define_method, 'destroy' do
+          call_in_transaction_for_all_embedding('save!', nil)
+        end
+      end
+
+      def embedded_save(builder)
+        klass.send :define_method, 'save' do
+          call_in_transaction_for_all_embedding('save', self)
         end
       end
 
-      def embedded_save
-        proc do |builder|
-          define_method('save') do
-            parent = public_send(builder.field_name)
-            return false unless parent.present?
-            parent.save
+      def embedded_save!(builder)
+        klass.send :define_method, 'save!' do
+          raise NoParentError.new('save!', self.class.name) unless any_embedding_present?
+          call_in_transaction_for_all_embedding('save!', self)
+        end
+      end
+
+      def embedded_changed(builder)
+        klass.send :define_method, 'embedson_model_changed!' do
+          raise NoParentError.new('register change', self.class.name) unless any_embedding_present?
+
+          self.class.embedson_relations.each do |relation|
+            send("#{relation}_send_to_related", self) if public_send(relation).present?
           end
+          true
         end
       end
 
-      def embedded_save!
-        proc do |builder|
-          define_method('save!') do
-            parent = public_send(builder.field_name)
-            raise NoParentError.new('save', self.class.name) unless parent.present?
-            parent.save!
+      def embedded_send_to_related(builder)
+        klass.send :define_method, "#{builder.field_name}_send_to_related" do |arg|
+          parent = public_send(builder.field_name)
+          return if parent.nil?
+          unless parent.respond_to?(builder.inverse_set)
+            raise NoRelationDefinedError.new(parent.class, builder.inverse_set)
           end
+          parent.public_send(builder.inverse_set, arg)
         end
+        klass.send :private, "#{builder.field_name}_send_to_related"
       end
 
-      def embedded_changed
-        proc do |builder|
-          define_method('embedson_model_changed!') do
-            parent = public_send(builder.field_name)
-            raise NoParentError.new('register change', self.class.name) unless parent.present?
-            parent.public_send(builder.inverse_set, self)
-            true
+      def embedded_call_in_transaction_for_all_embedding(builder)
+        return if klass.methods.include? :call_in_transaction_for_all_embedding
+        klass.send :define_method, :call_in_transaction_for_all_embedding do |method, object|
+          results = []
+          ActiveRecord::Base.transaction do
+            self.class.embedson_relations.each do |field_name|
+              next if public_send(field_name).nil?
+              send("#{field_name}_send_to_related", object)
+              save_res = public_send(field_name).send(method)
+              results << save_res
+              raise ActiveRecord::Rollback unless save_res
+            end
           end
+          !results.size.zero? && results.all?
         end
       end
+
+      def embedded_any_present?(builder)
+        return if klass.methods.include? :any_ebedding_present?
+        klass.send :define_method, :any_embedding_present? do
+          self.class.embedson_relations.any?{ |r| public_send(r).present? }
+        end
+
+        klass.send :private, :any_embedding_present?
+      end
     end
   end
 end

data/lib/embedson/model/embeds_builder.rb

@@ -10,58 +10,63 @@ module Embedson
 
       def define
         methods_embeds.each do |meth|
-          klass.class_exec builder, &send(meth)
+          klass.class_exec builder, &self.method(meth)
         end
       end
 
       private
 
       def methods_embeds
-        [:writer, :reader, :related_model, :build_related_model]
+        [:writer, :reader, :related_model, :build_related_model, :send_to_related]
       end
 
-      def writer
-        proc do |builder|
-          define_method("#{builder.field_name}=") do |arg|
-            verify_arg_klass(arg)
-            send_self_to_related(arg)
+      def writer(builder)
+        klass.send :define_method, "#{builder.field_name}=" do |arg|
+          send("#{builder.field_name}_verify_arg_klass", arg)
+          send("#{builder.field_name}_send_to_related", arg)
 
-            instance_variable_set(builder.instance_var_name, arg)
-            write_attribute(builder.column_name, arg.nil? ? arg : arg.to_h)
+          instance_variable_set(builder.instance_var_name, arg)
+          val = arg.nil? ? arg : arg.to_h.stringify_keys
+          unless val == read_attribute(builder.column_name)
+            write_attribute(builder.column_name, val)
           end
         end
       end
 
-      def reader
-        proc do |builder|
-          define_method(builder.field_name) do
-            return if read_attribute(builder.column_name).nil?
+      def reader(builder)
+        klass.send :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
+          send("#{builder.field_name}_build_related_model") if instance_variable_get(builder.instance_var_name).nil?
+          instance_variable_get(builder.instance_var_name)
         end
       end
 
-      def related_model
-        proc do |builder|
-          private
+      def related_model(builder)
+        klass.send :define_method, "#{builder.field_name}_related_model" do
+          builder.related_klass_name.constantize.new(read_attribute(builder.column_name))
+        end
+        klass.send :private, "#{builder.field_name}_related_model"
+      end
 
-          define_method('related_model') do
-            builder.related_klass_name.constantize.new(read_attribute(builder.column_name))
+      def build_related_model(builder)
+        klass.send :define_method, "#{builder.field_name}_build_related_model" do
+          related_model = send("#{builder.field_name}_related_model")
+          instance_variable_set(builder.instance_var_name, related_model)
+          if related_model.respond_to?(builder.inverse_set)
+            related_model.public_send(builder.inverse_set, self)
           end
         end
+        klass.send :private, "#{builder.field_name}_build_related_model"
       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)
+      def send_to_related(builder)
+        klass.send :define_method, "#{builder.field_name}_send_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
+        klass.send :private, "#{builder.field_name}_send_to_related"
       end
     end
   end

data/lib/embedson/model/method_builder.rb

@@ -26,7 +26,7 @@ module Embedson
       end
 
       def related_klass_name
-        @related_klass_name ||= (options.fetch(:class_name, nil) || field_name).to_s.classify
+        @related_klass_name ||= (options.fetch(:class_name, nil) || field_name).to_s.camelize
       end
 
       def instance_var_name
@@ -45,36 +45,21 @@ module Embedson
 
       def generate_common
         methods_for_both.each do |meth|
-          klass.class_exec self, &send(meth)
+          klass.class_exec self, &self.method(meth)
         end
       end
 
       def methods_for_both
-        [:send_self_to_related, :verify_arg_klass]
+        [: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
+      def verify_arg_klass(builder)
+        klass.send(:define_method, "#{field_name}_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
+        klass.send(:private, "#{field_name}_verify_arg_klass")
       end
     end
   end

data/lib/embedson/model.rb

@@ -1,13 +1,57 @@
 module Embedson
+  # Public: Defines embeds_one and embedded_in methods.
+  #
+  # Examples
+  #
+  #   class Emb
+  #     extend Embedson::Model
+  #   end
   module Model
 
+    # Public: Creates methods to manage embedded class.
+    #
+    # name - Name of of relation.
+    # options - The Hash options used to define custom column name, class name
+    #           and field name in embedded class (default: {}):
+    #           :class_name - Name of class which will be ebedded.
+    #           :column_name - Name of column where Hash representation will be stored.
+    #           :inverse_of - Name of field where related class will store current object.
+    #
+    # Examples
+    #
+    #   embeds_one :virt, class_name: Virt, column_name: :data, inverse_of: :parent
+    #
+    #   embeds_one :virt
+    #
+    # Returns nothing
     def embeds_one(name, options = {})
       MethodBuilder.new(self, name, options).embeds
     end
 
+    # Public: Creates methods to manage parent class.
+    #
+    # name - Name of relation where parent object will be stored.
+    # options - The hash options used to define custom class name and field name
+    #           in parent class (default: {}):
+    #           :class_name - Name of class where current object will be embedded.
+    #           :inverse_of - Name of field where parent class will keep current object.
+    #
+    # Examples
+    #
+    #   embedded_in :parent, class_name: Test, inverse_of: :virt
+    #
+    #   embedded_in :parent
+    #
+    # Returns nothing
     def embedded_in(name, options = {})
+      @embedson_relations ||= []
+      @embedson_relations << name
       MethodBuilder.new(self, name, options).embedded
     end
+
+    def self.extended(mod)
+      attr_reader :embedson_relations
+    end
   end
 end
 

data/lib/embedson/version.rb

@@ -1,3 +1,3 @@
 module Embedson
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

data/spec/embedson/exceptions_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Embedson::ClassTypeError do
+  let(:error) { Embedson::ClassTypeError.new('Wrong', 'Correct') }
+
+  it 'raises with correct message' do
+    expect(error.message).to eq "Wrong argument type Wrong (expected Correct)"
+  end
+end
+
+describe Embedson::NoParentError do
+  let(:error) { Embedson::NoParentError.new('assign', 'Correct') }
+
+  it 'raises with correct message' do
+    expect(error.message).to eq "Cannot assign embedded Correct without a parent relation."
+  end
+end
+
+describe Embedson::NoParentError do
+  let(:error) { Embedson::NoRelationDefinedError.new('Klass', 'embedded=') }
+
+  it 'raises with correct message' do
+    expect(error.message).to eq "Parent class Klass has no 'embedded=' method defined or inverse_of option is not set properly."
+  end
+end