adjustable_schema 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e850de1792bf132577dfde2173875a6935a5f2e11a0d0b4394739d34585216b3
-  data.tar.gz: 0c570f510d467df417755cb7b6fcff67744b2295ce499fbeb298b5f9efa427bd
+  metadata.gz: f9fab61b2df51275e0e3c9ebf681dc48a30378a48248b1f02c7bad89afc47075
+  data.tar.gz: 266abb846dba3f7119dd424f855e77942d3ffc98b012b44d2210902cff32a604
 SHA512:
-  metadata.gz: 3a6568bb17944cda2fe8acfdbfde2044690bcbc947fdea72fa25e3a994e664b2d95cd8cd36a2562b43236327cba0205a8c84190bbf404cb859d7717e09abb1e3
-  data.tar.gz: e8957e5c232b69467b07e684a134a07e1654e2038f62701d728eb8e6c544047548b54d4df28457ab8c3d5621b9cb2e19d0e2658e9711089d236fe826d300506c
+  metadata.gz: 9f2b270be59abff4ada4cfc1d9146f00bcbf43c8473588e23f411b71a5daf4f1928e1c075da4b3d4112e1883245249a5a6f42c5bbff148663ceca5fed8492bbe
+  data.tar.gz: f9ea77c562420ed47c701f963d2fcc9d7835ead91411e7e150944d9d9a9ba49a09b6bdc5ea44c4bcf7bf73e98e9767b8eb383b493f8d5f5aaae1821a4f10cf6c

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,7 +1,11 @@
+require 'memery'
+
 module AdjustableSchema
 	module ActiveRecord
 		class Association
 			concerning :Naming do
+				include Memery
+
 				module Inflections
 					refine String do
 						def passivize
@@ -12,50 +16,46 @@ module AdjustableSchema
 
 				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 self_targeted?
+						{
+								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 self_targeted?
+						Config.association_directions
+								.self_related[direction]
+					else
+						target_name
+					end
 				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,16 +2,28 @@ 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.self_targeted?
+					end
+
+					unless role
+						has_many target_name.tableize.to_sym, -> { roleless }, **options if
+								self_targeted?
 
-					define_role_methods unless role
+						define_role_methods
+					end
 				end
 			end
 
@@ -21,8 +33,9 @@ module AdjustableSchema
 
 			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

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 recursive
 				config.values.to_h do
-					[ _1[:self_related].to_s.pluralize.to_sym, _1[:recursive] ]
+					[ _1[:self_related].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

@@ -1,3 +1,5 @@
+require 'organizer'
+
 module AdjustableSchema
 	class Engine < ::Rails::Engine
 		isolate_namespace AdjustableSchema

data/lib/adjustable_schema/version.rb

@@ -1,3 +1,3 @@
 module AdjustableSchema
-	VERSION = '0.5.1'
+	VERSION = '0.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adjustable_schema
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Alexander Senko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-28 00:00:00.000000000 Z
+date: 2024-02-20 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.1/CHANGELOG.md
+  changelog_uri: https://github.com/Alexander-Senko/adjustable_schema/blob/v0.6.0/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -110,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.5
 signing_key:
 specification_version: 4
 summary: Adjustable data schemas for Rails