yiffspace 0.1.8 → 0.2.0

data/lib/yiffspace/concerns/user_class_methods.rb

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

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Concerns
-    module UserMethods
-      extend(ActiveSupport::Concern)
-
-      module ClassMethods
-        def belongs_to_user(*, **)
-          UserAttribute.new(self, *, **, db: true)
-        end
-
-        def resolvable(*, **)
-          UserAttribute.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

@@ -1,53 +0,0 @@
-# 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)
-          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 = 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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Concerns
-    module UserResolvableMethods
-      def resolvable(ip_addr = nil)
-        attr = YiffSpace.config.last_ip_addr_attribute
-        UserResolvable.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::Utils::UserToId)
-
-      private(:u2id)
-    end
-  end
-end

data/lib/yiffspace/config_builder.rb

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-require("active_support/hash_with_indifferent_access")
-
-# This is intended to only be used externally, it is NOT reusable, do not use it within this project, or attempt to use it multiple times!!
-module YiffSpace
-  class ConfigBuilder
-    include(Singleton)
-
-    cattr_accessor(:list, default: [])
-    cattr_accessor(:env_set, default: ActiveSupport::HashWithIndifferentAccess.new)
-    cattr_accessor(:unset, default: [])
-    cattr_accessor(:required, default: [])
-    cattr_accessor(:reviver_map, default: ActiveSupport::HashWithIndifferentAccess.new)
-    cattr_accessor(:subconfigs, default: ActiveSupport::HashWithIndifferentAccess.new { |h, k| h[k] = {} })
-    cattr_accessor(:env_name, default: "CONFIG")
-
-    def self.config(name, type = :string, env: true, required: false, blank: false, &block)
-      name = name.to_sym
-      remove_config(name) if list.include?(name)
-      list << name
-      self.required << name if required
-      if block.nil?
-        unset << name
-        block = -> { raise(NotImplementedError, "Config option #{name} is not set") }
-      end
-      define_method(name) do |*args|
-        env_or_value(name, args, blank: blank, &block)
-      end
-      if type == :boolean
-        define_method("#{name}?") do |*args|
-          public_send(name, *args)
-        end
-      end
-      reviver(name, type) if type && type != :string
-      env_set[name] = env
-    end
-
-    def self.remove_config(name, reviver: false)
-      name = name.to_sym
-      list.delete(name)
-      required.delete(name)
-      unset.delete(name)
-      reviver_map.delete(name) if reviver
-      env_set.delete(name)
-      remove_method(name)
-      remove_method("#{name}?") if method_defined?("#{name}?")
-    end
-
-    def env_or_value(name, args, blank: false, &)
-      value = env(name)
-      value = nil if !value.nil? && value.blank? && !blank
-      if value.nil?
-        instance_exec(*args, &)
-      else
-        reviver = reviver_map.fetch(name, proc(&:itself))
-        instance_exec(value, *args, &reviver)
-      end
-    end
-
-    def env(name)
-      ENV.fetch("#{self.class.env_name}_#{name.to_s.upcase}", nil)
-    end
-
-    def self.reviver(name, type = nil, &block)
-      name = name.to_sym
-      if block
-        reviver_map[name] = block
-        return
-      end
-      method            = case type
-                          when :boolean
-                            ->(v) { !v.match?(/\A(false|f|no|n|off|0)\z/i) }
-                          when :integer, :number
-                            ->(v) { v.to_i }
-                          when :symbol
-                            ->(v) { v.to_sym }
-                          when :array
-                            ->(v) { v.split(/\s*,\s*/) }
-                          else
-                            raise(ArgumentError, "not sure how to revive #{type} for #{method}")
-                          end
-      reviver_map[name] = method
-    end
-
-    def self.subconfig(prefix, parent: [], &block)
-      raise(ArgumentError, "block required") unless block
-
-      prefix = prefix.to_sym
-      path   = parent + [prefix]
-
-      node = subconfigs
-      path.each do |p|
-        node[p] ||= {}
-        node    = node[p]
-      end
-
-      define_method(prefix) { SubconfigProxy.new(self, path) } unless method_defined?(prefix)
-
-      collector = Module.new do
-        def self.collected
-          @collected ||= []
-        end
-
-        def self.config(name, type = :string, env: true, required: false, blank: false, &block)
-          collected << [:config, name, type, env, required, blank, block]
-        end
-
-        def self.reviver(name, type = nil, &block)
-          collected << [:reviver, name, type, block]
-        end
-
-        def self.subconfig(name, &block)
-          collected << [:subconfig, name, block]
-        end
-      end
-
-      collector.module_eval(&block)
-
-      collector.collected.each do |kind, name, *args|
-        case kind
-        when :config
-          full = (path + [name]).join("_").to_sym
-          config(full, args[0], env: args[1], required: args[2], blank: args[3], &args[4])
-        when :reviver
-          full = (path + [name]).join("_").to_sym
-          reviver(full, args[0], &args[1])
-        when :subconfig
-          subconfig(name, parent: path, &args[0])
-        end
-      end
-    end
-
-    def self.ensure_required_set!
-      unset = []
-      required.each do |name|
-        value = begin
-          instance.public_send(name)
-        rescue StandardError
-          nil
-        end
-        unset << name if value.blank?
-      end
-
-      raise("Missing required configuration options: #{unset.join(', ')}") if unset.any?
-    end
-
-    def present?(*names)
-      names.flatten.all? { |name| public_send(name).present? }
-    end
-
-    class SubconfigProxy
-      def initialize(owner, path)
-        @owner = owner
-        @path  = path
-      end
-
-      def method_missing(name, *, &)
-        name      = name.to_sym
-        full_path = @path + [name]
-
-        flat = full_path.join("_").to_sym
-        return @owner.public_send(flat, *, &) if @owner.respond_to?(flat)
-
-        return SubconfigProxy.new(@owner, full_path) if subconfig_path?(full_path)
-
-        super
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        name = name.to_sym
-        flat = (@path + [name]).join("_").to_sym
-
-        @owner.respond_to?(flat, include_private) ||
-          subconfig_path?(@path + [name]) ||
-          super
-      end
-
-      private
-
-      def subconfig_path?(path)
-        node = ConfigBuilder.subconfigs
-        path.each do |p|
-          return false unless node.key?(p)
-
-          node = node[p]
-        end
-        true
-      end
-    end
-  end
-end

