active_record-any_links 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d991efbc26c4de04ea6203b73356fdb35806afd
+  data.tar.gz: cb1a9f0466c18907fd4ff35fb5a3264310279ea4
+SHA512:
+  metadata.gz: bf656d93c9a5cda2cc9e8996df81a93fa41e7193c6427a739b32f2c9a7db1b13f22fb92bb60b4fdf7021877c9ef069f684594af76fb673f344d90bf44ba45c83
+  data.tar.gz: f47fcedc79318c8700c5952bc3fa0b1d78306a2f2184e35a2d947ba37b1af78e2685e19c3a6a67fe194bb3d62df8deb72e806e802cd5477f50415058cbcc1d3d

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.14.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2017, Samanage
+
+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,209 @@
+# AnyLinks
+
+AnyLinks is an ActiveRecord extension which enables simple linking any model to any other model.
+
+It requires a single table holding the connection of all types, and a single statement for each linked model.
+No pass-through model required.
+
+The links can be many-to-many or one-to-many, and can link
+also any model to itself, with bidirectional connection.
+
+It is a simple-to-use extension to the polymorphic schema, but without the complexity and with much more capabilities.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record-any_links'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_record-any_links
+
+## Getting Started
+
+### 1. Create any_links table
+
+AnyLinks requires an any_links table to store the links.
+You can create the table by adding the following migration, and running:
+
+```ruby
+ rake db:migrate
+```
+
+```ruby
+ class CreateAnyLinks < ActiveRecord::Migration
+   def up
+     create_table :any_links do |t|
+       t.integer :id1, null: false
+       t.string :type1, null: false
+       t.integer :id2, null: false
+       t.string :type2, null: false
+
+       t.timestamps
+     end
+
+     change_table :any_links do |t|
+       t.index [:id1, :type1, :id2, :type2], unique: true
+       t.index [:id1, :type1, :type2]
+       t.index [:id2, :type2, :type1]
+     end
+   end
+
+   def down
+     drop_table :any_links
+   end
+ end
+```
+
+### 2. Linking models
+
+In the following example we link the User model to Group model, using many to many relationship.
+
+```ruby
+class User < ActiveRecord::Base
+  has_many_to_many :groups
+end
+
+class Group < ActiveRecord::Base
+  has_many_to_many :users
+end
+```
+### 3. Using the linked models
+
+Use the linked models the same way you use any has_many relationship.
+examples:
+
+```ruby
+@user.groups = [group, group]
+@group.user_ids # => [4,7,9]
+@group.users.exists?
+@group.users.where(first_name: "James")
+```
+
+## AnyLinks statements
+
+There are three statements added to ActiveRecord:
+
+```ruby
+has_many_to_many
+has_many_to_one
+has_one_to_many
+```
+
+Each one of them creates a bundle of helper methods.
+
+## has_many_to_many
+
+has_many_to_many Specifies a many-to-many bi-directional association.
+Regularly, has_many_to_many is declared in each side of the association models.
+It will also work if declared only on one side of the association. However, doing so will
+not generate the dynamic methods on the other side, making the connections seen from
+one side only
+
+has_many_to_many can be used even on the same model:
+
+```ruby
+class User < ActiveRecord::Base
+  has_many_to_many :friends, class_name: User
+end
+```
+
+The previous link is also bidirectional!
+The associations, for all types and collections, are stored together in a single table called 'any_links'.
+The table contain all links between all instances of any type.
+Every record represent a link, which contains id and type for each side of the connection,
+which are called id1, type1, and id2, type2 respectively.
+Since the links are bi-directional, theoretically, any object can be represented as the left
+side link (#1) or right side (#2).
+For simplicity and performance, the links are stored thus the "smallest" type is in the left.
+Any link betwwen 'Incident' and 'Change' is stored as the Change object in the left, since
+the string types are 'Change' < 'Incident'.
+This technique is 'Hidden' and transparent for the has_many_to_many consumer.
+
+For association of the same type - (e.g. `Incident has_many incidents`):
+do standard declaration in the Class (i.e. has_many_to_many <collection>).
+In that case, a callbacks of after create and after destroy shall be called in the relevant any_link class.
+To overcome association methods that skip callbacks (as clear method) we override the delete_all
+association method of has many by passing a block with the new function.
+Notice that calling with 'dependent' param in this case shall raise an error since it doesn't have a meaning
+for once and secondly this param cannot be passed to destroy_all which is the callback that we call.
+
+A set dynamic methods are generated for altering the set of linked objects.
+They are the same methods as added by has_many decleration.
+The following methods for retrieval and query of
+collections of associated objects will be added:
+
+#### Auto-generated methods
+
+```ruby
+        others
+        others=(other,other,...)
+        other_ids
+        other_ids=(id,id,...)
+        others<<
+        others.push
+        others.concat
+        others.build(attributes={})
+        others.create(attributes={})
+        others.create!(attributes={})
+        others.size
+        others.length
+        others.count
+        others.sum(args*,&block)
+        others.empty?
+        others.clear
+        others.delete(other,other,...)
+        others.delete_all
+        others.destroy_all
+        others.find(*args)
+        others.exists?
+        others.uniq
+        others.reset
+ ```
+#### Options
+
+      [:class_name]
+        Specify the class name of the association. Use it only if that name can't be inferred
+        from the association name. So <tt>has_many_to_many :products</tt> will by default be linked
+        to the Product class, but if the real class name is SpecialProduct, you'll have to
+        specify it with this option.
+
+#### Examples
+
+```ruby
+      has_many_to_many :authors                             # linked class is Author
+      has_many_to_many :authors, class_name: "Person"       # specify that linked class is Person
+```
+
+## has_one_to_many, has_many_to_one
+
+has_one_to_many Specifies a one-to-many bi-directional association.
+The has_one_to_many is declared in one side of the association models. The other side must declare the opposite direction with has_many_to_one decleration.
+Notice: It differ from has_many_to_many, which will work also if only one side of the association is
+declared.
+
+The has_one_to_many and has_many_to_one use the has_many_to_many to create the relatioships, in the same
+table, but with restriction to a single connection from the has_one side.
+It means that the decleration creates plural helper functions as above in additition to the following
+singular helper functions.
+
+#### Singular Auto-generated methods
+
+```ruby
+  other
+  other=other
+  other_id
+  other_id=id
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Hagai-Arzi/active_record-any_links.
+

data/Rakefile

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

data/active_record-any_links.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record/any_links/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_record-any_links"
+  spec.version       = ActiveRecord::AnyLinks::VERSION
+  spec.authors       = ["Hagai Arzi"]
+  spec.email         = ["Hagai.Arzi@Gmail.com"]
+
+  spec.summary       = %q{Enable link objects of different models in a single table using only a single statement.}
+  spec.description   = %q{Enable link objects of different models in a single table using has_many_to_many, has_one_to_many or has_many_to_one methods.}
+  spec.homepage      = "https://github.com/Hagai-Arzi/active_record-any_links/tree/master/lib/active_record"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "sqlite3", "~> 1.3"
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  # spec.add_development_dependency 'byebug'
+  # spec.add_development_dependency 'pry-byebug'
+  # spec.add_development_dependency 'pry-rails'
+  # spec.add_development_dependency 'pry-stack_explorer'
+
+  spec.add_dependency "activerecord", ">= 4.2"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "active_record/any_links"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/active_record/any_links/class_methods.rb

@@ -0,0 +1,224 @@
+module ActiveRecord
+  module AnyLinks
+    module ClassMethods
+
+      # has_many_to_many Specifies a many-to-many bi-directional association.
+      # Regularly, the has_many_to_many is declared in each side of the association models.
+      # It will also work if declared only on one side of the association. However, doing so will
+      # not generate the dynamic methods on the other side, making the connections seen from
+      # one side only
+      #
+      # The associations, for all types and collections, are stored together in a single table called 'any_links'.
+      # The table contain all links between all instances of any type.
+      # Every record represent a link, which contains id and type for each side of the connection,
+      # which are called id1, type1, and id2, type2 respectively.
+      # Since the links are bi-directional, theoretically, any object can be represented as the left
+      # side link (#1) or right side (#2).
+      # For simplicity and performance, the links are stored thus the "smallest" type is in the left.
+      # Any link betwwen 'Incident' and 'Change' is stored as the Change object in the left, since
+      # the string types are 'Change' < 'Incident'.
+      # This technique is 'Hidden' and transparent for the has_many_to_many consumer.
+      #
+      # For association of the same type - (e.g. Incident has_many incidents):
+      # do standard declaration in the Class (i.e. has_many_to_many <collection>).
+      # In that case, a callbacks of after create and after destroy shall be called in the relevant any_link class.
+      # To overcome association methods that skip callbacks (as clear method) we override the delete_all
+      # association method of has many by passing a block with the new function.
+      # Notice that calling with 'dependent' param in this case shall raise an error since it doesn't have a meaning
+      # for once and secondly this param cannot be passed to destroy_all which is the callback that we call.
+      #
+      # The table should manually generated with a migration such as this:
+      #
+      #    class CreateAnyLinks < ActiveRecord::Migration
+      #      def up
+      #        create_table :any_links do |t|
+      #          t.integer :id1, null: false
+      #          t.string :type1, null: false
+      #          t.integer :id2, null: false
+      #          t.string :type2, null: false
+      #
+      #          t.timestamps
+      #        end
+      #
+      #        change_table :any_links do |t|
+      #          t.index [:id1, :type1, :id2, :type2], unique: true
+      #          t.index [:id1, :type1, :type2]
+      #          t.index [:id2, :type2, :type1]
+      #        end
+      #      end
+      #
+      #      def down
+      #        drop_table :any_links
+      #      end
+      #    end
+
+      # A set dynamic methods are generated for altering the set of linked objects.
+      # They are the same methods as added by has_many decleration.
+      # The following methods for retrieval and query of
+      # collections of associated objects will be added:
+      #
+      #   Auto-generated methods
+      #   --------------------------------------
+      #   others
+      #   others=(other,other,...)
+      #   other_ids
+      #   other_ids=(id,id,...)
+      #   others<<
+      #   others.push
+      #   others.concat
+      #   others.build(attributes={})
+      #   others.create(attributes={})
+      #   others.create!(attributes={})
+      #   others.size
+      #   others.length
+      #   others.count
+      #   others.sum(args*,&block)
+      #   others.empty?
+      #   others.clear
+      #   others.delete(other,other,...)
+      #   others.delete_all
+      #   others.destroy_all
+      #   others.find(*args)
+      #   others.exists?
+      #   others.uniq
+      #   others.reset
+      #
+      # === Options
+      #
+      # [:class_name]
+      #   Specify the class name of the association. Use it only if that name can't be inferred
+      #   from the association name. So <tt>has_many_to_many :products</tt> will by default be linked
+      #   to the Product class, but if the real class name is SpecialProduct, you'll have to
+      #   specify it with this option.
+      #
+      # === Examples
+      #
+      # has_many_to_many :authors                             # linked class is Author
+      # has_many_to_many :authors, class_name: "Person"       # specify that linked class is Person
+      def has_many_to_many(collection, options = {})
+        class_name = options[:class_name]
+        link_items, foreign_key, source = define_link_class(class_name || collection)
+        has_many link_items, foreign_key: foreign_key
+        if !identical_source_collection_class(class_name || collection)
+          has_many collection, { through: link_items, source: source, dependent: :destroy }.merge(options)
+        else
+          has_many collection, through: link_items, source: source, dependent: :destroy do
+            def delete_all(dependent = nil)
+              if dependent.present?
+                raise "The dependency is not supported nor relevant to the case of has_many_to_many since the relation is through association table any_links!"
+              end
+              destroy_all
+            end
+          end
+        end
+      end
+
+      # has_one_to_many Specifies a one-to-many bi-directional association.
+      # The has_one_to_many is declared in one side of the association models. The other side
+      # must declare the opposite direction with has_many_to_one decleration.
+      # Notice: It differ from has_many_to_many, which will work also if only one side of the association is
+      # declared.
+      #
+      # The has_one_to_many and has_many_to_one use the has_many_to_many to create the relatioships, in the same
+      # table, but with restriction to a single connection from the has_one side.
+      # It means that the decleration creates plural helper functions as above in additition to the following
+      # singular helper functions.
+      #
+      #   Singular Auto-generated methods
+      #   --------------------------------------
+      #   other
+      #   other=other
+      #   other_id
+      #   other_id=id
+      #
+      def has_one_to_many(collection, options = {})
+        item = collection.to_s.singularize.to_sym
+        has_many_to_many(
+          item.to_s.pluralize.to_sym,
+          options.merge(before_add: -> (owner, obj) { raise ActiveRecord::RecordNotUnique.new("#{name} can have only one #{obj.class} associated") if owner.send(item).present? })
+        )
+        AnyLinks.define_singular_accessors(self, item, collection)
+      end
+
+      def has_many_to_one(collection, options = {})
+        has_many_to_many(collection, options.merge(before_add: -> (_owner, obj) { obj.send(name.demodulize.underscore.pluralize).clear }))
+      end
+
+      private
+
+      def identical_source_collection_class(collection_or_class)
+        name == collection_or_class.to_s.singularize.classify
+      end
+
+      def define_link_class(collection)
+        klass1 = name
+        klass2 = collection.to_s.singularize.classify
+        model1 = name.demodulize.underscore
+        model2 = collection.to_s.demodulize.singularize.underscore
+        foreign_key = :id1
+        source = (klass1 == klass2 ? model2 + "_ghost" : model2).to_sym
+        model1, model2, klass1, klass2, foreign_key = model2, model1, klass2, klass1, :id2 if model1 > model2
+        klass_name = "#{model1}_#{model2}_link".classify
+        model2 = source if klass1 == klass2
+
+        define_class(klass_name, ActiveRecord::Base) do
+          if klass1 == klass2
+            attr_accessor :duplicated_relation
+            after_create :create_opposite_relation
+            after_destroy :destroy_opposite_relation
+          end
+
+          self.table_name = 'any_links'
+
+          belongs_to model1.to_sym, foreign_key: :id1, class_name: klass1
+          belongs_to model2.to_sym, foreign_key: :id2, class_name: klass2
+
+          default_scope { where(type1: klass1, type2: klass2) }
+
+          def create_opposite_relation
+            if !duplicated_relation && id2 != id1
+              self.class.create!(type1: type1, id1: id2, type2: type1, id2: id1, duplicated_relation: true)
+            end
+          end
+
+          def destroy_opposite_relation
+            self.class.find_by(type1: type1, type2: type2, id1: id2, id2: id1).try(:destroy)
+          end
+        end
+
+        [klass_name.underscore.pluralize.to_sym, foreign_key, source]
+      end
+
+      def define_class(klass_name, ancestor, &block)
+        if !const_defined?(klass_name)
+          klass = Class.new(ancestor, &block)
+          Object.const_set(klass_name, klass)
+        end
+      end
+    end
+
+    def self.define_singular_accessors(model, item, plural_name)
+      mixin = model.generated_association_methods
+      define_readers(mixin, item, plural_name)
+      define_writers(mixin, item, plural_name)
+      define_readers(mixin, "#{item}_id", "#{item}_ids")
+      define_writers(mixin, "#{item}_id", "#{item}_ids")
+    end
+
+    def self.define_readers(mixin, name, plural_name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(*args)
+          send("#{plural_name}")[0]
+        end
+      CODE
+    end
+
+    def self.define_writers(mixin, name, plural_name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          value.nil? ? send("#{plural_name}=", []) : send("#{plural_name}=", [value])
+        end
+      CODE
+    end
+  end
+end

data/lib/active_record/any_links/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module AnyLinks
+    VERSION = "0.1.0"
+  end
+end

data/lib/active_record/any_links.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+require 'active_record/any_links/version'
+require 'active_record/any_links/class_methods'
+
+module ActiveRecord
+  class Base
+    extend AnyLinks::ClassMethods
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: active_record-any_links
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hagai Arzi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: Enable link objects of different models in a single table using has_many_to_many,
+  has_one_to_many or has_many_to_one methods.
+email:
+- Hagai.Arzi@Gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_record-any_links.gemspec
+- bin/console
+- bin/setup
+- lib/active_record/any_links.rb
+- lib/active_record/any_links/class_methods.rb
+- lib/active_record/any_links/version.rb
+homepage: https://github.com/Hagai-Arzi/active_record-any_links/tree/master/lib/active_record
+licenses: []
+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.6.8
+signing_key: 
+specification_version: 4
+summary: Enable link objects of different models in a single table using only a single
+  statement.
+test_files: []