adjustable_schema 0.5.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c1789abd8073508a7768242d964718458c267d98d58ec4ac96872048d9e28b3
-  data.tar.gz: b565d636b51ec479a9b10784f21dd96b15ae1fc744dce0763ef9b42b8fbd548e
+  metadata.gz: 8f905a89a0f7ab6c7c5c1f1feaa92a8fdb90f5e58003b164fed5ac55096fa258
+  data.tar.gz: cf1c34dd8cce3497e64635ab1c59f079e257961979e55e9d31b30ae1aefeb4ff
 SHA512:
-  metadata.gz: e892e5c9b20b1cc7745a4fd69cd534764204ae80c7c19f13d9d13863c4be4abb59f541fe2347a9d65465b7946783f73470a734144e3a87e4e0f3c956ecd66aea
-  data.tar.gz: f794633f6c6799df9b4703525b3fdfc3a7a88e416ed2582671ebadb0d53028fcfce31c0570e5d42c9fc5421304382c7187ea1273a560b8fafe75ddea8dc2aea3
+  metadata.gz: 892d3cc2cdfa8d6cd7d2405289e1417a54be8c8767fefa557208a2d7880d346e4c362adc1a5dc911d2091be1b172a15f88e3060c0c06b29b135a61efb773f5bb
+  data.tar.gz: 145e68868903178eb0a6a82ed224912f657cdb7004f91df9cf70bec4c9c32241b1cd216515ee913369e6914f865007214d1a7aad5b5604664b73408974f5a323

data/README.md

@@ -56,10 +56,12 @@ book.editor_people
 
 #### Special cases
 
-In case you have set up relations with a `User` model you'll get a slightly different naming:
+##### "Actor-like" models
+
+In case you have set up relationships with `User` model you'll get a slightly different naming:
 
 ``` ruby
-AdjustableSchema::Relationship.seed! User => Book, %w[author editor]
+AdjustableSchema::Relationship.seed! User => Book, roles: %w[author editor]
 ```
 
 ``` ruby
@@ -71,11 +73,42 @@ book.editors
 The list of models to be handled this way can be set with `actor_model_names` configuration parameter.
 It includes `User` by default.
 
-###### TODO
+##### Self-referencing models
+
+You may want to set up self-targeted relationships:
+
+``` ruby
+AdjustableSchema::Relationship.seed! Person, roles: %w[friend]
+```
+
+In this case you'll get these associations:
+
+``` ruby
+person.parents
+person.children # for all the children
+person.people   # for "roleless" children, not friends
+person.friends
+person.friended_people
+```
+
+If you prefer a different naming over `parents` & `children`, you can configure it like this:
 
-* Describe self-referential associations.
+```ruby
+AdjustableSchema::Engine.configure do
+  config.names[:associations][:source][:self] = :effect
+  config.names[:associations][:target][:self] = :cause
+end
+```
+
+Thus, for the self-referenced `Event`s, you'll get:
+
+``` ruby
+event.causes
+event.effects
+```
 
 ## Installation
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -83,13 +116,15 @@ gem "adjustable_schema"
 ```
 
 And then execute:
+
 ```bash
-$ bundle
+bundle
 ```
 
 Or install it yourself as:
+
 ```bash
-$ gem install adjustable_schema
+gem install adjustable_schema
 ```
 
 ## Contributing
@@ -101,4 +136,5 @@ $ gem install adjustable_schema
 5. Create new Pull Request
 
 ## License
+
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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

@@ -1,16 +1,15 @@
 module AdjustableSchema
 	class Relationship
 		class Role < ApplicationRecord
-			include Organizer::Identifiable.by :name
+			include Organizer::Identifiable.by :name, symbolized: true
 
 			has_many :relationships
 
 			validates :name, presence: true, uniqueness: true
 
-			# FIXME: depends on default naming
-			scope :available, ->        { with_relationships { of :abstract } }
-			scope :of,        -> source { with_relationships { of source    } }
-			scope :for,       -> target { with_relationships { to target    } }
+			scope :available, ->        { with_relationships { send Config.shortcuts[:source], :abstract } }
+			scope :of,        -> source { with_relationships { send Config.shortcuts[:source], source    } }
+			scope :for,       -> target { with_relationships { send Config.shortcuts[:target], target    } }
 
 			def self.with_relationships(&)
 				joins(:relationships)
