yiffspace 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d76f09af3606e844dc35e1d97ce80a14eb6d99a989d421ec0e8a81ba6a3735f7
-  data.tar.gz: b81ec5a4ad23d5e0606fd8247f5b09537078fb9fe271c3a72ac3442963b3554f
+  metadata.gz: aca3308a25bbf6b426ea3a8d52a9bfe7a41452cc7e500332accab52ee0d2fde0
+  data.tar.gz: 2cac0c503de3fa0141b0a923c0fadeb4225b01640b74dac33c8f743127a5273e
 SHA512:
-  metadata.gz: 39fcd8410ca585b80edd98ce465d62c188c54a967db2cd98158306c313deaf6b8ea73e3ab3208b2e3cf69100fad641a763a25eecefbbf4a1cc31474851619b3d
-  data.tar.gz: 776dd1d3c6c53d1746fd7f671a2ce9667263ee031a34a7329054e753d4415bb0f1cf3d5432c34c258059aeab3bc652fccd57c1b7ed6e6226aaddee94fc93b5cc
+  metadata.gz: 62946e5dfb3a8593ae125882c845652babac22b5d4b55cb421a8de1cf6503b1940ada9b1e00b640b3d3d0af4f8f8867be832c0600e4f2de18f5c7acff71b8182
+  data.tar.gz: bb2435f4fd6d6f7ab4b4d6d4110e90b4bf1aceb36109db94af99078f652a59acfdc569fbe28b57367de014aa5443d9b413ad3ecdceced070321979a2b5537ccd

