rails_dynamic_associations 0.2.0.real → 0.2.1.real

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43cb344fd8b7ef4cd4f603260a48ad84c2fd3010
-  data.tar.gz: 121001d4ff410084fe0e1306735a8f78bf40e931
+  metadata.gz: 2e750c6c7f3dff5b63c11d91a5636cb7aeffc31b
+  data.tar.gz: c8f63f3d0831bbe148c3ebde7563f36548d078e5
 SHA512:
-  metadata.gz: ce004cfa30905fbfd731e1be5e084ccb10bbadf1018966d4a45f3cda25fd93258f1b330c70ffad9871ae3cb768b6a88358c8b0caa696fbd835adc786782c4270
-  data.tar.gz: 46953fe6aafe0cc8b6e7b3d15890d54f786f310f27ad4bf9b8d9aefac2947c0c6475406724d68a30ea57baa00ae3cae99b2ad7c6bb62e3616f6fcc1164b93e52
+  metadata.gz: ed9168cf7e38072e7971ecf38a9550d5a0c30ad27cd2a998e943d8cc7c7211243c94bfd7b475a326e0c1466debe3352b8ed0832de66defb86d57a027adcecd22
+  data.tar.gz: 6fb4f259c4915c9fe4c6edb2223e8ebe8376315c937c31e3f2ffb7a95fcc8afd04ff79382c72efa923d75f5035a71377020c92dc20d642f9efd57bb967b8d135

data/app/models/relation.rb

@@ -5,14 +5,18 @@ class Relation < ActiveRecord::Base
 
 	delegate :name, to: :role, allow_nil: true
 
-	RailsDynamicAssociations.directions.each &-> (association, method) do
+	default_scope {
+		references(:roles).includes :role
+	}
+
+	association_directions.shortcuts.each &-> (association, method) do
 		scope "#{method}_abstract", -> (object = nil) {
 			if object then
-				send method, object
+				send("#{method}_abstract").
+					send method, object
 			else
-				all
-			end.
-				where "#{association}_id"   => nil
+				where "#{association}_id" => nil
+			end
 		}
 
 		scope "#{method}_general", -> {
@@ -22,6 +26,8 @@ class Relation < ActiveRecord::Base
 
 		scope method, -> (object) {
 			case object
+			when nil then
+				# all
 			when Symbol then
 				send "#{method}_#{object}"
 			when Class then
@@ -37,16 +43,34 @@ class Relation < ActiveRecord::Base
 		of_abstract.to_abstract
 	}
 
-	def self.seed source, target, roles = nil
-		(roles.present? ? by_roles(roles) : [ self ]).map do |scope|
-			scope.create source_type: source,
-			             target_type: target
+	scope :applied, -> {
+		where.not source_id: nil,
+		          target_id: nil
+	}
+
+	scope :named, -> (*names) {
+		case names
+		when [[]] then # i.e. `named []`
+			# all
+		when []   then # i.e. `named`
+			where.not role_id: nil
+		else
+			with_roles { named *names }
 		end
+	}
+
+	def self.with_roles &block
+		joins(:role).merge(
+			Role.instance_eval &block
+		).uniq
 	end
 
-	def self.by_roles *names
-		Role.find_or_create_named(*names).
-			map &:relations
+	def self.seed source, target, roles = nil
+		(roles.present? ? Role.find_or_create_named(roles) : [ nil ]).map do |role|
+			create source_type: source,
+			       target_type: target,
+			       role:        role
+		end
 	end
 
 
@@ -55,6 +79,9 @@ class Relation < ActiveRecord::Base
 			Role.find_or_initialize_by(name: role_name)
 	end
 
+	def abstract?
+		not (source_id or target_id)
+	end
 
 	# Using polymorphic associations in combination with single table inheritance (STI) is
 	# a little tricky. In order for the associations to work as expected, ensure that you

data/app/models/role.rb

@@ -8,25 +8,30 @@ class Role < ActiveRecord::Base
 	}
 
 	scope :available, -> {
-		includes(:relations).
-			where relations: { id: Relation.of_abstract } # TODO: simplify
+		with_relations { of_abstract }
 	}
 
 	scope :in, -> (object) {
-		where relations: { id: Relation.to(object) } # TODO: simplify
+		with_relations { to object }
 	}
 
 	scope :for, -> (subject) {
-		where relations: { id: Relation.of(subject) } # TODO: simplify
+		with_relations { of subject }
 	}
 
 	def self.find_or_create_named *names
 		names.flatten!
 		names.compact!
 
