yiffspace-user 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: db2366c67818c97d4f8ce3ecb53816f6a84e0fb2a3b9faf952445a385d2f6a51
+  data.tar.gz: bff3d69f13b880865ff6f812fff8eb8da65108f6ed3bd9d87cf5d7cb4c570ce2
+SHA512:
+  metadata.gz: c616f03209b48f1bc85bfa134c2ac969b9eda29c0fee241124dde30757c68521f92e7e201161f2d0c86ed327bfc4508393583e07c2c81b9e986f22c1d0bcc8cc
+  data.tar.gz: 503228eec1c7c14fe14be6bb53aaac465b3e0cdb93dfc1fa99f9093e5ef9c2223264273d6eca95f6cc19f6ec9eb2994031e3ec2673a66c459bdd76ba19321a13

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+## 0.0.1
+
+- Initial release, extracted from the `yiffspace` gem's User/Current/Resolvable
+  concerns and utils. `YiffSpace::Utils::Current`/`UserLike`/`UserResolvable`/
+  `UserAttribute`/`UserToId` are now `YiffSpace::User::Current`/`Like`/
+  `Resolvable`/`Attribute`/`ToId`.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright Donovan_DMC
+
+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,28 @@
+# YiffSpace::User
+
+The User/Current/Resolvable concerns and utils - `YiffSpace::User::Current`,
+`YiffSpace::User::Resolvable`, `YiffSpace::User::Like`, `YiffSpace::User::Attribute`,
+`YiffSpace::User::ToId`, plus the `Concerns::User*`/`Concerns::Current*` model
+concerns - for https://yiff.space and related projects.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "yiffspace-user"
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Contributing
+
+Go away
+
+## 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,9 @@
+# frozen_string_literal: true
+
+require("bundler/gem_tasks")
+
+# CI releases from an already-tagged, already-pushed commit checked out at a detached HEAD, so
+# the default release task's git tag/push step has nothing to do and fails trying to push a
+# branch ref that does not exist in that checkout.
+Rake::Task["release"].clear
+task("release" => "release:rubygem_push")

data/lib/yiffspace/concerns/current_methods.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module CurrentMethods
+      extend(ActiveSupport::Concern)
+
+      module ClassMethods
+        def search_current(params, ...)
+          search(params, YiffSpace.config.current_class.user, ...)
+        end
+
+        def with_current(instance, method, *args, **, &)
+          attr = args.grep(Symbol)
+          other = args - attr
+          hashes = other.grep(Hash)
+          params = other.grep(ActionController::Parameters)
+          other -= hashes + params
+          other.compact_blank!
+          options = [attr.index_with(YiffSpace.config.current_class.user), *hashes, *params.map(&:to_hash)].inject(:merge)
+          instance.send(method, *other, **options, **, &)
+        end
+
+        def new_with_current(...)
+          with_current(self, :new, ...)
+        end
+
+        def create_with_current(...)
+          with_current(self, :create, ...)
+        end
+
+        def create_with_current!(...)
+          with_current(self, :create!, ...)
+        end
+      end
+
+      def update_with_current(...)
+        self.class.with_current(self, :update, ...)
+      end
+
+      def update_with_current!(...)
+        self.class.with_current(self, :update!, ...)
+      end
+
+      def destroy_with_current(*attrs)
+        attrs.each do |attr|
+          send("#{attr}=", YiffSpace.config.current_class.user)
+        end
+        destroy
+      end
+
+      def destroy_with_current!(*attrs)
+        attrs.each do |attr|
+          send("#{attr}=", YiffSpace.config.current_class.user)
+        end
+        destroy!
+      end
+    end
+  end
+end

data/lib/yiffspace/concerns/user_class_methods.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    # methods to include into the user class for use with the like/resolvable classes
+    module UserClassMethods
+      extend(ActiveSupport::Concern)
+
+      def resolvable(ip_addr = nil)
+        YiffSpace.config.user_resolvable_class.new(self, ip_addr || "127.0.0.1")
+      end
+
+      def resolve
+        self
+      end
+
+      def ==(other)
+        return super if other.is_a?(YiffSpace.config.user_class)
+
+        other.is_a?(YiffSpace.config.user_resolvable_class) && super(other.user)
+      end
+
+      def ===(other)
+        other == YiffSpace.config.user_like_class || super
+      end
+
+      def is_a?(other)
+        other == YiffSpace.config.user_like_class || super
+      end
+    end
+  end
+end

