adjustable_schema 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3485d9747332369fa6717cfcc2f8340dedc75cb47a991c4f6f52f6838dd0bab6
+  data.tar.gz: 9805cfd3909951255df31007226bf699208d710c4fc74861df94cc80730a6130
+SHA512:
+  metadata.gz: af22e30050202341aba9503e91382526e25db5955f0d4dc6582078a09f415a3461db50f39c06f7307f7ed35bb8bbfdc987533a1d51ba30fccb038b91bf9db034
+  data.tar.gz: 2080e9f4268d52ee0ec94cffe07ba747eac277d14917727ec0c6156e0dd6b498958365a16d308b257f6f55885c3cffbcdaa617bca424fea0c557ab5a2f5de4d1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Alexander Senko
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# Adjustable Schema for Rails
+
+Define your model associations in the database without changing the schema or models.
+
+This Rails Engine was renamed and refactored from [Rails Dynamic Associations](https://github.com/Alexander-Senko/rails_dynamic_associations).
+
+## Features
+
+* Creates associations for your models when application starts.
+* Provides `Relationship` & `Relationship::Role` models.
+* No configuration code needed.
+* No code generated or inserted to your app (except migrations).
+* Adds some useful methods to `ActiveRecord` models to handle their relationships.
+
+## Usage
+
+Add configuration records to the DB:
+
+``` ruby
+AdjustableSchema::Relationship.create! source_type: 'Person',
+                                       target_type: 'Book'
+```
+
+Or use a helper method:
+
+``` ruby
+AdjustableSchema::Relationship.seed! Person => Book
+```
+
+Now you have:
+
+``` ruby
+person.books
+book.people
+```
+
+### Roles
+
+You can create multiple role-based associations between two models.
+
+``` ruby
+AdjustableSchema::Relationship.seed! Person => Book, roles: %w[author editor]
+```
+
+You will get:
+
+``` ruby
+person.books
+person.authored_books
+person.edited_books
+
+book.people
+book.author_people
+book.editor_people
+```
+
+#### Special cases
+
+In case you have set up relations with a `User` model you'll get a slightly different naming:
+
+``` ruby
+AdjustableSchema::Relationship.seed! User => Book, %w[author editor]
+```
+
+``` ruby
+book.users
+book.authors
+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
+
+* Describe self-referential associations.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "adjustable_schema"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install adjustable_schema
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+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/Rakefile

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

data/app/assets/config/adjustable_schema_manifest.js

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

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

@@ -0,0 +1,15 @@
+/*
+ * 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

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

data/app/helpers/adjustable_schema/application_helper.rb

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

data/app/jobs/adjustable_schema/application_job.rb

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

data/app/mailers/adjustable_schema/application_mailer.rb

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

data/app/models/adjustable_schema/application_record.rb

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

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

@@ -0,0 +1,21 @@
+module AdjustableSchema
+	class Relationship
+		class Role < ApplicationRecord
+			include Organizer::Identifiable.by :name
+
+			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    } }
+
+			def self.with_relationships(&)
+				joins(:relationships)
+						.merge Relationship.instance_eval(&)
+			end
+		end
+	end
+end

data/app/models/adjustable_schema/relationship.rb

@@ -0,0 +1,123 @@
+module AdjustableSchema
+	class Relationship < ApplicationRecord
+		belongs_to :source, polymorphic: true, optional: true
+		belongs_to :target, polymorphic: true, optional: true
+		belongs_to :role,                      optional: true
+
+		default_scope do
+			references(:role)
+					.includes :role
+		end
+
+		Config.shortcuts.each &-> ((association, method)) do
+			scope method, -> object {
+				case object
+				when ::ActiveRecord::Base, nil
+					where association => object
+				when Class
+					where "#{association}_type" => object.ancestors
+							.select { _1 <= object.base_class }
+							.map(&:name)
+				when ::ActiveRecord::Relation
+					send(method, object.klass)
+							.where "#{association}_id" => object
+				when Symbol
+					send "#{method}_#{object}"
+				else
+					raise ArgumentError, "no relationships for #{object.inspect}"
+				end
+			}
+
+			scope "#{method}_abstract", -> object = nil {
+				if object
+					send(__method__).
+							send method, object
+				else
+					where "#{association}_id" => nil
+				end
+			}
+		end
+
+		scope :abstract, -> {
+			Config.shortcuts.values
+					.map { send _1, :abstract }
+					.reduce &:merge
+		}
+
+		scope :general, -> {
+			where target: nil
+		}
+
+		scope :applied, -> {
+			where.not(
+					source: nil,
+					target: nil,
+			)
+		}
+
+		scope :named, -> *names {
+			case names
+			when [] # i.e. `named`
+				where.not role: nil
+			else
+				with_roles { where name: names }
+			end
+		}
+
+		scope :nameless, -> { where role: nil }
+
+		def self.with_roles(&)
+			joins(:role)
+					.merge Role.instance_eval(&)
+		end
+
+		class << self
+			def seed! *models, roles: [], **_models
+				return seed!({ **Hash[*models], **_models }, roles:) if _models.any? # support keyword arguments syntax
+
+				case models
+				in [
+						String | Symbol | Class => source_type,
+						String | Symbol | Class => target_type,
+				]
+					roles
+							.map { |name| Role.find_or_create_by! name: }
+							.then { _1.presence or [ nil ] } # no roles => nameless relationship
+							.map { |role| create! source_type:, target_type:, role: }
+				in [ Hash => models ]
+					for sources, targets in models do
+						for source, target in Array(sources).product Array(targets) do
+							seed! source, target, roles:
+						end
+					end
+				in [ Class => source ]
+					seed! source, source, roles: # self-related
+				end
+			end
+		end
+
+		delegate :name, to: :role, allow_nil: true
+
+		def name= role_name
+			self.role =
+					role_name && Role[role_name]
+		end
+
+		def abstract? = not (source or target)
+
+		# HACK
+		# 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
+		# store the base model for the STI models in the type column of the polymorphic
+		# association.
+		# https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Polymorphic+Associations
+		reflections
+				.values
+				.select { _1.options[:polymorphic] }
+				.each do |reflection|
+					define_method "#{reflection.name}_type=" do |type|
+						super type && type.to_s.classify.constantize.base_class.to_s
+					end
+				end
+	end
+end

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

@@ -0,0 +1,28 @@
+module AdjustableSchema
+	module ActiveRecord
+		concern :Associations do
+			class_methods do
+				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
+				end
+
+				def setup_association direction, target = self, role = nil
+					adjustable_association(direction, target      ).define
+					adjustable_association(direction, target, role).define if role
+				end
+
+				def adjustable_association(...)
+					Association.new(self, ...)
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,16 @@
+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
+				end
+
+				def roles(&) = Role.of self, &
+			end
+		end
+	end
+end

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

@@ -0,0 +1,15 @@
+<!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/initializers/associations.rb

@@ -0,0 +1,6 @@
+ActiveSupport.on_load :model_class do
+	next if     self == AdjustableSchema::Relationship
+	next unless AdjustableSchema.available?
+
+	adjust_associations
+end

data/config/routes.rb

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

data/db/migrate/01_create_adjustable_schema_relationship_tables.rb

@@ -0,0 +1,39 @@
+class CreateAdjustableSchemaRelationshipTables < ActiveRecord::Migration[7.1]
+	def change
+		# Use Active Record's configured type for primary and foreign keys
+		primary_key_type, foreign_key_type = primary_and_foreign_key_types
+
+		create_table :adjustable_schema_relationship_roles do |t|
+			t.string :name, index: { unique: true }
+
+			t.timestamps
+		end
+
+		create_table :adjustable_schema_relationships do |t|
+			t.references :source, polymorphic: true, index: true, type: foreign_key_type
+			t.references :target, polymorphic: true, index: true, type: foreign_key_type
+			t.references :role,                      index: true,
+					foreign_key: { to_table: :adjustable_schema_relationship_roles }
+
+			t.timestamps
+
+			t.index %i[
+					source_id source_type
+					target_id target_type
+					role_id
+			].tap { |columns|
+					columns.reject! { _1.ends_with? '_type' } if foreign_key_type == :uuid # OPTIMIZATION: IDs are unique
+			}, unique: true, name: :index_adjustable_schema_relationships_uniqueness
+		end
+	end
+
+	private
+
+	def primary_and_foreign_key_types
+		config           = Rails.configuration.generators
+		setting          = config.options[config.orm][:primary_key_type]
+		primary_key_type = setting || :primary_key
+		foreign_key_type = setting || :bigint
+		[primary_key_type, foreign_key_type]
+	end
+end

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

@@ -0,0 +1,63 @@
+module AdjustableSchema
+	module ActiveRecord
+		class Association
+			concerning :Naming do
+				module Inflections
+					refine String do
+						def passivize
+							sub(/(e?d?|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
+				end
+
+				def target_name
+					@target_name ||= # cache
+							target.name
+									.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
+				end
+
+				def name_without_role
+					@name_without_role ||= # cache
+							if self_targeted?
+								Config.association_directions
+										.self_related[direction]
+							else
+								target_name
+							end
+				end
+			end
+		end
+	end
+end

data/lib/adjustable_schema/active_record/association.rb

@@ -0,0 +1,46 @@
+module AdjustableSchema
+	module ActiveRecord
+		class Association < Struct.new(:owner, :direction, :target, :role)
+			require_relative 'association/naming'
+
+			def define
+				name.tap do |association_name|
+					has_many association_name,
+							through:     define_relationships,
+							source:      direction,
+							source_type: target.base_class.name,
+							class_name:  target.name
+
+					define_role_methods unless role
+				end
+			end
+
+			def self_targeted? = target == owner
+
+			private
+
+			def define_relationships
+				relationships_name.tap do |association_name|
+					has_many association_name, role && -> { where role: },
+							as:         Config.association_directions.opposite(to: direction),
+							class_name: 'AdjustableSchema::Relationship'
+				end
+			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
+		end
+	end
+end

data/lib/adjustable_schema/active_record.rb

@@ -0,0 +1,10 @@
+module AdjustableSchema
+	module ActiveRecord
+		autoload :Association, 'adjustable_schema/active_record/association'
+
+		ActiveSupport.on_load :active_record do
+			include Associations
+			include Relationships
+		end
+	end
+end

data/lib/adjustable_schema/authors.rb

@@ -0,0 +1,15 @@
+Gem::Author ||= Struct.new(
+		:name,
+		:email,
+		:github_url,
+)
+
+module AdjustableSchema
+	AUTHORS = [
+			Gem::Author.new(
+					name:       'Alexander Senko',
+					email:      'Alexander.Senko@gmail.com',
+					github_url: 'https://github.com/Alexander-Senko',
+			),
+	]
+end

data/lib/adjustable_schema/config.rb

@@ -0,0 +1,76 @@
+module AdjustableSchema
+	module Config
+		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
+						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] ]
+				end
+			end
+
+			def opposite to:
+				reject { _1 == to }.sole
+			end
+
+			private
+
+			def config section = nil
+				if section
+					config.transform_values { _1[section] }
+				else
+					Config.association_names # TODO: DRY
+				end
+			end
+		end
+
+		module_function
+
+		def association_directions
+			@association_directions ||= # cache
+				association_names.keys.tap do |directions|
+					class << directions
+						include Naming
+					end
+				end
+		end
+
+		def find_direction(...)
+			normalize(...)
+					.find { |dir, *| dir.in? association_directions }
+		end
+
+		for method in %i[
+				shortcuts
+		] do
+			delegate        method, to: :association_directions
+			module_function method
+		end
+
+		private
+		module_function
+
+		def association_names = Engine.config.names[:associations]
+
+		def normalize **options
+			shortcuts
+					.select { _2.in? options }
+					.each { options[_1] = options.delete _2 }
+
+			options
+		end
+	end
+end

data/lib/adjustable_schema/engine.rb

@@ -0,0 +1,20 @@
+module AdjustableSchema
+	class Engine < ::Rails::Engine
+		isolate_namespace AdjustableSchema
+
+		config.names = {
+				associations: {
+						source: {
+								shortcut:     :of,
+								self_related: :child,
+								recursive:    :descendants,
+						},
+						target: {
+								shortcut:     :to,
+								self_related: :parent,
+								recursive:    :ancestors,
+						},
+				},
+		}
+	end
+end

data/lib/adjustable_schema/version.rb

@@ -0,0 +1,3 @@
+module AdjustableSchema
+	VERSION = '0.5.0'
+end

data/lib/adjustable_schema.rb

@@ -0,0 +1,15 @@
+require "adjustable_schema/version"
+require "adjustable_schema/engine"
+require 'adjustable_schema/active_record'
+
+require 'rails_model_load_hook' # should be loaded
+
+module AdjustableSchema
+	autoload :Config, 'adjustable_schema/config'
+
+	module_function
+
+	def available?
+		Relationship.table_exists?
+	end
+end

data/lib/tasks/adjustable_schema_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :adjustable_schema do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: adjustable_schema
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Alexander Senko
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: rails_model_load_hook
+  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: organizer-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rails Engine to allow ActiveRecord associations be set up in the DB instead
+  of being hard-coded.
+email:
+- Alexander.Senko@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- 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/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/authors.rb
+- lib/adjustable_schema/config.rb
+- lib/adjustable_schema/engine.rb
+- lib/adjustable_schema/version.rb
+- lib/tasks/adjustable_schema_tasks.rake
+homepage: https://github.com/Alexander-Senko/adjustable_schema
+licenses:
+- MIT
+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/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.0.dev
+signing_key:
+specification_version: 4
+summary: Adjustable data schemas for Rails
+test_files: []