-		(existing = named(names)).all +
+		(existing = named(names)).to_a +
 			(names - existing.map(&:name)).map { |name|
 				create name: name
 			}
 	end
+
+	def self.with_relations &block
+		joins(:relations).merge(
+			Relation.instance_eval &block
+		).uniq
+	end
 end

data/config/initializers/helpers.rb

@@ -0,0 +1,5 @@
+ActiveSupport.on_load :active_record do
+	include RailsDynamicAssociations::Config
+	include RailsDynamicAssociations::ActiveRecord::Associations
+	include RailsDynamicAssociations::ActiveRecord::Relations
+end

data/config/initializers/model_associations.rb

@@ -1,5 +1,5 @@
 ActiveSupport.on_load :model_class do
-	for type in RailsDynamicAssociations.directions.keys do
+	for type in association_directions do
 		for relation in send("#{type}_relations").abstract.select(&:"#{type}_type") do
 			setup_relation type, relation.send("#{type}_type").constantize, relation.role
 		end

data/db/migrate/02_create_relations.rb

@@ -1,6 +1,8 @@
 class CreateRelations < ActiveRecord::Migration
 	def change
 		create_table :relations do |t|
+			t.string     :type
+
 			t.references :source, polymorphic: { default: 'User' }
 			t.references :target, polymorphic: true
 			t.references :role
@@ -9,6 +11,6 @@ class CreateRelations < ActiveRecord::Migration
 		end
 
 		add_index :relations, [ :source_id, :source_type, :target_id, :target_type, :role_id ], unique: true,
-		          name: 'index_relations_on_source_and_target_and_role'
+			name: 'index_relations_on_source_and_target_and_role'
 	end
 end

data/lib/rails_dynamic_associations/active_record/associations.rb

@@ -5,13 +5,15 @@ module RailsDynamicAssociations::ActiveRecord
 		extend ActiveSupport::Concern
 
 		module ClassMethods
+			include RailsDynamicAssociations::Config
+
 			protected
 
 			def setup_relation type, target = self, role = nil
 				define_association type, target
 				define_association type, target, role if role
 
-				for association, method in RailsDynamicAssociations.self_referential_recursive do
+				for association, method in association_directions.recursive do
 					define_recursive_methods association, method if association.in? reflections and not method_defined? method
 				end
 			end
@@ -22,7 +24,7 @@ module RailsDynamicAssociations::ActiveRecord
 				:"#{role ? association_name(type, target, role).to_s.singularize : type}_relations".tap do |association|
 					unless association.in? reflections then
 						has_many association, role && -> { where role_id: role.id },
-						         as: (RailsDynamicAssociations.directions.keys - [type]).first, class_name: 'Relation'
+							as: association_directions.opposite(type), class_name: 'Relation'
 					end
 				end
 			end
@@ -30,10 +32,10 @@ module RailsDynamicAssociations::ActiveRecord
 			def define_association type, target = self, role = nil
 				unless (association = association_name(type, target, role)).in? reflections then
 					has_many association,
-					         through:     define_relations_association(type, target, role),
-					         source:      type,
-					         source_type: target.base_class.name,
-					         class_name:  target.name
+						through:     define_relations_association(type, target, role),
+						source:      type,
+						source_type: target.base_class.name,
+						class_name:  target.name
 
 					define_association_with_roles association unless role
 
