embedson 0.0.2 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b52da8a4596e89eaa71d2a1f109988c9157cc51
-  data.tar.gz: adf12afbc8c12ca1c1b751def0865010217fa421
+  metadata.gz: 1ae243da2a4284cf3d516517dcd888d43f8162ff
+  data.tar.gz: 288c5328e6abeac9b9189868b675e48d2a44c2e8
 SHA512:
-  metadata.gz: 9463f20a91ef4449246cda718aa4e1a2671d1b7fe6a37d2f92836392e6f76b3caa84b0042482b5e400c653caa7deb6969c3335b3016b17f7e5339946283a5a1b
-  data.tar.gz: e0346bfea5cd34fc28bd695b96ab5160421a65f3c42cf7e8aac19fd0fcdf42e81fe8fb78aeb68cdd4333ae28990b60dc1de2d3c551ae9d68f737cccfe3a39349
+  metadata.gz: 991fbdc6bda1324574b4a8299cee3ebaa82f5f28d07bc1730d490d1bbd442e42b8dca396a92bc6a20927f92b8bf613ddfc03b6687935c7e675921b58e756c083
+  data.tar.gz: b42bb795094c2ae21434b800212212edc0364311a559da8b561d833dbd42000451982ac102458a45297d17e3ed55c654daac2c9eb8c4776ad1e71fea0ee05223

data/.gitignore

@@ -19,4 +19,6 @@ tmp
 *.so
 *.o
 *.a
+*.swp
+*.swo
 mkmf.log

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+  - "2.1.3"
+
+addons:
+  postgresql: "9.3"
+
+env:
+  - BUILDER=travis
+before_script:
+  - psql -c 'create database travis_ci_test;' -U postgres

data/README.md