@@ -19,11 +18,13 @@ module AdjustableSchema
 
 			class << self
 				def [] *names, **scopes
-					return super *names if names.any?
-
-					scopes
-							.map { of(_1).for _2 }
-							.reduce &:merge
+					if scopes.any?
+						with_relationships { self[**scopes] }
+								.distinct
+					else
+						all
+					end
+							.scoping { names.any? ? super(*names) : all }
 				end
 			end
 		end

data/app/models/adjustable_schema/relationship.rb

@@ -72,6 +72,16 @@ module AdjustableSchema
 		end
 
 		class << self
+			def [] **scopes
+				scopes
+						.map do
+							self
+									.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
 

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

@@ -5,20 +5,23 @@ module AdjustableSchema
 				private
 
 				def adjust_associations
-					relationships.each do |direction, relationships|
-						relationships
-								.select(&:"#{direction}_type")
-								.each do |relationship|
-									setup_association direction, relationship.send("#{direction}_type").constantize, relationship.role
-								end
-					end
+					relationships
+							.flat_map do |direction, relationships|
+								relationships
+										.select(&:"#{direction}_type")
+										.each do |relationship|
+											setup_association direction, relationship.send("#{direction}_type").constantize, relationship.role
+										end
+							end
+							.presence
+							&.tap do # finally, if any relationships have been set up
+								include Relationships::InstanceMethods
+							end
 				end
 
 				def setup_association direction, target = self, role = nil
 					adjustable_association(direction, target      ).define
 					adjustable_association(direction, target, role).define if role
-
-					include Relationships::InstanceMethods
 				end
 
 				def adjustable_association(...)

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

@@ -1,12 +1,15 @@
+require 'memery'
+
 module AdjustableSchema
 	module ActiveRecord
 		concern :Relationships do
 			class_methods do
-				def relationships
-					@relationships ||= # cache
-							Config.association_directions.to_h do
-								[ _1, Relationship.abstract.send(Config.shortcuts.opposite[_1], self) ]
-							end
+				include Memery
+
+				memoize def relationships
+					Config.association_directions.to_h do
+						[ _1, Relationship.abstract.send(Config.shortcuts.opposite[_1], self) ]
+					end
 				end
 
 				def roles(&) = Role.of self, &
@@ -14,76 +17,57 @@ module AdjustableSchema
 				private
 
 				def define_recursive_methods association_name, method
-					redefine_method tree_method = "#{method.to_s.singularize}_tree" do
+					define_method method do
 						send(association_name)
-								.inject([]) do |tree, node|
-							tree << node << node.send(tree_method)
-						end
-								.reject &:blank?
-					end
-
-					redefine_method "#{method}_with_distance" do
-						(with_distance = -> (level, distance) {
-							case level
-							when Array
-								level.inject({}) do |hash, node|
-									hash.merge with_distance[node, distance.next]
-								end
-							else
-								{ level => distance }
-							end
-						})[send(tree_method), 0]
-					end
-
-					redefine_method method do
-						send(tree_method).flatten
+								.recursive
 					end
 				end
 			end
 
 			concern :InstanceMethods do # to include when needed
 				included do
+					scope :roleless, -> { merge Relationship.nameless }
+
 					Config.association_directions.recursive
 							.select { reflect_on_association _1 }
 							.reject { method_defined? _2 }
-							.each { define_recursive_methods _1, _2 }
+							.each   { define_recursive_methods _1, _2 }
 				end
 
 				def related?(...)
 					relationships(...)
-							.values
-							.reduce(&:or)
 							.any?
 				end
 
 				def related(...)
 					relationships(...)
-							.flat_map do |direction, relationships|
-								relationships
-										.preload(direction)
-										.map &direction
+							.preload(Config.association_directions)
+							.map do |relationship|
+								Config.association_directions
+										.map { relationship.send _1 } # both objects
+										.without(self) # the related one
+										.first or self # may be self-related
 							end
 							.uniq
 				end
 