@@ -77,25 +79,33 @@ module RailsDynamicAssociations::ActiveRecord
 
 			def association_name type, target = self, role = nil
 				if role then
-					if target == self || target <= User then
-						{
-							source: role.name,
-							target: "#{role.name.passivize}_#{target.name.split('::').reverse.join}",
-						}[type]
-					else
-						"#{{
-							source: role.name,
-							target: role.name.passivize,
-						}[type]}_#{association_name type, target}"
-					end
+					association_name_with_role    type, target, role
 				else
-					if target == self then
-						RailsDynamicAssociations.self_referential[type].to_s
-					else
-						target.name.split('::').reverse.join
-					end
+					association_name_without_role type, target
 				end.tableize.to_sym
 			end
+
+			def association_name_with_role type, target, role
+				if target == self or target <= User then
+					{
+						source: role.name,
+						target: "#{role.name.passivize}_#{target.name.split('::').reverse.join}",
+					}[type]
+				else
+					"#{{
+						source: role.name,
+						target: role.name.passivize,
+					}[type]}_#{association_name_without_role type, target}"
+				end
+			end
+
+			def association_name_without_role type, target
+				if target == self then
+					association_directions.selfed[type].to_s
+				else
+					target.name.split('::').reverse.join
+				end
+			end
 		end
 	end
 end

data/lib/rails_dynamic_associations/active_record/relations.rb

@@ -4,12 +4,67 @@ module RailsDynamicAssociations::ActiveRecord
 	module Relations
 		extend ActiveSupport::Concern
 
+		included do
+			extend  ClassAndInstanceMethods
+			include ClassAndInstanceMethods
+		end
+
 		module ClassMethods
-			RailsDynamicAssociations.opposite_directions.each &-> (association, method) do
+			RailsDynamicAssociations::Config.association_directions.opposite_shortcuts.each &-> (association, method) do
 				define_method "#{association}_relations" do
 					Relation.send method, self
 				end
 			end
 		end
+
+		module ClassAndInstanceMethods
+			def relative? args = {}
+				find_relations(args).
+					present?
+			end
+
+			def relatives args = {}
+				find_relations(args).
+					map { |r|
+						# TODO: optimize queries
+						(association_directions.map { |d| r.send d } - [ self ]).first
+					}.uniq
+			end
+
+			protected
+
+			# TODO: use keyword arguments
+			def find_relations args = {}
+				# Rearrange arguments
+				for direction, method in association_directions.shortcuts do
+					args[direction] = args.delete method if
+						method.in? args
+				end
+
+				roles = :as.in?(args) ?
+					[ args[:as] ].flatten :
+					[]
+
+				if direction = association_directions.find { |a| a.in? args } then # direction specified
+					find_relations_with_direction(direction, roles).send(
+						association_directions.shortcuts[direction], args[direction] # apply a filtering scope
+					)
+				else # both directions
+					association_directions.map do |direction|
+						find_relations_with_direction direction, roles
+					end.sum
+				end
+			end
+
+			private
+
+			def find_relations_with_direction direction, roles = []
+				if respond_to? association = "#{direction}_relations" then
+					send(association).named roles
+				else
+					Relation.none
+				end
+			end
+		end
 	end
 end

data/lib/rails_dynamic_associations/active_record.rb

@@ -1,7 +1,6 @@
-require 'rails_dynamic_associations/active_record/associations'
-require 'rails_dynamic_associations/active_record/relations'
-
-ActiveSupport.on_load :active_record do
-	include RailsDynamicAssociations::ActiveRecord::Associations
-	include RailsDynamicAssociations::ActiveRecord::Relations
+module RailsDynamicAssociations
+	module ActiveRecord
+		autoload :Associations, 'rails_dynamic_associations/active_record/associations'
+		autoload :Relations,    'rails_dynamic_associations/active_record/relations'
+	end
 end

data/lib/rails_dynamic_associations/config.rb