@@ -1,15 +1,20 @@
+[![Gem Version](https://badge.fury.io/rb/embedson.svg)](http://badge.fury.io/rb/embedson)
+[![Dependency Status](https://gemnasium.com/sufleR/embedson.svg)](https://gemnasium.com/sufleR/embedson)
+[![Code Climate](https://codeclimate.com/github/sufleR/embedson/badges/gpa.svg)](https://codeclimate.com/github/sufleR/embedson)
+[![Test Coverage](https://codeclimate.com/github/sufleR/embedson/badges/coverage.svg)](https://codeclimate.com/github/sufleR/embedson)
+[![Build Status](https://travis-ci.org/sufleR/embedson.svg?branch=master)](https://travis-ci.org/sufleR/embedson)
+
 # Embedson
 
-Adds functionality of `embedded_one` and `embedded_in`. 
+Adds functionality of `embeds_one` to ActiveRecord.
 
-Embeded class is saved in json column.
+Adds functionality of `embedded_in` to any class:
 
-Embedded class have to provide `to_h` method which should return data to store in database.
+- with defined `to_h` method which should return `Hash` 
+- initialized with Hash.
 
-####TODO
+Result of `to_h` is saved json/hstore column.
 
-1. More tests
-2. Code refactoring to clean up `embedded_in` and `embeds_one` from define methods
 
 ## Installation
 
@@ -31,45 +36,142 @@ Example with [Virtus](https://github.com/solnic/virtus):
 
 ```RUBY
 	
-	#create_tests.rb - migration	
+	#create_tests.rb - migration
 	class CreateTests < ActiveRecord::Migration
 	  def change
 	    create_table :tests do |t|
-		  t.json :data
-		end
+	      t.json :data
+	    end
 	  end
 	end
 	
 	class Test < ActiveRecord::Base
-	  extend Embedson::Model
- 
-	  embeds_one :virt, column_name: :data, inverse_of: :parent
+
+	  embeds_one :virt, class_name: Virt, column_name: :data, inverse_of: :parent
 	end
 
 	class Virt
 	  include Virtus.model
 	  extend Embedson::Model
- 
+
 	  attribute :name, String
 	  attribute :address, Hash
-	
-	  embedded_in :parent, class_name: Test
+
+	  embedded_in :parent, class_name: Test, inverse_of: :virt
 	end
-	
+
 	virt = Virt.new(name: 'Sample', address: { street: 'Kind', number: '33' })
 	virt.attributes # => {:name=>"Sample", :address=>{:street=>"Kind", :number=>"33"}}
-	
+
 	test = Test.create!
-	test.attributes # => {"id"=>1, "data"=>nil
-	
+	test.attributes # => {"id"=>1, "data"=>nil}
+
 	test.virt = virt
 	test.save
-	test.attributes # => {"id"=>1, "data"=>{"name"=>"Sample", "address"=>{"street"=>"Kind", "number"=>"33"}
-	
-	test.reload.virt.attributes # =>  {:name=>"Sample", :address=>{:street=>"Kind", :number=>"33"}, :children=>[]}
+	test.attributes # => {"id"=>1, "data"=>{"name"=>"Sample", "address"=>{"street"=>"Kind", "number"=>"33"}}
+
+	test.reload.virt.attributes # =>  {:name=>"Sample", :address=>{:street=>"Kind", :number=>"33"}}
 	test.virt == virt # => true
 	test.virt.parent == test # => true
-	
+
+```
+
+You don't have to use all options to define ```embeds_one``` and ```embedded_in```. Just name it with downcased related class name.
+
+
+```RUBY
+	#create_tests.rb - migration
+	class CreateTests < ActiveRecord::Migration
+	  def change
+	    create_table :tests do |t|
+	      t.json :virt
+	    end
+	  end
+	end
+
+	class Test < ActiveRecord::Base
+
+	  embeds_one :virt
+	end
+
+	class Virt
+	  include Virtus.model
+	  extend Embedson::Model
+
+	  attribute :name, String
+	  attribute :address, Hash
+
+	  embedded_in :test
+	end
+```
+
+### Additional methods in embedded model:
+
+- ####save
+	Assigns ```to_h``` result to parent and saves it with ```save```.
+
+- ####save!
+	Assigns ```to_h``` result to parent and saves it with ```save!```.
+
+- ####destroy
+	Assigns ```nil``` to parent and saves it with ```save!```
+
+- ####embedson_model_changed!
+	This gem does not provide dirty tracking of embedded model. To register change in parent model use this method in your setter.
+
+
+```RUBY
+
+	def your_variable=(arg)
+	  @your_variable = arg
+	  embedson_model_changed!
+	end
+
+```
+
+## Known issues
+
+- Placing ```initialize``` method after ```embedded_in``` and using ```Emb.new(parent: parent)```
+This examples will work:
+
+```RUBY
+	class Emb
+	  extend Embedson::Model
+	  
+          def initialize(attributes = {})
+	    # do your work here
+	  end
+
+	  embedded_in :parent
+	end
+``` 
+
+```RUBY
+	class Emb
+	  extend Embedson::Model
+
+	  embedded_in :parent
+        
+	  def initialize(attributes = {})
+	    self.parent = attributes[:parent]
+	    # do your work here
+	  end
+	end
+``` 
+
+This will **not** work!
+
+```RUBY
+	class Emb
+	  extend Embedson::Model
+	  embedded_in :parent
+	  
+          def initialize(attributes = {})
+	    # if you forget about assigning parent
+	    # do your work here
+	  end
+	end
+
 ```
 
 

data/Rakefile

@@ -1,2 +1,6 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
 
+task :default => :spec
+
+RSpec::Core::RakeTask.new

data/embedson.gemspec

@@ -18,12 +18,15 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord"
+  spec.required_ruby_version = ">= 1.9.3"
+
+  spec.add_dependency "activerecord", ">= 4"
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "pg"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "with_model"
+  spec.add_development_dependency "codeclimate-test-reporter"
 
 end

data/lib/embedson.rb

@@ -1,2 +1,6 @@
 require "embedson/version"
+require "embedson/exceptions"
 require "embedson/model"
+require "embedson/model/method_builder"
+require "embedson/model/embeds_builder"
+require "embedson/model/embedded_builder"

data/lib/embedson/exceptions.rb

@@ -0,0 +1,21 @@
+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})"
+    end
+  end
+
+  class NoParentError < StandardError
+
+    def initialize(action, klass_name)
+      super("Cannot #{action} embedded #{klass_name} without a parent relation.")
+    end
+  end
+end

data/lib/embedson/model.rb

@@ -1,79 +1,14 @@
-module Embedson::Model
+module Embedson
+  module Model
 
-  def embeds_one(name, options = {})
-    column_name = options.fetch(:column_name, nil) || name
-    klass_name = (options.fetch(:class_name, nil) || name).to_s.classify
-    inverse_get = options.fetch(:inverse_of, nil) || self.name.downcase
-    inverse_set = "#{inverse_get}="
-
-    define_method("#{name}=") do |arg|
-      raise TypeError, "wrong argument type #{arg.class.name} (expected #{klass_name})" unless arg.nil? || arg.is_a?(klass_name.constantize)
-
-      if arg.respond_to?(inverse_set) && arg.public_send(inverse_get) != self
-        arg.public_send(inverse_set, self)
-      end
-
-      instance_variable_set("@#{name}", arg)
-      write_attribute(column_name, arg.nil? ? arg : arg.to_h)
-    end
-
-    define_method(name) do
-      return if read_attribute(column_name).nil?
-
-      if instance_variable_get("@#{name}").nil?
-        model = klass_name.constantize.new(read_attribute(column_name))
-        instance_variable_set("@#{name}", model)
-        model.public_send(inverse_set, self) if model.respond_to?(inverse_set)
-      end
-      instance_variable_get("@#{name}")
-    end
-  end
-
-  def embedded_in(name, options = {})
-    klass_name = (options.fetch(:class_name, nil) || name).to_s.classify
-    inverse_get = options.fetch(:inverse_of, nil) || self.name.demodulize.tableize.singularize
-    inverse_set = "#{inverse_get}="
-
-
-    define_method(name) do
-      instance_variable_get("@#{name}")
+    def embeds_one(name, options = {})
+      MethodBuilder.new(self, name, options).embeds
     end
 
-    define_method("#{name}=") do |arg|
-      raise TypeError, "wrong argument type #{arg.class.name} (expected #{klass_name})" unless arg.nil? || arg.is_a?(klass_name.constantize)
-
-      instance_variable_set("@#{name}", arg)
-      parent = public_send(name)
-
-      if parent.respond_to?(inverse_set) && parent.public_send(inverse_get) != self
-        parent.public_send(inverse_set, self)
-      end
-    end
-
-    define_method('destroy') do
-      parent = public_send(name)
-      return false unless parent.present?
-      parent.public_send(inverse_set, nil)
-      parent.save!
-    end
-
-    define_method('save') do
-      parent = public_send(name)
-      return false unless parent.present?
-      parent.save
-    end
-
-    define_method('save!') do
-      parent = public_send(name)
-      raise "No parent model defined!" unless parent.present?
-      parent.save!
-    end
-
-    define_method('embedson_model_changed!') do
-      parent = public_send(name)
-      raise "No parent model defined!" unless parent.present?
-      parent.public_send(inverse_set, self)
-      true
+    def embedded_in(name, options = {})
+      MethodBuilder.new(self, name, options).embedded
     end
   end
 end
+
+ActiveRecord::Base.send :extend, Embedson::Model

data/lib/embedson/model/embedded_builder.rb

@@ -0,0 +1,100 @@
+module Embedson
+  module Model
+    class EmbeddedBuilder
+      attr_reader :builder, :klass
+
+      def initialize(builder)
+        @builder = builder
+        @klass = builder.klass
+      end
+
+      def define
+        methods_embedded.each do |meth|
+          klass.class_exec builder, &send(meth)
+        end
+      end
+
+      private
+
+      def methods_embedded
+        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
+
+          define_method("initialize") do |*args|
+            attrs = args[0]
+            attrs ||= {}
+            public_send("#{builder.field_name}=", attrs.fetch(builder.field_name, nil))
+            orig_initialize(*args)
+          end
+        end
+      end
+
+      def embedded_writer
+        proc do |builder|
+          define_method("#{builder.field_name}=") do |arg|
+            verify_arg_klass(arg)
+
+            instance_variable_set(builder.instance_var_name, arg)
+            parent = public_send(builder.field_name)
+
+            send_self_to_related(parent)
+          end
+        end
+      end
+
+      def embedded_reader
+        proc do |builder|
+          define_method(builder.field_name) do
+            instance_variable_get(builder.instance_var_name)
+          end
+        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
+        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
+          end
+        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!
+          end
+        end
+      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
+          end
+        end
+      end
+    end
+  end
+end