data/lib/yiffspace/configuration/fixer_templates.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  class Configuration
-    # Named presets for `bin/rails generate yiffspace:fixer`, so `--template <name>` (or a
-    # registered shortname flag) can stand in for `--steps N`. Populated two ways:
-    #
-    # - Automatically, from YiffSpace::FixerTemplate subclasses found in
-    #   YiffSpace.config.fixer_templates_path (the common case - see FixerTemplate).
-    # - Manually, via #register, for a preset that just needs a step count and no per-step
-    #   content (every step falls back to the generic fixer.rb template).
-    #
-    # See YiffSpace::Configuration#fixer_templates and Yiffspace::FixerGenerator.
-    class FixerTemplates
-      include(Enumerable)
-
-      Template = Struct.new(:name, :short, :content_blocks, keyword_init: true) do
-        def steps
-          content_blocks.size
-        end
-      end
-
-      # -t is yiffspace:fixer's own --template flag; -f/-p/-q/-s are Rails::Generators::Base's
-      # built-in runtime options (--force/--pretend/--quiet/--skip).
-      RESERVED_SHORTS = %w[t f p q s].freeze
-
-      def initialize
-        @templates = {}
-        @discovered = false
-      end
-
-      # short is optional - a template is always reachable via `--template <name>`, a shortname
-      # flag (e.g. `-e`) is just a convenient alias for it.
-      def register(name, steps:, short: nil)
-        raise(ArgumentError, "steps must be a positive integer, got #{steps.inspect}") unless steps.is_a?(Integer) && steps.positive?
-
-        add(name.to_s, short: short, content_blocks: Array.new(steps))
-      end
-
-      def [](name)
-        discover!
-        @templates[name.to_s]
-      end
-
-      def each(&)
-        discover!
-        @templates.each_value(&)
-      end
-
-      private
-
-      def add(name, short:, content_blocks:)
-        raise(ArgumentError, "a fixer template named #{name.inspect} is already registered") if @templates.key?(name)
-
-        short = short.to_s.delete_prefix("-") if short
-        if short
-          raise(ArgumentError, "\"-#{short}\" is reserved by yiffspace:fixer's own options") if RESERVED_SHORTS.include?(short)
-
-          existing = @templates.values.find { |template| template.short == short }
-          raise(ArgumentError, "\"-#{short}\" is already registered to the #{existing.name.inspect} fixer template") if existing
-        end
-
-        @templates[name] = Template.new(name: name, short: short, content_blocks: content_blocks)
-      end
-
-      # Scans YiffSpace.config.fixer_templates_path for YiffSpace::FixerTemplate subclasses and
-      # registers each one - runs once, the first time a template is looked up (#[] or #each),
-      # so it sees whatever the host app registered manually beforehand.
-      def discover!
-        return if @discovered
-
-        @discovered = true
-        path = YiffSpace.config.fixer_templates_path
-        return unless path && Dir.exist?(path)
-
-        before = FixerTemplate.subclasses
-        Dir[File.join(path, "*.rb")].each { |file| require(file) }
-
-        (FixerTemplate.subclasses - before).each do |klass|
-          raise(ArgumentError, "#{klass.name} has no step blocks - add at least one `step { ... }`") if klass.steps.empty?
-
-          add(klass.template_name, short: klass.short, content_blocks: klass.steps)
-        end
-      end
-    end
-  end
-end

data/lib/yiffspace/configuration/images.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  class Configuration
-    class Images
-      attr_accessor(:server_url, :update_token, :default_avatar_type, :default_banner_type, :httparty_options)
-
-      def initialize
-        @server_url          = "https://images.yiff.space"
-        @default_avatar_type = :discord
-        @default_banner_type = :discord
-        @httparty_options    = {
-          timeout:      10,
-          open_timeout: 5,
-          headers:      {
-            "User-Agent" => "YiffSpaceRuby/#{YiffSpace::VERSION} (https://yiff.space)",
-          },
-        }
-      end
-    end
-  end
-end