@@ -0,0 +1,62 @@
+module RailsDynamicAssociations
+	module Config
+		module Naming
+			def shortcuts
+				config :shortcut
+			end
+
+			def selfed
+				config :selfed
+			end
+
+			def recursive
+				config.each_with_object({}) do |(key, value), hash|
+					hash[
+						value[:selfed].to_s.pluralize.to_sym
+					] = value[:recursive]
+				end
+			end
+
+			def opposite direction
+				find { |d| d != direction }
+			end
+
+			def opposite_shortcuts
+				shortcuts.each_with_object({}) do |(key, value), hash|
+					hash[key] = shortcuts.values.find do |v|
+						v != value
+					end
+				end
+			end
+
+			private
+
+			def config section = nil
+				if section
+					config.each_with_object({}) do |(key, value), hash|
+						hash[key] = value[section]
+					end
+				else
+					Config.association_names[:directions] # TODO: DRY
+				end
+			end
+		end
+
+		private
+
+		module_function
+
+		def association_names
+			Engine.config.names
+		end
+
+		def association_directions
+			@association_directions ||=
+				association_names[:directions].keys.tap do |directions|
+					class << directions
+						include Naming
+					end
+				end
+		end
+	end
+end

data/lib/rails_dynamic_associations/engine.rb

@@ -1,5 +1,20 @@
 module RailsDynamicAssociations
 	class Engine < ::Rails::Engine
 		isolate_namespace RailsDynamicAssociations
+
+		config.names = {
+			directions: {
+				source: {
+					shortcut:  :of,
+					selfed:    :child,
+					recursive: :descendants,
+				},
+				target: {
+					shortcut:  :to,
+					selfed:    :parent,
+					recursive: :ancestors,
+				},
+			},
+		}
 	end
 end

data/lib/rails_dynamic_associations/version.rb

@@ -1,3 +1,3 @@
 module RailsDynamicAssociations
-	VERSION = '0.2.0.real'
+	VERSION = '0.2.1.real'
 end

data/lib/rails_dynamic_associations.rb

@@ -4,32 +4,6 @@ require 'rails_dynamic_associations/engine'
 require 'core_ext/string'
 
 module RailsDynamicAssociations
-	mattr_accessor :directions,
-	               :self_referential,
-	               :self_referential_recursive
-
-	self.directions = {
-		source: :of,
-		target: :to,
-	}
-
-	self.self_referential = {
-		source: :child,
-		target: :parent,
-	}
-
-	self.self_referential_recursive = {
-		parents:  :ancestors,
-		children: :descendants,
-	}
-
-	def self.opposite_directions
-		directions.each_with_object({}) do |(key, value), hash|
-			hash[key] = directions.values.find do |v|
-				v != value
-			end
-		end
-	end
+	autoload :Config,       'rails_dynamic_associations/config'
+	autoload :ActiveRecord, 'rails_dynamic_associations/active_record'
 end
-
-require 'rails_dynamic_associations/active_record'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_dynamic_associations
 version: !ruby/object:Gem::Version
-  version: 0.2.0.real
+  version: 0.2.1.real
 platform: ruby
 authors:
 - Alexander Senko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-04 00:00:00.000000000 Z
+date: 2015-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -65,6 +65,7 @@ files:
 - Rakefile
 - app/models/relation.rb
 - app/models/role.rb
+- config/initializers/helpers.rb
 - config/initializers/model_associations.rb
 - db/migrate/01_create_roles.rb
 - db/migrate/02_create_relations.rb
@@ -73,6 +74,7 @@ files:
 - lib/rails_dynamic_associations/active_record.rb
 - lib/rails_dynamic_associations/active_record/associations.rb
 - lib/rails_dynamic_associations/active_record/relations.rb
+- lib/rails_dynamic_associations/config.rb
 - lib/rails_dynamic_associations/engine.rb
 - lib/rails_dynamic_associations/version.rb
 - lib/tasks/rails_dynamic_associations_tasks.rake