data/lib/yiffspace/concerns/user_methods.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module UserMethods
+      extend(ActiveSupport::Concern)
+
+      module ClassMethods
+        def belongs_to_user(*, **)
+          User::Attribute.new(self, *, **, db: true)
+        end
+
+        def resolvable(*, **)
+          User::Attribute.new(self, *, **, db: false)
+        end
+
+        def with_user(instance, method, user, *args, **, &)
+          default = { new: :creator, create: :creator, create!: :creator, update: :updater, update!: :updater, destroy: :destroyer, destroy!: :destroyer }.fetch(method)
+          attrs = args.grep(Symbol)
+          attrs = [default] if default && attrs.empty?
+          other = args - attrs
+          hashes = other.grep(Hash)
+          params = other.grep(ActionController::Parameters)
+          other -= hashes + params
+          other.compact_blank!
+          options = [attrs.index_with(user), *hashes, *params.map(&:to_hash)].inject(:merge)
+          if %i[destroy destroy!].include?(method)
+            options.each do |attr, value|
+              instance.send("#{attr}=", value)
+            end
+            instance.send(method)
+          else
+            instance.send(method, *other, **options, **, &)
+          end
+        end
+
+        def new_with(...)
+          with_user(self, :new, ...)
+        end
+
+        def create_with(...)
+          new_with(...).tap(&:save)
+        end
+
+        def create_with!(...)
+          new_with(...).tap(&:save!)
+        end
+      end
+
+      def update_with(...)
+        self.class.with_user(self, :update, ...)
+      end
+
+      def update_with!(...)
+        self.class.with_user(self, :update!, ...)
+      end
+
+      def destroy_with(...)
+        self.class.with_user(self, :destroy, ...)
+      end
+
+      def destroy_with!(...)
+        self.class.with_user(self, :destroy!, ...)
+      end
+
+      private
+
+      def put(attr, value, overwrite: false)
+        if respond_to?(:"#{attr}_id")
+          send(:"#{attr}=", value) if overwrite || send(:"#{attr}_id").blank?
+        elsif respond_to?(attr)
+          send(:"#{attr}=", value) if overwrite || send(attr).blank?
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/concerns/user_name_methods.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module UserNameMethods
+      extend(ActiveSupport::Concern)
+
+      module ClassMethods
+        def name_to_id(name)
+          normalized_name = normalize_name(name)
+          Utils::Cache.fetch("uni:#{normalized_name}", expires_in: 4.hours) do
+            ::User.where("lower(name) = ?", normalized_name).pick(:id)
+          end
+        end
+
+        # @param arguments [Array<String, Array<String>>] a list of names
+        # @return [Hash{String => Integer, nil}] a hash of normalized names to user IDs
+        def bulk_name_to_id(*arguments)
+          names = arguments.flatten.map { |n| normalize_name(n) }
+          results = names.index_with { |name| Utils::Cache.fetch("uni:#{name}") }.compact_blank
+          missing = names - results.keys
+          fetched = ::User.where("lower(name) IN (?)", missing).select(:id, :name).to_h { |u| [normalize_name(u.name), u.id] }
+          not_found = (missing - fetched.keys).index_with { nil }
+          fetched.each { |name, id| Utils::Cache.write("uni:#{name}", id, expires_in: 4.hours) }
+          { **results, **fetched, **not_found }
+        end
+
+        def name_or_id_to_id(name)
+          return name[1..].to_i if name =~ /\A!\d+\z/
+
+          ::User.name_to_id(name)
+        end
+
+        def name_or_id_to_id_forced(name)
+          return name.to_i if name =~ /\A\d+\z/
+
+          ::User.name_to_id(name)
+        end
+
+        def id_to_name(user_id)
+          RequestStore[:id_name_cache] ||= {}
+          return RequestStore[:id_name_cache][user_id] if RequestStore[:id_name_cache].key?(user_id)
+
+          name = Utils::Cache.fetch("uin:#{user_id}", expires_in: 4.hours) do
+            ::User.where(id: user_id).pick(:name) || YiffSpace.config.anonymous_user_name.call
+          end
+          RequestStore[:id_name_cache][user_id] = name
+          name
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/concerns/user_resolvable_methods.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module UserResolvableMethods
+      def resolvable(ip_addr = nil)
+        attr = YiffSpace.config.last_ip_addr_attribute
+        User::Resolvable.new(self, ip_addr || (attr && respond_to?(attr) ? send(attr) : nil) || YiffSpace.config.default_ip_address)
+      end
+
+      def resolve
+        self
+      end
+
+      def is?(user_or_id)
+        id == u2id(user_or_id)
+      end
+
+      def ==(other)
+        return super if other.is_a?(YiffSpace.config.user_class)
+
+        other.is_a?(YiffSpace.config.user_resolvable_class) && super(other.user)
+      end
+
+      def ===(other)
+        other == YiffSpace.config.user_like_class || super
+      end
+
+      def is_a?(other)
+        other == YiffSpace.config.user_like_class || super
+      end
+
+      include(YiffSpace::User::ToId)
+
+      private(:u2id)
+    end
+  end
+end