data/lib/yiffspace/concerns/active_record_extensions.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module ActiveRecordExtensions
+      extend(ActiveSupport::Concern)
+
+      module ClassMethods
+        def without_timeout
+          original = statement_timeout
+          connection.execute("SET STATEMENT_TIMEOUT = 0") unless Rails.env.test?
+          yield
+        ensure
+          connection.execute("SET STATEMENT_TIMEOUT = #{original}") unless Rails.env.test?
+        end
+
+        def with_timeout(time, default_value = nil)
+          original = statement_timeout
+          connection.execute("SET STATEMENT_TIMEOUT = #{time}") unless Rails.env.test?
+          yield
+        rescue ::ActiveRecord::StatementInvalid => e
+          Rails.logger.warn("Statement timeout exceeded: #{e.message}")
+          default_value
+        ensure
+          connection.execute("SET STATEMENT_TIMEOUT = #{original}") unless Rails.env.test?
+        end
+
+        def statement_timeout
+          ApplicationRecord.connection.select_one("SELECT setting FROM pg_settings WHERE name = 'statement_timeout'")["setting"].to_i
+        end
+
+        # CrossJoinLateral, LeftJoinLateral, nil
+        def unnest(column, name: column.singularize, type: Arel::Nodes::LeftJoinLateral)
+          function = Arel::Nodes::NamedFunction.new("unnest", [arel(column)], name)
+          return function if type.nil?
+
+          joins(type.new(
+                  function,
+                  Arel::Nodes::On.new(Arel.sql("TRUE")),
+                ))
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/concerns/api_methods.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module ApiMethods
+      class NotVisibleError < StandardError; end
+      extend(ActiveSupport::Concern)
+
+      module ClassMethods
+        def available_includes
+          []
+        end
+
+        def multiple_includes
+          reflections.select { |_, v| v.macro == :has_many }.keys.map(&:to_sym)
+        end
+
+        def associated_models(name)
+          if reflections[name].options[:polymorphic]
+            reflections[name].active_record.try(:model_types) || []
+          else
+            [reflections[name].class_name]
+          end
+        end
+      end
+
+      delegate(:available_includes, to: :class)
+
+      # XXX deprecated, shouldn't expose this as an instance method.
+      def api_attributes(user)
+        policy = Pundit.policy(user, self) || ApplicationPolicy.new(user, self)
+        policy.api_attributes
+      end
+
+      # XXX deprecated, shouldn't expose this as an instance method.
+      def html_data_attributes(user)
+        policy = Pundit.policy(user, self) || ApplicationPolicy.new(user, self)
+        policy.html_data_attributes
+      end
+
+      def process_api_attributes(options, underscore: false)
+        options[:methods] ||= []
+        attributes, methods = api_attributes(options[:user]).partition { |attr| has_attribute?(attr) }
+        methods += options[:methods]
+        if underscore && options[:only].blank?
+          options[:only] = attributes + methods
+        else
+          options[:only] ||= attributes + methods
+        end
+
+        attributes &= options[:only]
+        methods &= options[:only]
+
+        options[:only] = attributes
+        options[:methods] = methods
+
+        options.delete(:methods) if options[:methods].empty?
+        options
+      end
+
+      def serializable_hash(options = {})
+        options ||= {}
+        options[:user] ||= CurrentUser.user || User.anonymous
+        return :not_visible unless visible?(options[:user])
+
+        if options[:only].is_a?(String)
+          options.delete(:methods)
+          options.delete(:include)
+          options.merge!(ParameterBuilder.serial_parameters(options[:only], self, options))
+          if options[:only].include?("_")
+            options[:only].delete("_")
+            options = process_api_attributes(options, underscore: true)
+          end
+        else
+          options = process_api_attributes(options)
+        end
+        options[:only] += [SecureRandom.hex(6)]
+
+        hash = super
+        hash.transform_keys! { |key| key.delete("?").delete_prefix("apionly_") }
+        deep_reject_hash(hash) { |_, v| v == :not_visible }
+      end
+
+      def visible?(_user)
+        true
+      end
+
+      def deep_reject_hash(hash, &block)
+        hash.each_with_object({}) do |(key, value), result|
+          if value.is_a?(Hash)
+            result[key] = deep_reject_hash(value, &block)
+          elsif value.is_a?(Array)
+            result[key] = value.map { |v| v.is_a?(Hash) ? deep_reject_hash(v, &block) : v }.reject { |i| block.call(nil, i) }
+          elsif !block.call(key, value)
+            result[key] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/concerns/attribute_matchers.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module AttributeMatchers
+      def boolean_attribute_matches(attribute, value, &)
+        return all if value.nil?
+
+        if value.to_s.truthy?
+          value = true
+        elsif value.to_s.falsy?
+          value = false
+        else
+          raise(ArgumentError, "value must be truthy or falsy")
+        end
+
+        q = block_given? ? yield : all
+        q.where(attribute => value)
+      end
+
+      # range: "5", ">5", "<5", ">=5", "<=5", "5..10", "5,6,7"
+      def numeric_attribute_matches(attribute, value, &)
+        return all if value.nil?
+
+        value = value.to_s.strip
+        column = QueryHelper.get_column(attribute, table_name)
+        parsed_range = ParseValue.range(value, column.type)
+
+        add_range_relation(parsed_range, attribute, &)
+      end
+
+      # datetime columns return ActiveSupport::TimeWithZone
+      def datetime_attribute_matches(attribute, range, &)
+        numeric_attribute_matches(attribute, range, &)
+      end
+
+      def add_range_relation(arr, field, &)
+        return all if arr.nil?
+
+        q = block_given? ? yield : all
+        case arr[0]
+        when :eq
+          if arr[1].is_a?(Time)
+            q.where.between(field => arr[1].all_day)
+          else
+            q.where(field => arr[1])
+          end
+        when :gt
+          q.where.gt(field => arr[1])
+        when :gte
+          q.where.gte(field => arr[1])
+        when :lt
+          q.where.lt(field => arr[1])
+        when :lte
+          q.where.lte(field => arr[1])
+        when :in
+          q.where.in(field => arr[1])
+        when :between
+          q.where.between(field => arr[1]..arr[2])
+        else
+          q.none
+        end
+      end
+
+      def text_attribute_matches(attribute, value, convert_to_wildcard: false, &)
+        return all if value.nil?
+
+        value = "*#{value}*" if convert_to_wildcard && value.exclude?("*")
+        q = block_given? ? yield : all
+        if value.is_a?(Array)
+          q.where.ilike_any(attribute => value)
+        elsif value =~ /\*/
+          q.where.ilike(attribute => value)
+        else
+          q.where.tsquery(attribute => value)
+        end
+      end
+
+      def ip_attribute_matches(attribute, value, &)
+        return all if value.nil?
+
+        q = block_given? ? yield : all
+        q.where.inet_contained_within_or_equals(attribute => value)
+      end
+
+      def attribute_present(attribute, value, &)
+        return all if value.nil?
+
+        q = block_given? ? yield : all
+        if value.to_s.truthy?
+          q.where.not(attribute => nil)
+        elsif value.to_s.falsy?
+          q.where(attribute => nil)
+        else
+          q.none
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/concerns/attribute_methods.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module AttributeMethods
+      extend(ActiveSupport::Concern)
+
+      module ClassMethods
+        # Defines `<attribute>_string`, `<attribute>_string=`, and `<attribute>=`
+        # methods for converting an array attribute to or from a string.
+        #
+        # The `<attribute>=` setter parses strings into an array using the
+        # `parse` regex. The resulting strings can be converted to another type
+        # with the `cast` option.
+        def array_attribute(name, parse: /[^[:space:]]+/, join_character: " ", cast: :itself)
+          define_method("#{name}_string") do
+            send(name).join(join_character)
+          end
+
+          define_method("#{name}_string=") do |value|
+            raise(ArgumentError, "#{name} must be a String") unless value.respond_to?(:to_str)
+
+            send("#{name}=", value)
+          end
+
+          define_method("#{name}=") do |value|
+            if value.respond_to?(:to_str)
+              super(value.to_str.scan(parse).flatten.map(&cast))
+            elsif value.respond_to?(:to_a)
+              super(value.to_a)
+            else
+              raise(ArgumentError, "#{name} must be a String or an Array")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/concerns/concurrency_methods.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module ConcurrencyMethods
+      extend(ActiveSupport::Concern)
+
+      class_methods do
+        def parallel_find_each(**, &)
+          # XXX We may deadlock if a transaction is open; do a non-parallel each.
+          return find_each(&) if connection.transaction_open?
+
+          find_in_batches(error_on_ignore: true, **) do |batch|
+            batch.parallel_each(&)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/concerns/conditional_includes.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module ConditionalIncludes
+      extend(ActiveSupport::Concern)
+
+      module ClassMethods
+        def html_includes(request, *)
+          includes_if(request.format.html?, *)
+        end
+
+        def includes_if(condition, *)
+          return all unless condition
+
+          includes(*)
+        end
+
+        def includes_unless(condition, *)
+          return all if condition
+
+          includes(*)
+        end
+
+        def html_preload(request, *)
+          preload_if(request.format.html?, *)
+        end
+
+        def preload_if(condition, *)
+          return all unless condition
+
+          preload(*)
+        end
+
+        def preload_unless(condition, *)
+          return all if condition
+
+          preload(*)
+        end
+      end
+    end
+  end
+end

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/has_bit_flags.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Concerns
+    module HasBitFlags
+      extend(ActiveSupport::Concern)
+
+      module ClassMethods
+        # NOTE: the ordering of attributes has to be fixed
+        # new attributes should be appended to the end.
+        def has_bit_flags(attributes, options = {})
+          field = options[:field] || :bit_flags
+
+          define_singleton_method("flag_value_for") do |key|
+            value = attributes[key.to_s]
+            return value if value
+
+            raise(ArgumentError, "Invalid flag: #{key}")
+          end
+
+          attributes.each do |name, value|
+            scope(name.to_sym, -> { where.has_bits(field => value) })
+            define_method(name) do
+              send(field) & value == value
+            end
+
+            define_method("#{name}=") do |val|
+              if val.to_s =~ /[t1y]/
+                send("#{field}=", send(field) | value)
+              else
+                send("#{field}=", send(field) & ~value)
+              end
+            end
+
+            define_method("#{name}_was") do
+              send("#{field}_was") & value == value
+            end
+
+            define_method("#{name}_before_last_save") do
+              send("#{field}_before_last_save") & value == value
+            end
+
+            alias_method("#{name}?", name)
+            alias_method("#{name}_before_last_save?", "#{name}_before_last_save")
+            alias_method("#{name}_was?", "#{name}_was")
+
+            define_method("#{name}_changed?") do
+              send("#{name}_was") != send(name)
+            end
+
+            define_method("saved_change_to_#{name}?") do
+              send("#{name}_before_last_save") != send(name)
+            end
+          end
+        end
+      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(*, **)
+          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

@@ -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)
+          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