mongoid-embedded_copy 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d7c96aa95743c9b0ce42fe49cb82fb0b2a906f63
+  data.tar.gz: 5c32ab4b11fa8a0c1cb8bfb4e9c5af1a6fb88697
+SHA512:
+  metadata.gz: 6a8d8bdf66cf2cd8b5bc0e9fd46eb2b4a25a8ef4ab3f54a1cf15e279182e2f803b157d852f4b7ba7c2486e4271b213a19f3e716ce2bf73779ad536449a314b99
+  data.tar.gz: e887b5ccbf3979d8d0700d863f436b0a4dbe0290c331930ecd7649f0d18f01fed71642914a78c77c496a09fa601ab0bc05e237d1876f03182961f246c65cf135

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 Geoffroy Planquart
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,15 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+desc 'Default: run unit tests'
+task :default => :test
+
+desc 'Run tests'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+

data/lib/mongoid/embedded_copy/version.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  module EmbeddedCopy
+    VERSION = '1.0.0'
+  end
+end
+

data/lib/mongoid/embedded_copy.rb

@@ -0,0 +1,122 @@
+module Mongoid
+  module EmbeddedCopy
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def embeds_copy(name, opts = {})
+        klass = opts[:class_name] || name.to_s.camelize
+        embedded_class = EmbeddedCopy.embedded_class(self, opts, klass)
+        EmbeddedCopy.for(klass, opts.merge({:in => self, inverse_of: name}))
+        mongoid_options = Mongoid::Relations::Embedded::One.valid_options +
+          Mongoid::Relations::Options::COMMON
+        embeds_one name, opts.merge({class_name: embedded_class}).slice(*mongoid_options)
+
+        define_method("#{name}_with_copy=") do |value|
+          value = embedded_class.constantize.new(value) if value.class.name == klass
+          self.public_send("#{name}_without_copy=", value)
+        end
+        alias_method_chain "#{name}=", :copy
+      end
+    end
+
+    def self.embedded_class(klass, opts, prefix = nil)
+      embedded_class = opts[:embedded_class] || "CopyFor#{klass}".gsub('::', '')
+      [prefix, embedded_class].compact.join('::')
+    end
+
+    def self.for(klass, opts = {})
+      klass = klass.constantize if klass.is_a?(String)
+      raise ArgumentError.new('Requires :in options to specify the document in which this one is embedded') if !opts.has_key?(:in)
+      raise ArgumentError.new("Can't create an embedded copy of non-mongoid document class #{klass}") if !(klass < Mongoid::Document)
+      skipped = Array(opts[:skip]).map{|f| f.to_s}
+      skipped.push('deleted_at')
+
+      embed_opts = opts[:in]
+      embed_opts = {class_name: embed_opts.to_s, as: embed_opts.to_s.underscore} if embed_opts.is_a?(Class)
+      embed_opts[:inverse_of] = opts[:inverse_of]
+      embedded_class = self.embedded_class(embed_opts[:class_name], opts)
+      embed_name = embed_opts.delete(:as)
+      skipped.push(embed_name).push("#{embed_name}_id")
+
+      return if klass.const_defined?(embedded_class) && [klass, embedded_class].join('::').constantize.respond_to?(:original_class)
+      klass.send(:include, equality_module_for(klass))
+
+      document_module = Module.new do
+        extend ActiveSupport::Concern
+
+        included do
+          include Mongoid::Document
+          include Mongoid::EmbeddedCopy.equality_module_for(klass)
+
+          class_attribute :original_class, instance_writer: false
+          class_attribute :skipped_attributes, instance_writer: false
+          class_attribute :embed_name
+
+          self.original_class = klass
+          self.embed_name = embed_name
+          self.skipped_attributes = skipped
+
+          def initialize(*attrs)
+            if attrs.first.is_a?(original_class)
+              attrs = attrs.first.attributes.to_h.dup
+              skipped_attributes.each {|n| attrs.delete(n) }
+            end
+            super(attrs)
+          end
+
+          embedded_in embed_name, embed_opts
+
+          klass.fields.each do |name, f|
+            next if skipped.include?(name) || name == '_id'
+            options = f.options.dup
+            options.delete(:klass)
+            field name, options
+
+            if opts[:update_original]
+              define_method("#{name}_with_update_original=") do |value|
+                load_original.set(name => value)
+                public_send("#{name}_without_update_original=", value)
+              end
+              alias_method_chain "#{name}=", :update_original
+            end
+          end
+        end
+
+        def load_original
+          @original ||= original_class.find(id)
+        end
+      end
+
+      if klass.const_defined?(embedded_class)
+        klass.const_get(embedded_class).send(:include, document_module)
+      else
+        klass.const_set(embedded_class, Class.new do
+          include document_module
+        end)
+      end
+    end
+
+    def self.equality_module_for(klass)
+      Module.new do
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :acts_as_method, instance_writer: false
+          self.acts_as_method = "acts_as_#{klass.to_s.underscore}"
+
+          define_method(acts_as_method) { true }
+        end
+
+        def ==(rhs)
+          if rhs.respond_to?(acts_as_method) && rhs.public_send(acts_as_method)
+            id == rhs.id
+          else
+            super
+          end
+        end
+        alias_method :eql?, :==
+      end
+    end
+  end
+end
+