data/lib/yiffspace/serializers/user_resolvable_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require("active_job")
+
+module YiffSpace
+  module Serializers
+    class UserResolvableSerializer < ActiveJob::Serializers::ObjectSerializer
+      def serialize(arg)
+        super("user" => arg.user&.id, "ip_addr" => arg.ip_addr)
+      end
+
+      def deserialize(arg)
+        YiffSpace.config.user_resolvable_class.new(arg["user"].blank? ? nil : YiffSpace.config.user_class.find(arg["user"]), arg["ip_addr"])
+      end
+
+      def klass
+        YiffSpace.config.user_resolvable_class
+      end
+    end
+  end
+end

data/lib/yiffspace/user/attribute.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module User
+    # User class must have id_to_name & name_to_id methods, and global u2id method must exist
+    class Attribute
+      class CircularAliasError < StandardError; end
+      class CircularCloneError < StandardError; end
+      class DuplicateAttributeError < StandardError; end
+      class CloneError < StandardError; end
+      attr_reader(:klass, :attribute, :db, :ip, :optional, :clones, :overwrite, :aliases, :ignore_nil, :ar_options)
+
+      # noinspection RubyUnusedLocalVariable
+      def initialize(klass, attribute, db:, ip: !db, optional: !db, clones: [], clone: [], overwrite: false, aliases: [], alias: [], ignore_nil: false, **ar_options)
+        Attribute.class_setup(klass)
+        @klass = klass
+        @attribute = attribute.to_sym
+        @db = db
+        # noinspection RubySimplifyBooleanInspection
+        @ip = ip == true ? :"#{attribute}_ip_addr" : ip
+        @optional = optional
+        @clones = Array(clones.presence || clone).map(&:to_sym)
+        @overwrite = overwrite
+        @aliases = Array(aliases.presence || binding.local_variable_get(:alias)).map(&:to_sym)
+        @ignore_nil = ignore_nil
+        @ar_options = ar_options
+        if ar_options.any? && !db # rubocop:disable Style/IfUnlessModifier
+          Utils::TraceLogger.warn("UserAttribute", "Unexpected extra options for non-db attribute: #{ar_options.inspect}", ignore: [%r{/concerns/user_methods\.rb}, %r{/logical/user_attribute\.rb}])
+        end
+        @ar_options[:optional] = optional
+        @ar_options[:class_name] = "User"
+        validate_options!
+        klass.user_attributes[attribute] = self
+        define_methods
+      end
+
+      def validate_options!
+        raise(DuplicateAttributeError, "user attribute #{attribute} is already defined on #{klass}") if klass.user_attributes.key?(attribute)
+
+        validate_aliases!
+        validate_clones!
+      end
+
+      def validate_aliases!
+        return if aliases.empty?
+        raise(CircularAliasError, "aliases must not contain attribute (#{klass}.#{attribute}") if aliases.include?(attribute)
+      end
+
+      def validate_clones!
+        return if clones.empty?
+        raise(CircularCloneError, "clones must not contain attribute (#{klass}.#{attribute}") if clones.include?(attribute)
+        # TODO: implement clone validation logic
+      end
+
+      def validate_value!(value, type, record: nil)
+        return if value.nil?
+
+        case type
+        when :user
+          return if (optional || ignore_nil) && value.nil?
+          return if value.is_a?(::User)
+
+          if value.is_a?(::UserResolvable)
+            return if value.user.is_a?(::User)
+
+            raise(ArgumentError, "Expected User for UserResolvable.user in #{klass.name}##{attribute}, got #{value.user.inspect} (#{value.user.class.name})")
+          end
+          value_error("is invalid", "UserLike", attribute, value, record: record)
+        when :id
+          value_error("is invalid", "Integer", "#{attribute}_id", value, record: record) unless value.is_a?(Integer) || (value.is_a?(String) && /\A\d+\Z/.match?(value))
+        when :name
+          value_error("is invalid", "String", "#{attribute}_name", value, record: record) unless value.is_a?(String)
+        when :ip_addr
+          return if value.is_a?(IPAddr)
+
+          begin
+            IPAddr.new(value)
+          rescue IPAddr::InvalidAddressError
+            value_error("is invalid", "IPAddr", ip, value, record: record)
+          end
+        else
+          raise(ArgumentError, "Not sure how to validate #{type}")
+        end
+      end
+
+      def value_error(message, expected, attr, value, record: nil)
+        raise(ArgumentError, "Expected #{expected} for #{klass.name}.#{attr}=, got #{value.inspect} (#{value.class.name})") unless record.respond_to?(:errors) && record.errors.is_a?(ActiveModel::Errors)
+
+        record.errors.add(attr, message)
+      end
+
+      def define_methods # rubocop:disable Metrics/MethodLength
+        ua = self
+        klass.define_singleton_method(:"#{attribute}_attribute") { ua }
+        klass.belongs_to(attribute, **ar_options) if db
+        if (klass < ActiveModel::Validations) && ip && !optional
+          # klass.validates(attribute, presence: { message: "must exist" }) unless optional
+          klass.validates(ip, presence: true, if: -> { send("#{ua.attribute}_id").present? })
+        end
+        klass.define_method(attribute) do
+          if ua.db
+            value = super()
+          else
+            value = instance_variable_get(:"@#{ua.attribute}")
+            value = ua.get_clone_value(self) if value.blank?
+          end
+          return if value.blank?
+
+          if ua.ip && (ip_addr = send(ua.ip))
+            ::UserResolvable.new(value, ip_addr)
+          else
+            value
+          end
+        end
+        klass.define_method("#{attribute}=") do |value|
+          ua.validate_value!(value, :user, record: self)
+          if ua.clones.any?
+            ua.clones.each do |cattr|
+              ua.clone_value(self, cattr, value)
+            end
+          end
+
+          if value.is_a?(::UserResolvable)
+            send("#{ua.ip}=", value.ip_addr) if ua.ip
+            value = value.user
+          end
+
+          if ua.db
+            super(value)
+          else
+            instance_variable_set(:"@#{ua.attribute}", value)
+          end
+        end
+        klass.define_method("#{attribute}_id") do
+          if ua.db
+            read_attribute("#{ua.attribute}_id")
+          else
+            value = instance_variable_get(:"@#{ua.attribute}")&.id
+            value = ua.get_clone_value(self, :id) if value.blank?
+            value
+          end
+        end
+        klass.define_method("#{attribute}_id=") do |value|
+          ua.validate_value!(value, :id, record: self)
+          if ua.db
+            write_attribute("#{ua.attribute}_id", value)
+            Utils::TraceLogger.warn("UserAttribute", "#{ua.klass.name}.#{ua.attribute}_id= should not be used when clone is enabled (#{ua.clones.join(', ')})", ignore: [%r{/concerns/user_methods\.rb}, %r{/logical/user_attribute\.rb}]) if ua.clones.any?
+          else
+            value = ::User.find(value) if value.is_a?(Integer) || value.is_a?(String)
+            ua.clones.each do |cattr|
+              ua.clone_direct(self, cattr, value)
+            end
+            instance_variable_set(:"@#{ua.attribute}", value)
+          end
+        end
+        klass.define_method("#{attribute}_name") do
+          value = send("#{ua.attribute}_id")
+          return "Anonymous" if value.blank?
+
+          ::User.id_to_name(value)
+        end
+        klass.define_method("#{attribute}_name=") do |value|
+          ua.validate_value!(value, :name, record: self)
+          value = ::User.name_to_id(value)
+          return send("#{ua.attribute}_id=", value) if value.blank?
+
+          send("#{ua.attribute}=", ::User.find(value))
+        end
+        if ip
+          klass.define_method(ip) do
+            if ua.db
+              read_attribute(ua.ip)
+            else
+              value = instance_variable_get(:"@#{ua.ip}")
+              value = ua.get_clone_value(self, :ip_addr) if value.blank?
+              value
+            end
+          end
+          klass.define_method("#{ip}=") do |value|
+            ua.validate_value!(value, :ip_addr, record: self)
+            if ua.db
+              write_attribute(ua.ip, value)
+            else
+              value = value.to_s.strip if value.is_a?(String)
+              ua.clones.each do |cattr|
+                ua.clone_ip(self, cattr, value)
+              end
+              instance_variable_set(:"@#{ua.ip}", value)
+            end
+          end
+        end
+        klass.instance_exec do
+          scope("for_#{ua.attribute}", ->(value) { where(ua.db && ua.ar_options.key?(:foreign_key) ? ua.ar_options[:foreign_key] : "#{ua.attribute}_id" => u2id(value)) }) unless respond_to?("for_#{ua.attribute}")
+          scope("for_#{ua.attribute}_id", ->(value) { where(ua.db && ua.ar_options.key?(:foreign_key) ? ua.ar_options[:foreign_key] : "#{ua.attribute}_id" => value) }) unless respond_to?("for_#{ua.attribute}_id")
+          scope("for_#{ua.attribute}_name", ->(value) { where(ua.db && ua.ar_options.key?(:foreign_key) ? ua.ar_options[:foreign_key] : "#{ua.attribute}_id" => YiffSpace.config.user_class.name_to_id(value)) }) unless respond_to?("for_#{ua.attribute}_name")
+        end
+
+        aliases.each do |alias_attr|
+          create_alias(alias_attr)
+        end
+      end
+
+      def get_clone_value(record, type = nil)
+        attrs = klass.user_attributes.select { |_attr, options| options.clones.include?(attribute) }
+        value = nil
+        attrs.each_key do |cattr|
+          case type
+          when :id
+            value = record.send("#{cattr}_id")
+          when :ip_addr
+            value = record.send(attrs[cattr].ip) if attrs[cattr].ip
+          else
+            value = record.send(cattr)
+          end
+          break if value.present?
+        end
+        value
+      end
+
+      def clone_value(record, attr, value)
+        return record.send("#{attr}=", value) if overwrite
+
+        if record.respond_to?(:"#{attr}_id")
+          record.send(:"#{attr}=", value) if record.send(:"#{attr}_id").blank?
+        elsif record.respond_to?(attr)
+          record.send(:"#{attr}=", value) if record.send(attr).blank?
+        else
+          raise(CloneError, "Not sure how to clone to #{attr}, #{record.class} does not respond_to? #{attr}_id or #{attr}")
+        end
+      end
+
+      def clone_ip(record, attr, value)
+        ip_attr = klass.user_attributes.find { |uattr, _value| uattr == attr }&.second&.ip
+        raise(CloneError, "Not sure how to clone ip for #{attr}, no ip attribute defined") unless ip_attr
+
+        clone_direct(record, ip_attr, value)
+      end
+
+      def clone_direct(record, attr, value)
+        return record.send("#{attr}=", value) if overwrite
+
+        raise(CloneError, "Not sure how to clone to #{attr}, #{record.class} does not respond_to? #{attr}") unless record.respond_to?(attr)
+
+        record.send(:"#{attr}=", value) if record.send(attr).blank?
+      end
+
+      def create_alias(attr)
+        ua = self
+        klass.class_eval do
+          define_method(attr) { send(ua.attribute) }
+          define_method("#{attr}=") { |value| send("#{ua.attribute}=", value) }
+          define_method("#{attr}_id") { send("#{ua.attribute}_id") }
+          define_method("#{attr}_id=") { |value| send("#{ua.attribute}_id=", value) }
+          define_method("#{attr}_name") { send("#{ua.attribute}_name") }
+          define_method("#{attr}_name=") { |value| send("#{ua.attribute}_name=", value) }
+          if ua.ip
+            define_method("#{attr}_ip_addr") { send(ua.ip) }
+            define_method("#{attr}_ip_addr=") { |value| send("#{ua.ip}=", value) }
+          end
+        end
+      end
+
+      def self.class_setup(klass)
+        return if klass.method_defined?(:user_attributes)
+
+        klass.class_eval do
+          class_attribute(:user_attributes, default: {})
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/user/current.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module User
+    class Current < ActiveSupport::CurrentAttributes
+      attribute(:user, :ip_addr, :request)
+
+      def initialize
+        super
+        reset
+      end
+
+      after_reset do
+        attributes[:user]    = YiffSpace.config.anonymous_user_getter.call
+        attributes[:ip_addr] = YiffSpace.config.default_ip_address
+      end
+
+      def user
+        value = super
+        return value if value.is_a?(YiffSpace.config.user_resolvable_class) || !value.is_a?(YiffSpace.config.user_class)
+        return YiffSpace.config.user_resolvable_class.new(value, ip_addr) if ip_addr.present?
+
+        value
+      end
+
+      def user=(value)
+        if value.is_a?(YiffSpace.config.user_resolvable_class)
+          self.ip_addr = value.ip_addr
+          value = value.user
+        end
+        super
+      end
+
+      def self.scoped(user, ip_addr = YiffSpace.config.default_ip_address, &)
+        set(user: user, ip_addr: ip_addr, &)
+      end
+
+      def self.as_system(&)
+        scoped(YiffSpace.config.system_user_getter.call, &)
+      end
+    end
+  end
+end

data/lib/yiffspace/user/engine.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require("rails")
+
+module YiffSpace
+  module User
+    # No app/ of its own - this exists to register the UserResolvableSerializer with ActiveJob.
+    class Engine < ::Rails::Engine
+      config.root = File.expand_path("../../..", __dir__)
+
+      initializer("yiffspace.user.serializers") do
+        ActiveSupport.on_load(:active_job) do
+          ActiveJob::Serializers.add_serializers(Serializers::UserResolvableSerializer)
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/user/like.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module User
+    module Like
+    end
+  end
+end

data/lib/yiffspace/user/resolvable.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require("active_support/core_ext/module/delegation")
+require("active_support/core_ext/string/inflections")
+
+module YiffSpace
+  module User
+    class Resolvable
+      attr_reader(:user, :ip_addr)
+
+      def initialize(user, ip_addr, validate: true)
+        if user.is_a?(YiffSpace.config.user_resolvable_class)
+          Utils::TraceLogger.warn(self.class.name.demodulize, "Unexpectedly received #{user.class.name} for user argument")
+          user = recursive_resolve(user)
+        end
+        @user = user
+        ip_addr = ip_addr.to_s if ip_addr.is_a?(IPAddr)
+        @ip_addr = ip_addr
+        return unless validate
+        raise(ArgumentError, "Expected User for user argument, got #{user.inspect} (#{user.class.name})") unless user.is_a?(YiffSpace.config.user_class)
+        raise(ArgumentError, "Expected String for ip_addr argument, got #{ip_addr.inspect} (#{ip_addr.class.name})") unless ip_addr.is_a?(String)
+      end
+
+      alias resolve user
+
+      def resolvable(ip_addr = nil)
+        @ip_addr = ip_addr if ip_addr.present?
+        self
+      end
+
+      delegate(:recursive_resolve, to: :class)
+      delegate(:to_param, :serializable_hash, :as_json, :to_json, to: :user)
+      delegate_missing_to(:user, allow_nil: true)
+
+      # needed to allow passing the class around when creating records, active record attempts to call several methods on the provided record's class
+      class << self
+        delegate_missing_to(:User, allow_nil: false)
+      end
+
+      def self.recursive_resolve(resolvable)
+        result = resolvable
+        result = result.resolve while result.is_a?(YiffSpace.config.user_resolvable_class)
+        result
+      end
+
+      def ==(other)
+        return other == user if other.is_a?(YiffSpace.config.user_class)
+
+        other.is_a?(YiffSpace.config.user_resolvable_class) && user == other.user
+      end
+
+      def ===(other)
+        (other == YiffSpace.config.user_like_class && user.is_a?(YiffSpace.config.user_class)) || super
+      end
+
+      def is_a?(other)
+        (other == YiffSpace.config.user_like_class && user.is_a?(YiffSpace.config.user_class)) || super
+      end
+    end
+  end
+end