data/lib/yiffspace/configuration.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  class Configuration
-    # Maximum number of comma-separated values allowed in a multi-value query parameter.
-    # Used by ParseValue.range and QueryBuilder.
-    attr_reader(:max_multi_count)
-
-    # Redis URL used by Utils::Cache for direct Redis connections.
-    attr_reader(:redis_url)
-
-    # The application's User model class. Used by Utils::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 Utils::UserResolvable
-    # Falls back to ::UserLike at call time when nil.
-    attr_writer(:user_like_class)
-
-    # The application's UserResolvable class. Used by Utils::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::Utils::Current.
-    attr_writer(:current_class)
-
-    # The default IP address assigned to Utils::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)
-
-    # The application's ApplicationRecord class. Used by Concerns::ActiveRecordExtensions & Utils::TableBuilder.
-    # Falls back to ::ApplicationRecord at call time when nil.
-    attr_writer(:application_record_class)
-
-    # The application's ApplicationController class. Used by Utils::Helpers & Utils::TableBuilder.
-    # Falls back to ::ApplicationController at call time when nil.
-    attr_writer(:application_controller_class)
-
-    def initialize
-      @max_multi_count         = -> { 100 }
-      @redis_url               = -> {}
-      @user_class              = nil
-      @user_like_class         = nil
-      @user_resolvable_class   = nil
-      @current_class           = nil
-      @default_ip_address      = "127.0.0.1"
-      @last_ip_addr_attribute  = :last_ip_addr
-      @anonymous_user_name     = -> { "Anonymous" }
-    end
-
-    def user_class
-      @user_class || ::User
-    end
-
-    def user_like_class
-      @user_like_class || Utils::UserLike
-    end
-
-    def user_resolvable_class
-      @user_resolvable_class || Utils::UserResolvable
-    end
-
-    # Returns the configured current class, defaulting to YiffSpace::Utils::Current.
-    def current_class
-      @current_class || Utils::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 redis_url=(value)
-      @redis_url = value.is_a?(Proc) ? value : -> { value }
-    end
-
-    def max_multi_count=(value)
-      @max_multi_count = value.is_a?(Proc) ? value : -> { value }
-    end
-
-    def anonymous_user_name=(value)
-      @anonymous_user_name = value.is_a?(Proc) ? value : -> { value }
-    end
-
-    def application_record_class
-      @application_record_class || ::ApplicationRecord
-    end
-
-    def application_controller_class
-      @application_controller_class || ::ApplicationController
-    end
-
-    def images
-      @images ||= Images.new
-    end
-
-    # Named `--steps` presets for `bin/rails generate yiffspace:fixer`. See
-    # YiffSpace::Configuration::FixerTemplates.
-    def fixer_templates
-      @fixer_templates ||= FixerTemplates.new
-    end
-
-    # Directory scanned for YiffSpace::FixerTemplate subclasses (see FixerTemplate) - defaults to
-    # db/fixer_templates in the host app.
-    attr_writer(:fixer_templates_path)
-
-    def fixer_templates_path
-      @fixer_templates_path ||= Rails.root.join("db/fixer_templates")
-    end
-  end
-end

data/lib/yiffspace/core_ext/active_record/all.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require_relative("cross_join_lateral")
-require_relative("cross_unnest")
-require_relative("left_join_lateral")
-require_relative("left_unnest")
-require_relative("unnest")
-require_relative("where_chain")

data/lib/yiffspace/core_ext/active_record/cross_join_lateral.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require("active_record/relation")
-require_relative("../arel/cross_join_lateral")
-require_relative("../../extensions/active_record/cross_join_lateral")
-
-ActiveRecord::Relation.include(YiffSpace::Extensions::ActiveRecord::CrossJoinLateral)

data/lib/yiffspace/core_ext/active_record/cross_unnest.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require("active_record/relation")
-require_relative("unnest")
-require_relative("../../extensions/active_record/cross_unnest")
-
-ActiveRecord::Relation.include(YiffSpace::Extensions::ActiveRecord::CrossUnnest)

data/lib/yiffspace/core_ext/active_record/left_join_lateral.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require("active_record/relation")
-require_relative("../arel/left_join_lateral")
-require_relative("../../extensions/active_record/left_join_lateral")
-
-ActiveRecord::Relation.include(YiffSpace::Extensions::ActiveRecord::LeftJoinLateral)

data/lib/yiffspace/core_ext/active_record/left_unnest.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require("active_record/relation")
-require_relative("unnest")
-require_relative("../../extensions/active_record/left_unnest")
-
-ActiveRecord::Relation.include(YiffSpace::Extensions::ActiveRecord::LeftUnnest)

data/lib/yiffspace/core_ext/active_record/unnest.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require("active_record/relation")
-require_relative("cross_join_lateral")
-require_relative("left_join_lateral")
-require_relative("../../extensions/active_record/unnest")
-
-ActiveRecord::Relation.include(YiffSpace::Extensions::ActiveRecord::Unnest)