data/lib/mongoid-embedded_copy.rb

@@ -0,0 +1,2 @@
+require 'mongoid/embedded_copy'
+

data/test/embedded_copy_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+class EmbeddedCopyTest < BaseTest
+  test 'should raise if given class is not a Mongoid::Document' do
+    assert_raises(ArgumentError) do
+      Mongoid::EmbeddedCopy.for(BaseTest, in: User)
+    end
+  end
+
+  test 'should raise if no :in argument is given' do
+    assert_raises(ArgumentError) do
+      Mongoid::EmbeddedCopy.for(User)
+    end
+  end
+
+  test 'should access embedded copy' do
+    user = User.create({firstname: 'Geoffroy', lastname: 'Planquart'})
+    post = Post.create({title: 'Hello', content: 'Hello World', user: user, u: user})
+    
+    assert_equal User::CopyForPost, post.u.class
+    assert_equal user, post.u.load_original
+    assert_operator user, :==, post.u
+    assert_operator post.u, :==, user
+    assert post.u.eql?(user)
+  end
+
+  test 'should embeds copy of document embedding a copy of self' do
+    class ::User
+      embeds_copy :last_post, class_name: 'Post', skip: :u
+    end
+
+    user = User.create({firstname: 'Geoffroy', lastname: 'Planquart'})
+    post = Post.create({title: 'Hello', content: 'Hello World', user: user, u: user})
+    user.set(last_post: post)
+
+    assert_operator post, :==, user.last_post
+  end
+
+  test 'load_original should return new value if copy is changed' do
+    user1 = User.create({firstname: 'Geoffroy', lastname: 'Planquart'})
+    user2 = User.create({firstname: 'John', lastname: 'Doe'})
+
+    post = Post.create({title: 'Hello', content: 'Hello World', user: user1, u: user1})
+    assert_equal user1, post.u.load_original
+    post.set(u: user2)
+    assert_equal user2, post.u.load_original
+  end
+
+  test 'should update original' do
+    class ::User
+      embeds_copy :first_post, class_name: 'Post', skip: :u, update_original: true, embedded_class: 'Copy'
+    end
+
+    post = Post.create({title: 'Hello', content: 'Hello World'})
+    user = User.create({firstname: 'Geoffroy', lastname: 'Planquart', first_post: post})
+    user.first_post.set(title: 'World')
+
+    assert_equal Post::Copy, user.first_post.class
+
+    assert_equal 'World', post.reload.title
+  end
+
+  test 'should use predefined class and add attributes once' do
+    class ::User
+      embeds_copy :a_post, class_name: 'Post', skip: :u, embedded_class: 'SpecializedCopy'
+    end
+
+    post = Post.create({title: 'Hello', content: 'Hello World'})
+    user = User.create({firstname: 'Geoffroy', lastname: 'Planquart', a_post: post})
+
+    assert_equal Post::SpecializedCopy, user.a_post.class
+    assert_nothing_raised(NoMethodError) do
+      user.a_post.some_method
+    end
+  end
+end
+

data/test/models/post.rb

@@ -0,0 +1,17 @@
+class Post
+  include Mongoid::Document
+  include Mongoid::EmbeddedCopy
+
+  field :title
+  field :content
+
+  embeds_copy :u, class_name: 'User'
+  belongs_to :user
+
+  class SpecializedCopy
+    def some_method
+      true
+    end
+  end
+end
+

data/test/models/user.rb

@@ -0,0 +1,10 @@
+class User
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  field :firstname
+  field :lastname
+
+  has_many :posts
+end
+

data/test/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: mongoid_embedded_copy_test
+      hosts:
+        - localhost:27017

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+require 'bundler/setup'
+require 'simplecov'
+require 'pry'
+SimpleCov.configure do
+  add_filter '/test/'
+end
+SimpleCov.start if ENV['COVERAGE']
+
+require 'minitest/autorun'
+require 'mongoid'
+
+require File.expand_path("../../lib/mongoid-embedded_copy", __FILE__)
+
+Mongoid.load!("#{File.dirname(__FILE__)}/mongoid.yml", "test")
+
+Dir["#{File.dirname(__FILE__)}/models/*.rb"].each { |f| require f }
+
+ActiveSupport::TestCase.test_order = :random
+
+class BaseTest < ActiveSupport::TestCase
+  def teardown
+    Mongoid::Sessions.default.use('mongoid_embedded_copy_test').drop
+  end
+end
+

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-embedded_copy
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Geoffroy Planquart
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Create a mimic of a root document to use as a copy embedded in another
+  document
+email:
+- geoffroy@planquart.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/mongoid-embedded_copy.rb
+- lib/mongoid/embedded_copy.rb
+- lib/mongoid/embedded_copy/version.rb
+- test/embedded_copy_test.rb
+- test/models/post.rb
+- test/models/user.rb
+- test/mongoid.yml
+- test/test_helper.rb
+homepage: https://github.com/Aethelflaed/mongoid-embedded_copy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Mimic a given root document to use as embedded copy
+test_files:
+- test/models/user.rb
+- test/models/post.rb
+- test/mongoid.yml
+- test/test_helper.rb
+- test/embedded_copy_test.rb
+has_rdoc: