virtus-relations 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8d2c028409e9b6f8e746c754c9bf30b527e4d36
+  data.tar.gz: 28a863c25d519a3bd1f17026b3ffc85063b2c43d
+SHA512:
+  metadata.gz: 9fb675108952c9f28a78aa09b44807cb5b43dc4b461534fd3dfeb232cedecccf59cb59b90034154a2de0d5ff69148daf856f5fa33ad48426cf440a2573f845ef
+  data.tar.gz: 66b4929df4ab1176919fbe0c43c6fd8921299c8a40331c985376b02bb8df168deeca3b981b18c799a62e2b7d7ab05ae694f7f723463040ae6b57387ebee15c1d

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in virtus-relations.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Simeon Manolov
+
+MIT License
+
+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/README.md

@@ -0,0 +1,75 @@
+# Virtus::Relations
+
+Adds relations to Virtus objects.
+
+## Installation
+
+In your Gemfile:
+
+```ruby
+gem 'virtus-relations'
+```
+
+In your source code:
+
+```ruby
+require 'virtus/relations'
+```
+
+## Usage examples
+Given the following classes:
+```ruby
+require 'virtus/relations'
+
+class Kid
+  include Virtus.model
+
+  attribute :name, String
+end
+
+class Mother
+  include Virtus.model
+  include Virtus.relations(as: :mom)
+
+  attribute :name, String
+  attribute :kid, Kid, relation: true, lazy: true, default: :load_kid
+
+  def load_kid
+    { name: 'Billy' }
+  end
+end
+```
+
+You can do the following:
+```ruby
+### Explicit assignment
+alice = Mother.new(name: 'Alice')
+alice.kid = { name: 'Danny' }
+alice.kid.mom
+# => <Mother:0x007fa43415fda8 @name="Alice", ...>
+
+### Mass-assignment
+emma = Mother.new(name: 'Emma', kid: { name: 'Johnny' })
+emma.kid.mom
+# => #<Mother:0x007fc40dbbdbf8 @name="Emma", ...>
+
+### Lazy assignment
+mia = Mother.new(name: 'Mia')
+mia.kid.mom
+# => #<Mother:0x007fa435d27130 @name="Mia", ...>
+
+### Objects can still be created without a parent
+orphan = Kid.new(name: 'Deirdre')
+orphan.parent
+# => NoMethodError: undefined method `parent' for #<Kid:0x007...
+```
+
+The `:as` option defaults to `parent` when omitted
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch
+3. Comply with the [ruby style guide](https://github.com/bbatsov/ruby-style-guide)
+4. Add tests for your new feature/bugfix. This is important so I don't break it in a future version unintentionally.
+5. Submit a pull request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/virtus/relations.rb

@@ -0,0 +1,186 @@
+require 'virtus'
+require 'virtus/relations/version'
+
+module Virtus
+  def self.relations(params = {})
+    rel_name = params.fetch(:as, :parent)
+    fail TypeError, 'Symbol expected' unless rel_name.is_a?(Symbol)
+
+    mod = Module.new
+    mod.instance_variable_set(:@rel_name, rel_name)
+
+    mod.module_eval do
+      def self.class_methods
+        Module.new do
+          # During instantiation, .relation_attributes is called
+          # If class was instantiated before, just return the list of related
+          # attributes
+          #
+          # If instantiated for the first time, then monkey-patch some instance
+          # methods to allow relation attributes to work with accessor methods.
+          #
+          #
+          # patch Model#attribute=
+          #
+          #   1. create {list}
+          #   2. for each {attribute} in {list}
+          #   2.1. patch the accessor method
+          #   2.2. patch the lazy initializer method (if any)
+          #
+          def relation_attributes
+            @relation_attributes ||= attribute_set.select do |attribute|
+              next unless attribute.options[:relation] == true
+
+              patch_accessor_method(attribute)
+              patch_lazy_initializer(attribute)
+              true
+            end
+          end
+
+          #
+          # When the original method returns something, we need to
+          # actually set ourselves as its parent
+          # If that something is a collection, do it for each element
+          #
+          def relate(object, method_return)
+            if object.kind_of?(Array)
+              object.each { |o| relate(o, method_return) }
+            else
+              object.define_singleton_method(relation_name) { method_return }
+              object
+            end
+          end
+
+
+          protected
+          #   1. rename method "{attribute}=" to "{attribute}_not_related="
+          #   2. define method "{attribute}=", which:
+          #     2.1. calls "{attribute}_not_related=", takes the {return_object}
+          #     2.2. defines {return_object}.parent which returns self
+          #     2.3. returns {return_object}
+          #   3. return the list
+          def patch_accessor_method(attribute)
+            if [Numeric, Symbol].any? { |c| attribute.primitive.ancestors.include?(c) }
+              fail "Relations don't work with Numeric and Symbol types"
+            end
+
+            old_method = "#{attribute.name}_not_related="
+            new_method = "#{attribute.name}="
+
+            # Suffix the original method with '_not_related'
+            define_method(old_method, instance_method(new_method))
+            define_method(new_method) do |value|
+              return_value = send(old_method, value)
+              self.class.relate(return_value, self)
+            end
+
+            private old_method
+            visibility = attribute.options[:writer]
+            send(visibility, new_method)
+          end
+
+          # (see above for the explanation of step 2.)
+          #   Wrap the original method/proc into a new one, which:
+          #   1. calls the original one, takes the {return_object}
+          #   2. coerces {return_object}
+          #   3. defines {return_object}.parent which returns self
+          #   4. returns {return_object}
+          #
+          def patch_lazy_initializer(attribute)
+            return unless attribute.lazy?
+
+            case attribute.default_value.value
+            when Proc
+              old_proc = attribute.default_value.value
+              new_proc = proc do |object, *args|
+                return_value = attribute.coerce(old_proc.call(*[object, *args]))
+                object.class.relate(return_value, object)
+              end
+
+              attribute.default_value.instance_variable_set(:@value, new_proc)
+            else
+              old_method = "#{attribute.default_value.value}_not_related"
+              new_method = attribute.default_value.value
+              visibility = if private_method_defined?(new_method)
+                             :private
+                           elsif protected_method_defined?(new_method)
+                             :protected
+                           else
+                             :public
+                           end
+
+              define_method(old_method, instance_method(new_method))
+              define_method(new_method) do
+                return_value = attribute.coerce(send(old_method))
+                self.class.relate(return_value, self)
+                return_value
+              end
+
+              private old_method
+              send(visibility, new_method)
+            end
+          end
+        end # Module.new
+      end # def
+
+      def self.instance_methods
+        Module.new do
+          #
+          # Enhance the initialize process to allow
+          # related attributes to work with mass-assignment
+          #
+          def initialize(mass_assignment_attributes = {})
+            super
+
+            self.class.relation_attributes.each do |ra|
+              # set self as the child's parent only if child was mass-
+              # assigned during self.initialize (e.g. hash has child's key)
+              # This prevents children from doing this against the parents
+              # when they also have relation: true on their attributes
+              # (since their initializers will not receive the parent as
+              #  a part of the mass-assignment)
+
+              if mass_assignment_attributes.key?(ra.name)
+                self.class.relate(ra.get(self), self)
+              end
+            end
+          end
+
+          alias_method :dup_not_related, :dup
+
+          # Add #parent to duped objects, when available
+          def dup
+            rel = self.class.relation_name
+            if respond_to?(rel)
+              self.class.relate(dup_not_related, rel)
+            else
+              dup_not_related
+            end
+          end
+        end # Module.new
+      end # def
+
+      def self.included(base)
+        required = [
+          Virtus::InstanceMethods::MassAssignment,
+          Virtus::InstanceMethods::Constructor
+        ]
+
+        unless required.all? { |mod| base.included_modules.include?(mod) }
+          fail 'Virtus.model must be included prior to Virtus.relations'
+        end
+
+        # Using a local variable in the parent scope
+        # with the same name as the singleton method
+        # prevents recursion
+        relation_name = @rel_name
+        base.define_singleton_method(:relation_name) { relation_name }
+
+        base.send(:include, instance_methods)
+        base.extend(class_methods)
+      end
+
+      mod
+    end
+  end
+end

data/lib/virtus/relations/version.rb

@@ -0,0 +1,5 @@
+module Virtus
+  module Relations
+    VERSION = '1.0.0'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+Bundler.require(:default, :development)
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/virtus/relations_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'active_support/core_ext/object/instance_variables'
+
+describe Virtus::Relations do
+  # The child
+  class C
+    include Virtus.model
+  end
+
+  # The parent, referenced by Child#parent
+  class P
+    include Virtus.model
+    include Virtus.relations
+
+    attribute :c_1, C, relation: true
+    attribute :c_2, C, relation: true, lazy: true, default: :load_c_2
+    attribute :c_3, C, relation: true, lazy: true, default: proc { {} }
+    attribute :c_4, Array[C], relation: true
+    attribute :c_5, Array[C], relation: true,  lazy: true, default: :load_c_5
+    attribute :c_6, Array[C], relation: true,  lazy: true, default: proc { [{}] }
+
+    def load_c_2
+      {}
+    end
+
+    def load_c_5
+      [{}]
+    end
+  end
+
+  # Another parent, but referenced by Child#father
+  class F
+    include Virtus.model
+    include Virtus.relations(as: :father)
+
+    attribute :c, C, relation: true
+  end
+
+  it 'allow to specify a relation name' do
+    f = F.new
+    f.c = {}
+
+    expect(f.c.father).to be(f)
+  end
+
+  describe 'Object#parent' do
+    context 'when initialized via a related attribute' do
+      context 'of non-array type' do
+        context 'and is mass-assigned' do
+          let(:p) { P.new(c_1: {}) }
+
+          it 'returns the attribute owner' do
+            expect(p.c_1.parent).to be(p)
+          end
+
+          it 'does not store its return value in an instance variable' do
+            expect(p.c_1.instance_values.values).not_to include(p)
+          end
+        end
+
+        context 'and is strictly initialized' do
+          it 'returns the attribute owner' do
+            p = P.new
+            p.c_1 = {}
+            expect(p.c_1.parent).to be(p)
+          end
+        end
+
+        context 'and is lazily initialized via a method' do
+          it 'returns the attribute owner' do
+            p = P.new
+            expect(p.c_2.parent).to be(p)
+          end
+        end
+
+        context 'and is lazily initialized via a proc' do
+          it 'returns the attribute owner' do
+            p = P.new
+            p.c_3
+            expect(p.c_3.parent).to be(p)
+          end
+        end
+      end
+
+      context 'of an array type' do
+        context 'and is mass-assigned' do
+          it 'returns the attribute owner' do
+            p = P.new(c_4: [{}])
+            expect(p.c_4.first.parent).to be(p)
+          end
+        end
+
+        context 'and is strictly initialized' do
+          it 'returns the attribute owner' do
+            p = P.new
+            p.c_4 = [{}]
+            expect(p.c_4.first.parent).to be(p)
+          end
+        end
+
+        context 'and is lazily initialized via a method' do
+          it 'returns the attribute owner' do
+            p = P.new
+            expect(p.c_5.first.parent).to be(p)
+          end
+        end
+
+        context 'and is lazily initialized via a proc' do
+          it 'returns the attribute owner' do
+            p = P.new
+            expect(p.c_6.first.parent).to be(p)
+          end
+        end
+      end
+    end
+  end
+
+  describe ''
+
+end

data/virtus-relations.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'virtus/relations/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'virtus-relations'
+  spec.version       = Virtus::Relations::VERSION
+  spec.authors       = ['Simeon Manolov']
+  spec.email         = ['s.manolloff@gmail.com']
+  spec.summary       = %q{Relations for Virtus models}
+  spec.homepage      = 'https://github.com/smanolloff/virtus-relations'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'virtus', '~> 1'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.2'
+  spec.add_development_dependency 'pry-byebug', '~> 3.1'
+  spec.add_development_dependency 'activesupport', '~> 4.2'
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: virtus-relations
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Simeon Manolov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: 
+email:
+- s.manolloff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/virtus/relations.rb
+- lib/virtus/relations/version.rb
+- spec/spec_helper.rb
+- spec/virtus/relations_spec.rb
+- virtus-relations.gemspec
+homepage: https://github.com/smanolloff/virtus-relations
+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.3
+signing_key: 
+specification_version: 4
+summary: Relations for Virtus models
+test_files:
+- spec/spec_helper.rb
+- spec/virtus/relations_spec.rb