-				def relationships *names, **options
-					if (direction, scope = Config.find_direction options)
-						{
-								direction => relationships_to(direction)
-										.try(Config.shortcuts[direction], scope) # filter by related objects
-						}
-					else # both directions
-						Config.association_directions.to_h { [ _1, relationships_to(_1) ] }
+				def relationships **options
+					if (direction, scope = Config.find_direction **options) # 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 }
+								.reduce(&:or)
 					end
-							.compact
-							.tap do |relationships|
-								break relationships.transform_values { _1.named names } if names.any? # filter by role
-							end
 				end
 
 				private
 
-				def relationships_to(direction) = try "#{direction}_relationships"
+				def relationships_to direction
+					try "#{direction}_relationships" or
+							Relationship.none
+				end
 			end
 		end
 	end

data/config/initializers/model_names.rb

@@ -0,0 +1,4 @@
+# HACK: non-public Rails API used
+ActiveModel::Name.class_eval do
+	def unnamespaced = @unnamespaced || name
+end

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

@@ -1,62 +1,67 @@
+require 'memery'
+
 module AdjustableSchema
 	module ActiveRecord
 		class Association
 			concerning :Naming do
+				include Memery
+
 				module Inflections
 					refine String do
 						def passivize
-							sub(/(e?d?|ing|[eo]r|ant|(t)ion)$/, '\\2ed')
+							self
+									.sub(/(author)$/, '\\2ed')
+									.sub(/(e*|ed|ing|[eo]r|ant|(t)ion)$/, '\\2ed')
 						end
 					end
 				end
 
 				using Inflections
 
-				def name
-					@name ||= # cache
-							(role ? name_with_role : name_without_role)
-									.to_s
-									.tableize
-									.to_sym
+				memoize def name
+					(role ? name_with_role : name_without_role)
+							.to_s
+							.tableize
+							.to_sym
 				end
 
-				def target_name
-					@target_name ||= # cache
-							target.name
-									.split('::')
-									.reverse
-									.join
-									.underscore
+				memoize def target_name
+					target.model_name.unnamespaced
+							.split('::')
+							.reverse
+							.join
+							.underscore
 				end
 
 				def relationships_name = :"#{role ? name_with_role : direction}_relationships"
 
 				private
 
-				def name_with_role
-					@name_with_role ||= # cache
-							if self_targeted?
-								{
-										source: role.name,
-										target: "#{role.name.passivize}_#{target_name}",
-								}[direction]
-							else
-								"#{{
-										source: role.name,
-										target: role.name.passivize,
-								}[direction]}_#{target_name}"
-							end
+				memoize def name_with_role
+					if loop?
+						{
+								source: role.name,
+								target: "#{role.name.passivize}_#{target_name}",
+						}[direction]
+					else
+						"#{{
+								source: role.name,
+								target: role.name.passivize,
+						}[direction]}_#{target_name}"
+					end
 				end
 
-				def name_without_role
-					@name_without_role ||= # cache
-							if self_targeted?
-								Config.association_directions
-										.self_related[direction]
-							else
-								target_name
-							end
+				memoize def name_without_role
+					if loop?
+						Config.association_directions
+								.self[direction]
+					else
+						target_name
+					end
 				end
+
+				def name_for_any  = :"#{name.to_s.singularize.passivize}"
+				def name_for_none = :"#{name.to_s.singularize}less"
 			end
 		end
 	end

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

@@ -0,0 +1,52 @@
+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
+
+				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
+				end
+
+				private
+
+				def association_name = @association.reflection.name
+
+				def inverse_association_name
+					Config.association_directions
+							.recursive
+							.keys
+							.without(association_name)
+							.sole
+				end
+
+				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
+			end
+		end
+	end
+end

data/lib/adjustable_schema/active_record/association.rb

@@ -2,31 +2,70 @@ module AdjustableSchema
 	module ActiveRecord
 		class Association < Struct.new(:owner, :direction, :target, :role)
 			require_relative 'association/naming'
+			require_relative 'association/scopes'
 
 			def define
 				name.tap do |association_name|
-					has_many 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.loop?
+					end
+
+					define_scopes
+					define_methods
+
+					unless role
+						has_many target_name.tableize.to_sym, -> { roleless }, **options if
+								loop?
 
-					define_role_methods unless role
+						define_role_methods
+					end
 				end
 			end
 
-			def self_targeted? = target == owner
+			def loop? = target == owner
 
 			private
 
 			def define_relationships
 				relationships_name.tap do |association_name|
-					has_many association_name, role && -> { where role: },
+					has_many association_name, (role = self.role) && -> { where role: },
 							as:         Config.association_directions.opposite(to: direction),
+							dependent:  :destroy_async,
 							class_name: 'AdjustableSchema::Relationship'
 				end
 			end
 
+			def define_scopes
+				name = relationships_name
+
+				{
+						name_for_any  => -> { where.associated name },
+						name_for_none => -> { where.missing    name },
+				}
+						.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}?" }
+						.reject { owner.method_defined? _1 }
+						.each   { owner.define_method _1, &_2 }
+			end
+
 			def define_role_methods
 				name = self.name
 

data/lib/adjustable_schema/active_record/query_methods.rb

@@ -0,0 +1,103 @@
+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

data/lib/adjustable_schema/config.rb

@@ -1,24 +1,29 @@
+require 'memery'
+
 module AdjustableSchema
 	module Config
+		include Memery
+
 		module Naming
-			def shortcuts
-				@shortcuts ||= # cache
-						config(:shortcut).tap do |shortcuts|
-							def shortcuts.opposite to: nil
-								if to
-									values.reject { _1 == to }.sole
-								else
-									transform_values { opposite to: _1 }
-								end
-							end
+			include Memery
+
+			memoize def shortcuts
+				config(:shortcut).tap do |shortcuts|
+					def shortcuts.opposite to: nil
+						if to
+							values.reject { _1 == to }.sole
+						else
+							transform_values { opposite to: _1 }
 						end
+					end
+				end
 			end
 
-			def self_related = config :self_related
+			def self = config :self
 
 			def recursive
 				config.values.to_h do
-					[ _1[:self_related].to_s.pluralize.to_sym, _1[:recursive] ]
+					[ _1[:self].to_s.pluralize.to_sym, _1[:recursive].to_sym ]
 				end
 			end
 
@@ -30,7 +35,7 @@ module AdjustableSchema
 
 			def config section = nil
 				if section
-					config.transform_values { _1[section] }
+					config.transform_values { _1[section].to_sym }
 				else
 					Config.association_names # TODO: DRY
 				end
@@ -39,13 +44,12 @@ module AdjustableSchema
 
 		module_function
 
-		def association_directions
-			@association_directions ||= # cache
-				association_names.keys.tap do |directions|
-					class << directions
-						include Naming
-					end
+		memoize def association_directions
+			association_names.keys.tap do |directions|
+				class << directions
+					include Naming
 				end
+			end
 		end
 
 		def find_direction(...)
@@ -67,6 +71,7 @@ module AdjustableSchema
 
 		def normalize **options
 			shortcuts
+					.tap { options.assert_valid_keys _1.keys, _1.values }
 					.select { _2.in? options }
 					.each { options[_1] = options.delete _2 }
 

data/lib/adjustable_schema/engine.rb

@@ -7,14 +7,14 @@ module AdjustableSchema
 		config.names = {
 				associations: {
 						source: {
-								shortcut:     :of,
-								self_related: :child,
-								recursive:    :descendants,
+								shortcut:  :of,
+								self:      :child,
+								recursive: :descendants,
 						},
 						target: {
-								shortcut:     :to,
-								self_related: :parent,
-								recursive:    :ancestors,
+								shortcut:  :to,
+								self:      :parent,
+								recursive: :ancestors,
 						},
 				},
 		}

data/lib/adjustable_schema/version.rb

@@ -1,3 +1,3 @@
 module AdjustableSchema
-	VERSION = '0.5.2'
+	VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adjustable_schema
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Alexander Senko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-04 00:00:00.000000000 Z
+date: 2024-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -40,6 +40,20 @@ dependencies:
         version: '0.2'
 - !ruby/object:Gem::Dependency
   name: organizer-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: memery
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -77,12 +91,15 @@ files:
 - 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/naming.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
@@ -94,7 +111,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.5.2/CHANGELOG.md
+  changelog_uri: https://github.com/Alexander-Senko/adjustable_schema/blob/v0.7.0/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths: