adjustable_schema 0.7.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f44c8a85801250e7f4d0e26af1984a77f7e59d0d0f31f416e8d55343fdefb94a
-  data.tar.gz: fd68da65c3953097520bd12263924482d11330b7862c5bb7cf4aeffef972ecc8
+  metadata.gz: 3b1390e4f564f54d0e8a840fae882bf7a494b51323846ab06e05a786c332fc37
+  data.tar.gz: 5458b1a98b4b3a3dea0c3a8e2cd66e42003683cbbd4af95c939af8fe1810ce34
 SHA512:
-  metadata.gz: 05bc3d492e1794d4549668cf853b07fc824b5285fb6062287f11875ba8d408f1f2c1fc9fcaa26becd797ee04e9ed1c9ed997a4a998eb21dc70ba77486a1725e3
-  data.tar.gz: 44e8c6b9fef8f06d4bedd14213ae08a62e425825fe3a30c6843117c1d1b2e4cabbd66ec00e2bef5b5fb9ab1bd7e4e3696e3e784b24a62832bab66ee2d54d6b4b
+  metadata.gz: dee15ab2468fca2b6bf3739df1b65508dd80ae87830833d27895e05a21c59392e3856ffbd78742cc0c067bfd1db66b364a880f0bf5401a3a3cc5cac2879ec59e
+  data.tar.gz: 984449dfcba1f1797830b5153439d2873187b0fe32aaefe23cb21bab76b49f49906f70dc562eacb92653a531eb828c262449bf41a71b4507782de25ac38214d0

data/CHANGELOG.md

@@ -0,0 +1,124 @@
+## [0.9.0] — 2025-03-10
+
+### Changed
+
+- Requires Rails 8 and Ruby 3.4+.
+- Protected `AdjustableSchema::Relationship::Role` from being deleted when used.
+
+### Added
+
+- `Relationship#sourced` and `Relationship#targeted` scopes to filter relationships by presence of _source_ and _target_ records respectively.
+
+### Fixed
+
+- `Relationship#applied` scope used to return relationships with at least one record attached, instead of ones with both records present.
+
+
+## [0.8.0] — 2024-11-08
+
+### Changed
+
+- Renamed checks for related records:
+	`<associat>ful` form is now used instead of a passive one (`<associat>ed`) to check for related records’ presence.
+	- `.<associat>ful` — scope records having associated ones.
+	- `#<associat>ful?` — are there any records associated?
+- Naming: improved passive forms for words ending with `or`/`ant`/`ion`/`ment`/`ing`.
+
+### Added
+
+- Checks for related records’ presence on roleless recursive associations:
+	- `.<associat>ful` —
+		records having associated ones;
+	- `.<association>less` —
+		records not having associated ones;
+	- `#<associat>ful?` —
+		if there are records associated;
+	- `#<association>less?` —
+		if there are no records associated;
+	- `#intermediate?` —
+		whether is only one child record associated (_Is the node just a link between two other nodes like?_);
+	- `#branching?` —
+		whether are several child records associated.
+
+### Fixed
+
+- Naming: passive form for `author`.
+
+
+## [0.7.2] — 2024-04-02
+
+### Fixed
+
+- `roleless` scope used to generate wrong queries.
+
+
+## [0.7.1] — 2024-03-31
+
+### Fixed
+
+- DB constraints:
+	- `roles.name` is `NOT NULL`,
+	- `UNIQUE` constraints should treat `NULLS` as `NOT DISTINCT`.
+- Roleless recursive associations used to fail on `joins`.
+
+
+## [0.7.0] — 2024-02-25
+
+### Changed
+
+- Naming: improved passive forms a bit.
+- Configuration: renamed `self_related` to `self`.
+
+### Added
+
+- Checks for related records’ presence:
+	- `.<associat>ed` —
+		records having associated ones;
+	- `.<association>less` —
+		records not having associated ones;
+	- `#<associat>ed?` —
+		if there are records associated;
+	- `#<association>less?` —
+		if there are no records associated.
+- Documentation: self-targeted relationships in README.
+
+### Fixed
+
+- Documentation: examples in the README.
+
+
+## [0.6.0] — 2024-02-20
+
+### Changed
+
+- Destroy orphaned relationships of an object on destroy.
+- Symbolize configurable names used for associations, methods, etc.
+- Raise `ArgumentError` for unknown names passed to the API.
+
+### Added
+
+- `Relationship[]` to filter relationships by related objects/classes.
+- `Role[]` accepts `Hash`-like parameters to filter roles by relationships.
+- Methods for related records:
+	- `related?` to check for related objects,
+	- `related` to fetch them,
+	- and the basic `relationships`.
+- Recursive methods for related records:
+	- flat `ancestors` & `descendants` with distance,
+	- based on `recursive` association scope.
+- `roleless` scope for related records without a role.
+- A dedicated association for roleless children.
+
+### Fixed
+
+- Faulty scopes in role-based relationship associations.
+- Naming for namespaced models, e.g., in Rails Engines.
+
+
+## [0.5.0] — 2023-12-29
+
+Refactored from [Rails Dynamic Associations](
+	https://github.com/Alexander-Senko/rails_dynamic_associations
+).
+
+Some experimental features are missing and can be found in the `api` branch.

data/README.md

@@ -75,7 +75,7 @@ It includes `User` by default.
 
 ##### Self-referencing models
 
-You may want to set up self-targeted relationships:
+You may want to set up recursive relationships:
 
 ``` ruby
 AdjustableSchema::Relationship.seed! Person, roles: %w[friend]
@@ -100,7 +100,7 @@ AdjustableSchema::Engine.configure do
 end
 ```
 
-Thus, for the self-referenced `Event`s, you'll get:
+Thus, for hierarchical `Event`s, you'll get:
 
 ``` ruby
 event.causes

data/Rakefile

@@ -1,8 +1,10 @@
-require "bundler/setup"
+# frozen_string_literal: true
 
-APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
-load "rails/tasks/engine.rake"
+require 'bundler/setup'
 
-load "rails/tasks/statistics.rake"
+APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
 
-require "bundler/gem_tasks"
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/app/models/adjustable_schema/application_record.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module AdjustableSchema
-  class ApplicationRecord < ::ActiveRecord::Base
-    self.abstract_class = true
-  end
+	class ApplicationRecord < ::ActiveRecord::Base # :nodoc:
+		self.abstract_class = true
+	end
 end

data/app/models/adjustable_schema/relationship/role.rb

@@ -1,9 +1,16 @@
+# frozen_string_literal: true
+
 module AdjustableSchema
 	class Relationship
+		# = Relationship roles
+		#
+		# `AdjustableSchema::Relationship::Role` serves to distinguish
+		# between several associations of the same pair of models.
 		class Role < ApplicationRecord
 			include Organizer::Identifiable.by :name, symbolized: true
 
-			has_many :relationships
+			has_many :relationships,
+					dependent: :restrict_with_exception
 
 			validates :name, presence: true, uniqueness: true
 

data/app/models/adjustable_schema/relationship.rb

@@ -1,4 +1,29 @@
+# frozen_string_literal: true
+
 module AdjustableSchema
+	# = Relationships
+	#
+	# `Relationship` is a core class of Adjustable Schema representing both
+	# associations of model classes and connections of individual records.
+	#
+	# No constraints are supported yet, so only many-to-many associations
+	# are available for now.
+	#
+	# == Model associations
+	#
+	# To represent an association, a `Relationship` record should have both
+	# `source_type` and `target_type` columns set, with both ID columns set
+	# to `NULL`.
+	#
+	# == Record relationships
+	#
+	# To connect individual records, both `source` and `target` polymorphic
+	# associations shoud be set.
+	#
+	# == Roles
+	#
+	# Many associations with different semantics between the same models
+	# can be set using roles (see `Relationship::Role`).
 	class Relationship < ApplicationRecord
 		belongs_to :source, polymorphic: true, optional: true
 		belongs_to :target, polymorphic: true, optional: true
@@ -8,14 +33,14 @@ module AdjustableSchema
 			includes :role
 		end
 
-		Config.shortcuts.each &-> ((association, method)) do
+		Config.shortcuts.each &-> ((association, method)) do # rubocop:disable Style
 			scope method, -> object {
 				case object
 				when ::ActiveRecord::Base, nil
 					where association => object
 				when Class
 					where "#{association}_type" => object.ancestors
-							.select { _1 <= object.base_class }
+							.grep(..object.base_class)
 							.map(&:name)
 				when ::ActiveRecord::Relation
 					send(method, object.klass)
@@ -29,8 +54,7 @@ module AdjustableSchema
 
 			scope "#{method}_abstract", -> object = nil {
 				if object
-					send(__method__).
-							send method, object
+					send(__method__).send method, object
 				else
 					where "#{association}_id" => nil
 				end
@@ -39,20 +63,14 @@ module AdjustableSchema
 
 		scope :abstract, -> {
 			Config.shortcuts.values
-					.map { send _1, :abstract }
+					.map { send it, :abstract }
 					.reduce &:merge
 		}
 
-		scope :general, -> {
-			where target: nil
-		}
-
-		scope :applied, -> {
-			where.not(
-					source: nil,
-					target: nil,
-			)
-		}
+		scope :general,  -> { where     target: nil }
+		scope :sourced,  -> { where.not source: nil }
+		scope :targeted, -> { where.not target: nil }
+		scope :applied,  -> { sourced.targeted }
 
 		scope :named, -> *names {
 			case names
@@ -74,15 +92,15 @@ module AdjustableSchema
 			def [] **scopes
 				scopes
 						.map do
-							self
+							self # rubocop:disable Style
 									.send(Config.shortcuts[:source], _1)
 									.send(Config.shortcuts[:target], _2)
 						end
 						.reduce &:or
 			end
 
-			def seed! *models, roles: [], **_models
-				return seed!({ **Hash[*models], **_models }, roles:) if _models.any? # support keyword arguments syntax
+			def seed! *models, roles: [], **mapping # rubocop:disable Metrics
+				return seed!({ **Hash[*models], **mapping }, roles:) if mapping.any? # support keyword arguments syntax
 
 				case models
 				in [
@@ -91,7 +109,7 @@ module AdjustableSchema
 				]
 					roles
 							.map { |name| Role.find_or_create_by! name: }
-							.then { _1.presence or [ nil ] } # no roles => nameless relationship
+							.then { it.presence or [ nil ] } # no roles => nameless relationship
 							.map { |role| create! source_type:, target_type:, role: }
 				in [ Hash => models ]
 					for sources, targets in models do
@@ -100,7 +118,7 @@ module AdjustableSchema
 						end
 					end
 				in [ Class => source ]
-					seed! source, source, roles: # self-related
+					seed! source, source, roles: # recursive
 				end
 			end
 		end
@@ -122,7 +140,7 @@ module AdjustableSchema
 		# https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Polymorphic+Associations
 		reflections
 				.values
-				.select { _1.options[:polymorphic] }
+				.select { it.options[:polymorphic] }
 				.each do |reflection|
 					define_method "#{reflection.name}_type=" do |type|
 						super type && type.to_s.classify.constantize.base_class.to_s

data/app/models/concerns/adjustable_schema/active_record/associations.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module AdjustableSchema
-	module ActiveRecord
+	module ActiveRecord # :nodoc:
 		concern :Associations do
 			class_methods do
 				private

data/app/models/concerns/adjustable_schema/active_record/relationships.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require 'memery'
 
 module AdjustableSchema
-	module ActiveRecord
+	module ActiveRecord # :nodoc:
 		concern :Relationships do
 			class_methods do
 				include Memery
 
 				memoize def relationships
-					Config.association_directions.to_h do
-						[ _1, Relationship.abstract.send(Config.shortcuts.opposite[_1], self) ]
+					Config.association_directions.index_with do
+						Relationship.abstract.send Config.shortcuts.opposite[it], self
 					end
 				end
 
@@ -44,20 +46,20 @@ module AdjustableSchema
 							.preload(Config.association_directions)
 							.map do |relationship|
 								Config.association_directions
-										.map { relationship.send _1 } # both objects
+										.map { relationship.send it } # both objects
 										.without(self) # the related one
-										.first or self # may be self-related
+										.first or self # may be recursive
 							end
 							.uniq
 				end
 
-				def relationships **options
-					if (direction, scope = Config.find_direction **options) # filter by direction & related objects
+				def relationships(...)
+					if (direction, scope = Config.find_direction(...)) # filter by direction & related objects
 						relationships_to(direction)
 								.send Config.shortcuts[direction], scope
 					else # all in both directions
 						Config.association_directions
-								.map { relationships_to _1 }
+								.map { relationships_to it }
 								.reduce(&:or)
 					end
 				end

data/config/initializers/associations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ActiveSupport.on_load :model_class do
 	next if     self == AdjustableSchema::Relationship
 	next unless AdjustableSchema.available?

data/config/initializers/model_names.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # HACK: non-public Rails API used
 ActiveModel::Name.class_eval do
 	def unnamespaced = @unnamespaced || name

data/db/migrate/01_create_adjustable_schema_relationship_tables.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CreateAdjustableSchemaRelationshipTables < ActiveRecord::Migration[7.1]
 	def change
 		# Use Active Record's configured type for primary and foreign keys
@@ -22,13 +24,13 @@ class CreateAdjustableSchemaRelationshipTables < ActiveRecord::Migration[7.1]
 					target_id target_type
 					role_id
 			].tap { |columns|
-				columns.reject! { _1.ends_with? '_type' } if foreign_key_type == :uuid # OPTIMIZATION: IDs are unique
+				columns.reject! { it.ends_with? '_type' } if foreign_key_type == :uuid # OPTIMIZATION: IDs are unique
 
 				# NULLS are DISTINCT by default.
 				# One can use `ADD CONSTRAINT … UNIQUE NULLS NOT DISTINCT (…)` instead
 				t.index columns,
 						unique: true, where: 'role_id IS NOT NULL', name: :index_adjustable_schema_relationships_uniqueness_with_role
-				t.index columns.excluding(:role_id),
+				t.index columns.without(:role_id),
 						unique: true, where: 'role_id IS     NULL', name: :index_adjustable_schema_relationships_uniqueness_without_role
 			}
 		end

data/lib/adjustable_schema/active_record/association/hierarchy.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module AdjustableSchema
+	module ActiveRecord
+		module Association::Hierarchy # :nodoc:
+			private
+
+			def scopes
+				name = roleless_name # save the context
+
+				{
+						**super,
+
+						name_for_any( target_name) => -> { where.associated name },
+						name_for_none(target_name) => -> { where.missing    name },
+				}
+			end
+
+			def flags
+				name = roleless_name # save the context
+
+				{
+						**super,
+
+						name_for_any( target_name) => -> { send(name).any?  },
+						name_for_none(target_name) => -> { send(name).none? },
+						intermediate:                 -> { send(name).one?  },
+						branching:                    -> { send(name).many? },
+				}
+			end
+		end
+	end
+end

data/lib/adjustable_schema/active_record/association/naming.rb

@@ -1,30 +1,63 @@
+# frozen_string_literal: true
+
 require 'memery'
 
 module AdjustableSchema
 	module ActiveRecord
-		class Association
+		class Association # :nodoc:
 			concerning :Naming do
 				include Memery
 
-				module Inflections
+				module Inflections # :nodoc:
 					refine String do
 						def passivize
-							self
-									.sub(/(author)$/, '\\2ed')
-									.sub(/(e*|ed|ing|[eo]r|ant|(t)ion)$/, '\\2ed')
+							presence
+									&.sub(/((:?[aeiou]+[^aeiou]+){2,})(?:or|ant|ion|e?ment)$/, '\1ed')
+									&.sub(/((:?[aeiou]+[^aeiou]+){1,})(?:ing)$/,               '\1ed')
+									&.sub(/(?:e*|ed|er)$/,                                     '\1ed')
+									.to_s
 						end
 					end
 				end
 
 				using Inflections
 
-				memoize def name
-					(role ? name_with_role : name_without_role)
+				module Recursive # :nodoc:
+					include Memery
+
+					memoize def name_with_role = {
+							source: role.name,
+							target: "#{role.name.passivize}_#{target_name}",
+					}[direction]
+
+					def name_without_role
+						Config.association_directions
+								.self[direction]
+								.to_s
+					end
+				end
+
+				def initialize(...)
+					super
+
+					extend Recursive if recursive?
+				end
+
+				memoize def name name = object_name
+					name
 							.to_s
 							.tableize
 							.to_sym
 				end
 
+				def object_name
+					if role
+						name_with_role
+					else
+						name_without_role
+					end
+				end
+
 				memoize def target_name
 					target.model_name.unnamespaced
 							.split('::')
@@ -37,31 +70,17 @@ module AdjustableSchema
 
 				private
 
-				memoize def name_with_role
-					if recursive?
-						{
-								source: role.name,
-								target: "#{role.name.passivize}_#{target_name}",
-						}[direction]
-					else
-						"#{{
-								source: role.name,
-								target: role.name.passivize,
-						}[direction]}_#{target_name}"
-					end
-				end
+				memoize def name_with_role = "#{{
+						source: role.name,
+						target: role.name.passivize,
+				}[direction]}_#{target_name}"
 
-				memoize def name_without_role
-					if recursive?
-						Config.association_directions
-								.self[direction]
-					else
-						target_name
-					end
-				end
+				def name_without_role = target_name
+
+				def roleless_name = name(target_name)
 
-				def name_for_any  = :"#{name.to_s.singularize.passivize}"
-				def name_for_none = :"#{name.to_s.singularize}less"
+				def name_for_any (name = object_name) = :"#{name}ful"
+				def name_for_none(name = object_name) = :"#{name}less"
 			end
 		end
 	end

data/lib/adjustable_schema/active_record/association/roleless.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module AdjustableSchema
+	module ActiveRecord
+		module Association::Roleless # :nodoc:
+			def define
+				super
+
+				has_many roleless_name, -> { roleless }, **options if
+						child?
+			end
+
+			private
+
+			def define_methods
+				super
+
+				name = self.name # save the context
+
+				owner.redefine_method "#{name}_with_roles" do |*roles|
+					send(name)
+							.merge Relationship.named *roles
+				end
+			end
+		end
+	end
+end

data/lib/adjustable_schema/active_record/association/scopes.rb

@@ -1,39 +1,40 @@
+# frozen_string_literal: true
+
 module AdjustableSchema
 	module ActiveRecord
 		module Association::Scopes
-			concern :Recursive do
-				require_relative '../query_methods'
-
-				included do
-					::ActiveRecord::QueryMethods.prepend QueryMethods # HACK: to bring `with.recursive` in
-				end
+			module Recursive # :nodoc:
+				# rubocop:disable Layout
 
 				def recursive
-					all._exec_scope do
-						all
-								.select(
-										select_values = self.select_values.presence || arel_table[Arel.star],
-										Arel.sql('1').as('distance'),
-								)
-								.with.recursive(recursive_table.name => unscoped
-										.select(
-												select_values,
-												(recursive_table[:distance] + 1).as('distance'),
-										)
-										.joins(inverse_association_name)
-										.arel
-										.join(recursive_table)
-												.on(recursive_table[primary_key].eq inverse_table[primary_key])
-								)
-								.unscope(:select, :joins, :where)
-								.from(recursive_table.alias table_name)
-								.distinct
-										.unscope(:order) # for SELECT DISTINCT, ORDER BY expressions must appear in select list
-					end
+					with_recursive(recursive_table.name => [ recursion_base, recursive_step ])
+							.unscope(:select, :joins, :where)
+							.from(recursive_table.alias table_name)
+							.distinct
+									.unscope(:order) # for SELECT DISTINCT, ORDER BY expressions must appear in select list
 				end
 
 				private
 
+				def recursion_base
+					unscope(:order, :group, :having)
+							.select(recursive_select_values,
+									Arel.sql('1').as('distance'),
+							)
+				end
+
+				def recursive_step
+					unscoped
+							.select(recursive_select_values,
+									(recursive_table[:distance] + 1).as('distance'),
+							)
+							.joins(inverse_association_name)
+							.joins(<<~SQL.squish)
+								JOIN #{recursive_table.name}
+									ON #{recursive_table.name}.#{primary_key} = #{inverse_table.name}.#{primary_key}
+							SQL
+				end
+
 				def association_name = @association.reflection.name
 
 				def inverse_association_name
@@ -46,6 +47,8 @@ module AdjustableSchema
 
 				def recursive_table = Arel::Table.new [ :recursive, association_name, klass.table_name ] * '_'
 				def   inverse_table = Arel::Table.new [     inverse_association_name, klass.table_name ] * '_' # HACK: depends on ActiveRecord internals
+
+				def recursive_select_values = select_values.presence || arel_table[Arel.star]
 			end
 		end
 	end

data/lib/adjustable_schema/active_record/association.rb

@@ -1,38 +1,49 @@
+# frozen_string_literal: true
+
+require 'memery'
+
 module AdjustableSchema
 	module ActiveRecord
-		class Association < Struct.new(:owner, :direction, :target, :role)
+		# rubocop:disable Style/StructInheritance
+		class Association < Struct.new( # :nodoc:
+				:owner,
+				:direction,
+				:target,
+				:role,
+		)
 			require_relative 'association/naming'
 			require_relative 'association/scopes'
+			require_relative 'association/roleless'
+			require_relative 'association/hierarchy'
+
+			include Memery
+
+			def initialize(...)
+				super
+
+				extend Roleless  if roleless?
+				extend Hierarchy if hierarchy?
+			end
 
 			def define
-				name.tap do |association_name|
-					association = self # save context
-
-					has_many association_name, **(options = {
-							through:     define_relationships,
-							source:      direction,
-							source_type: target.base_class.name,
-							class_name:  target.name
-					}) do
-						include Scopes
-						include Scopes::Recursive if association.recursive?
-					end
-
-					define_scopes
-					define_methods
-
-					unless role
-						# HACK: using `try` to overcome a Rails bug
-						# (see https://github.com/rails/rails/issues/40109)
-						has_many target_name.tableize.to_sym, -> { try :roleless }, **options if
-								recursive?
-
-						define_role_methods
-					end
+				association = self # save the context
+
+				has_many name, **options do
+					include Scopes
+					include Scopes::Recursive if association.recursive?
 				end
+
+				define_scopes
+				define_methods
 			end
 
 			def recursive? = target == owner
+			def roleless?  = !role
+			def source?    = direction == :source
+			def target?    = direction == :target
+			def child?     = (recursive? and source?)
+			def parent?    = (recursive? and target?)
+			def hierarchy? = (child? and roleless?)
 
 			private
 
@@ -46,42 +57,48 @@ module AdjustableSchema
 			end
 
 			def define_scopes
-				name = relationships_name
-
-				{
-						name_for_any  => -> { where.associated name },
-						name_for_none => -> { where.missing    name },
-				}
+				scopes
 						.reject { owner.singleton_class.method_defined? _1 }
 						.each   { owner.scope _1, _2 }
 			end
 
 			def define_methods
-				name = self.name
-
-				{
-						name_for_any  => -> { send(name).any?  },
-						name_for_none => -> { send(name).none? },
-				}
-						.transform_keys {"#{_1}?" }
+				flags
+						.transform_keys { :"#{it}?" }
 						.reject { owner.method_defined? _1 }
 						.each   { owner.define_method _1, &_2 }
 			end
 
-			def define_role_methods
-				name = self.name
-
-				owner.redefine_method "#{name}_with_roles" do |*roles|
-					send(name)
-							.merge Relationship.named *roles
-				end
-			end
-
 			def has_many(association_name, ...)
 				return if owner.reflect_on_association association_name
 
 				owner.has_many(association_name, ...)
 			end
+
+			def scopes
+				name = relationships_name # save the context
+
+				{
+						name_for_any  => -> { where.associated name },
+						name_for_none => -> { where.missing    name },
+				}
+			end
+
+			def flags
+				name = self.name # save the context
+
+				{
+						name_for_any  => -> { send(name).any?  },
+						name_for_none => -> { send(name).none? },
+				}
+			end
+
+			memoize def options = {
+					through:     define_relationships,
+					source:      direction,
+					source_type: target.base_class.name,
+					class_name:  target.name,
+			}
 		end
 	end
 end

data/lib/adjustable_schema/active_record.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module AdjustableSchema
-	module ActiveRecord
+	module ActiveRecord # :nodoc:
 		autoload :Association, 'adjustable_schema/active_record/association'
 
 		ActiveSupport.on_load :active_record do

data/lib/adjustable_schema/authors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Gem::Author ||= Struct.new(
 		:name,
 		:email,
@@ -11,5 +13,5 @@ module AdjustableSchema
 					email:      'Alexander.Senko@gmail.com',
 					github_url: 'https://github.com/Alexander-Senko',
 			),
-	]
+	].freeze
 end

data/lib/adjustable_schema/config.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 require 'memery'
 
 module AdjustableSchema
-	module Config
+	module Config # :nodoc:
 		include Memery
 
-		module Naming
+		module Naming # :nodoc:
 			include Memery
 
 			memoize def shortcuts
 				config(:shortcut).tap do |shortcuts|
 					def shortcuts.opposite to: nil
 						if to
-							values.reject { _1 == to }.sole
+							values.grep_v(to).sole
 						else
-							transform_values { opposite to: _1 }
+							transform_values { opposite to: it }
 						end
 					end
 				end
@@ -23,19 +25,19 @@ module AdjustableSchema
 
 			def recursive
 				config.values.to_h do
-					[ _1[:self].to_s.pluralize.to_sym, _1[:recursive].to_sym ]
+					[ it[:self].to_s.pluralize.to_sym, it[:recursive].to_sym ]
 				end
 			end
 
 			def opposite to:
-				reject { _1 == to }.sole
+				grep_v(to).sole
 			end
 
 			private
 
 			def config section = nil
 				if section
-					config.transform_values { _1[section].to_sym }
+					config.transform_values { it[section].to_sym }
 				else
 					Config.association_names # TODO: DRY
 				end
@@ -64,14 +66,11 @@ module AdjustableSchema
 			module_function method
 		end
 
-		private
-		module_function
-
 		def association_names = Engine.config.names[:associations]
 
 		def normalize **options
 			shortcuts
-					.tap { options.assert_valid_keys _1.keys, _1.values }
+					.tap { options.assert_valid_keys it.keys, it.values }
 					.select { _2.in? options }
 					.each { options[_1] = options.delete _2 }
 

data/lib/adjustable_schema/engine.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'organizer'
 
 module AdjustableSchema
-	class Engine < ::Rails::Engine
+	class Engine < ::Rails::Engine # :nodoc:
 		isolate_namespace AdjustableSchema
 
 		config.names = {

data/lib/adjustable_schema/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdjustableSchema
-	VERSION = '0.7.2'
+	VERSION = '0.9.0'
 end

data/lib/adjustable_schema.rb

@@ -1,10 +1,12 @@
-require "adjustable_schema/version"
-require "adjustable_schema/engine"
+# frozen_string_literal: true
+
+require 'adjustable_schema/version'
+require 'adjustable_schema/engine'
 require 'adjustable_schema/active_record'
 
 require 'rails_model_load_hook' # should be loaded
 
-module AdjustableSchema
+module AdjustableSchema # :nodoc:
 	autoload :Config, 'adjustable_schema/config'
 
 	module_function

data/lib/tasks/adjustable_schema_tasks.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # desc "Explaining what the task does"
 # task :adjustable_schema do
 #   # Task goes here

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: adjustable_schema
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.9.0
 platform: ruby
 authors:
 - Alexander Senko
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-02 00:00:00.000000000 Z
+date: 2025-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.0'
 - !ruby/object:Gem::Dependency
   name: rails_model_load_hook
   requirement: !ruby/object:Gem::Requirement
@@ -78,28 +77,21 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- app/assets/config/adjustable_schema_manifest.js
-- app/assets/stylesheets/adjustable_schema/application.css
-- app/controllers/adjustable_schema/application_controller.rb
-- app/helpers/adjustable_schema/application_helper.rb
-- app/jobs/adjustable_schema/application_job.rb
-- app/mailers/adjustable_schema/application_mailer.rb
 - app/models/adjustable_schema/application_record.rb
 - app/models/adjustable_schema/relationship.rb
 - app/models/adjustable_schema/relationship/role.rb
 - app/models/concerns/adjustable_schema/active_record/associations.rb
 - app/models/concerns/adjustable_schema/active_record/relationships.rb
-- app/views/layouts/adjustable_schema/application.html.erb
 - config/initializers/associations.rb
 - config/initializers/model_names.rb
-- config/routes.rb
 - db/migrate/01_create_adjustable_schema_relationship_tables.rb
 - lib/adjustable_schema.rb
 - lib/adjustable_schema/active_record.rb
 - lib/adjustable_schema/active_record/association.rb
+- lib/adjustable_schema/active_record/association/hierarchy.rb
 - lib/adjustable_schema/active_record/association/naming.rb
+- lib/adjustable_schema/active_record/association/roleless.rb
 - lib/adjustable_schema/active_record/association/scopes.rb
-- lib/adjustable_schema/active_record/query_methods.rb
 - lib/adjustable_schema/authors.rb
 - lib/adjustable_schema/config.rb
 - lib/adjustable_schema/engine.rb
@@ -111,8 +103,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/Alexander-Senko/adjustable_schema
   source_code_uri: https://github.com/Alexander-Senko/adjustable_schema
-  changelog_uri: https://github.com/Alexander-Senko/adjustable_schema/blob/v0.7.2/CHANGELOG.md
-post_install_message:
+  changelog_uri: https://github.com/Alexander-Senko/adjustable_schema/blob/v0.9.0/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -120,15 +111,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
-signing_key:
+rubygems_version: 3.6.5
 specification_version: 4
 summary: Adjustable data schemas for Rails
 test_files: []

data/app/assets/config/adjustable_schema_manifest.js

@@ -1 +0,0 @@
-//= link_directory ../stylesheets/adjustable_schema .css

data/app/assets/stylesheets/adjustable_schema/application.css

@@ -1,15 +0,0 @@
-/*
- * This is a manifest file that'll be compiled into application.css, which will include all the files
- * listed below.
- *
- * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
- * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
- *
- * You're free to add application-wide styles to this file and they'll appear at the bottom of the
- * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
- * files in this directory. Styles in this file should be added after the last require_* statement.
- * It is generally better to create a new file per style scope.
- *
- *= require_tree .
- *= require_self
- */

data/app/controllers/adjustable_schema/application_controller.rb

@@ -1,4 +0,0 @@
-module AdjustableSchema
-  class ApplicationController < ActionController::Base
-  end
-end

data/app/helpers/adjustable_schema/application_helper.rb

@@ -1,4 +0,0 @@
-module AdjustableSchema
-  module ApplicationHelper
-  end
-end

data/app/jobs/adjustable_schema/application_job.rb

@@ -1,4 +0,0 @@
-module AdjustableSchema
-  class ApplicationJob < ActiveJob::Base
-  end
-end

data/app/mailers/adjustable_schema/application_mailer.rb

@@ -1,6 +0,0 @@
-module AdjustableSchema
-  class ApplicationMailer < ActionMailer::Base
-    default from: "from@example.com"
-    layout "mailer"
-  end
-end

data/app/views/layouts/adjustable_schema/application.html.erb

@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Adjustable schema</title>
-  <%= csrf_meta_tags %>
-  <%= csp_meta_tag %>
-
-  <%= stylesheet_link_tag    "adjustable_schema/application", media: "all" %>
-</head>
-<body>
-
-<%= yield %>
-
-</body>
-</html>

data/config/routes.rb

@@ -1,2 +0,0 @@
-AdjustableSchema::Engine.routes.draw do
-end

data/lib/adjustable_schema/active_record/query_methods.rb

@@ -1,103 +0,0 @@
-module AdjustableSchema
-	module ActiveRecord
-		module QueryMethods
-			class WithChain
-				def initialize scope
-					@scope = scope
-				end
-
-				# Returns a new relation expressing WITH RECURSIVE statement.
-				#
-				# #recursive accepts conditions as a hash. See QueryMethods#with for
-				# more details on each format.
-				#
-				#    User.with.recursive(
-				#      descendants: User.joins('INNER JOIN descendants ON users.parent_id = descendants.id')
-				#    )
-				#    # WITH RECURSIVE descendants AS (
-				#    #   SELECT * FROM users
-				#    #   UNION
-				#    #   SELECT * FROM users INNER JOIN descendants ON users.parent_id = descendants.id
-				#    # ) SELECT * FROM descendants
-				#
-				# WARNING! Due to how Arel works,
-				#  * `recursive` can't be chained with any prior non-recursive calls to `with` and
-				#  * all subsequent non-recursive calls to `with` will be treated as recursive ones.
-				def recursive *args
-					args.map! do
-						next _1 unless _1.is_a? Hash
-
-						_1
-								.map(&method(:with_recursive_union))
-								.to_h
-					end
-
-					case @scope.with_values
-					in []
-						@scope = @scope.with :recursive, *args
-					in [ :recursive, * ]
-						@scope = @scope.with *args
-					else
-						raise ArgumentError, "can't chain `WITH RECURSIVE` with non-recursive one"
-					end
-
-					@scope
-				end
-
-				private
-
-				def with_recursive_union name, scope
-					scope = scope.arel if scope.respond_to? :arel
-
-					[
-							name,
-							@scope
-									.unscope(:order, :group, :having)
-									.arel
-									.union(scope)
-					]
-				end
-			end
-
-			def with *args
-				if args.empty?
-					WithChain.new spawn
-				else
-					super
-				end
-			end
-
-			private
-
-			# OVERWRITE: allow a Symbol to be passes as the first argument
-			def build_with(arel)
-				return if with_values.empty?
-
-				with_statements = with_values.map.with_index do |with_value, i|
-					next with_value if with_value.is_a? Symbol and i == 0
-
-					raise ArgumentError, "Unsupported argument type: #{with_value} #{with_value.class}" unless with_value.is_a?(Hash)
-
-					build_with_value_from_hash(with_value)
-				end
-
-				arel.with(*with_statements)
-			end
-
-			# OVERWRITE: allow Arel Nodes
-			def build_with_value_from_hash(hash)
-				hash.map do |name, value|
-					expression =
-							case value
-							when Arel::Nodes::SqlLiteral then Arel::Nodes::Grouping.new(value)
-							when ::ActiveRecord::Relation then value.arel
-							when Arel::SelectManager, Arel::Nodes::Node then value
-							else
-								raise ArgumentError, "Unsupported argument type: `#{value}` #{value.class}"
-							end
-					Arel::Nodes::TableAlias.new(expression, name)
-				end
-			end
-		end
-	end
-end