data/lib/yiffspace/user/to_id.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module User
+    module ToId
+      def u2id(value, klass = YiffSpace.config.user_class)
+        value.is_a?(klass) || (klass == YiffSpace.config.user_class && value.is_a?(YiffSpace.config.user_resolvable_class)) ? value.id : value
+      end
+    end
+  end
+end

data/lib/yiffspace/user/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module User
+    VERSION = "0.0.1"
+  end
+end

data/lib/yiffspace/user.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require("yiffspace/core")
+require("zeitwerk")
+
+loader = Zeitwerk::Loader.for_gem_extension(YiffSpace)
+loader.ignore("#{__dir__}/user/engine.rb")
+loader.setup
+
+# Require the engine eagerly so it registers with Rails before the host app's
+# active_support.initialize_per_engine_zeitwerk_loaders initializer runs.
+require_relative("user/engine") if defined?(Rails)
+
+module YiffSpace
+  class Configuration
+    # The application's User model class. Used by User::Current, Search::QueryDSL, etc.
+    # Falls back to ::User at call time when nil.
+    attr_writer(:user_class)
+
+    # The application's User model class. Used by User::Resolvable
+    # Falls back to ::UserLike at call time when nil.
+    attr_writer(:user_like_class)
+
+    # The application's UserResolvable class. Used by User::Current.
+    # Falls back to ::UserResolvable at call time when nil.
+    attr_writer(:user_resolvable_class)
+
+    # The CurrentAttributes class used to access the current user in model concerns.
+    # Defaults to YiffSpace::User::Current.
+    attr_writer(:current_class)
+
+    # The default IP address assigned to User::Current when none is present.
+    attr_accessor(:default_ip_address)
+
+    # The `last_ip_addr` attribute of the User model, used by the UserResolvableMethods concern
+    attr_accessor(:last_ip_addr_attribute)
+
+    # The anonymous user's name, can be a proc
+    attr_reader(:anonymous_user_name)
+
+    # Override the proc used to fetch the anonymous user. Must respond to #call.
+    # Default: -> { (user_class || ::User).anonymous }
+    attr_writer(:anonymous_user_getter)
+
+    # Override the proc used to fetch the system user. Must respond to #call.
+    # Default: -> { (user_class || ::User).system }
+    attr_writer(:system_user_getter)
+
+    def user_class
+      @user_class || ::User
+    end
+
+    def user_like_class
+      @user_like_class || User::Like
+    end
+
+    def user_resolvable_class
+      @user_resolvable_class || User::Resolvable
+    end
+
+    # Returns the configured current class, defaulting to YiffSpace::User::Current.
+    def current_class
+      @current_class || User::Current
+    end
+
+    # Lazily built: calls user_class (or ::User) at invocation time, not config time.
+    def anonymous_user_getter
+      @anonymous_user_getter ||= -> { user_class.anonymous }
+    end
+
+    # Lazily built: calls user_class (or ::User) at invocation time, not config time.
+    def system_user_getter
+      @system_user_getter ||= -> { user_class.system }
+    end
+
+    def anonymous_user_name=(value)
+      @anonymous_user_name = value.is_a?(Proc) ? value : -> { value }
+    end
+  end
+end
+
+YiffSpace.configure do |config|
+  config.default_ip_address     = "127.0.0.1"
+  config.last_ip_addr_attribute = :last_ip_addr
+  config.anonymous_user_name    = "Anonymous"
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: yiffspace-user
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Donovan_DMC
+bindir: bin
+cert_chain: []
+date: 2026-09-04 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: request_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: yiffspace-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: The User/Current/Resolvable concerns and utils, for https://yiff.space
+  and related projects
+email:
+- hewwo@yiff.rocks
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/yiffspace/concerns/current_methods.rb
+- lib/yiffspace/concerns/user_class_methods.rb
+- lib/yiffspace/concerns/user_methods.rb
+- lib/yiffspace/concerns/user_name_methods.rb
+- lib/yiffspace/concerns/user_resolvable_methods.rb
+- lib/yiffspace/serializers/user_resolvable_serializer.rb
+- lib/yiffspace/user.rb
+- lib/yiffspace/user/attribute.rb
+- lib/yiffspace/user/current.rb
+- lib/yiffspace/user/engine.rb
+- lib/yiffspace/user/like.rb
+- lib/yiffspace/user/resolvable.rb
+- lib/yiffspace/user/to_id.rb
+- lib/yiffspace/user/version.rb
+homepage: https://yiff.space
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://yiff.space
+  source_code_uri: https://github.com/YiffSpace/Gem/tree/master/yiffspace-user
+  changelog_uri: https://github.com/YiffSpace/Gem/blob/master/yiffspace-user/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: The User/Current/Resolvable concerns and utils, for https://yiff.space and
+  related projects
+test_files: []