yiffspace 0.0.1

data/lib/yiffspace/configuration/images.rb

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  class Configuration
+    def auth(&block)
+      client = YiffSpace::Auth.register(Auth::DEFAULT_CLIENT_NAME) unless YiffSpace::Auth.instance_variable_get(:@clients).key?(Auth::DEFAULT_CLIENT_NAME)
+      client ||= YiffSpace::Auth[Auth::DEFAULT_CLIENT_NAME]
+      block&.call(client)
+      client
+    end
+
+    def add_auth(name, &)
+      YiffSpace::Auth.register(name, &)
+    end
+
+    def images
+      @images ||= Images.new
+    end
+  end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield(config)
+    end
+  end
+end

data/lib/yiffspace/core_ext/action_dispatch/set_auth_client/scoped.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative("../../../extensions/action_dispatch/set_auth_client/scoped")
+
+module ActionDispatch
+  module Routing
+    class Mapper
+      module Scoping
+        include(YiffSpace::Extensions::ActionDispatch::SetAuthClient::Scoped)
+      end
+    end
+  end
+end

data/lib/yiffspace/core_ext/action_dispatch/set_auth_client.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/action_dispatch/set_auth_client")
+
+module ActionDispatch
+  module Routing
+    class Mapper
+      module Scoping
+        include(YiffSpace::Extensions::ActionDispatch::SetAuthClient)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative("where_chain")

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require("active_record/relation")
+require_relative("../../extensions/active_record/where_chain")
+
+ActiveRecord::QueryMethods::WhereChain.include(YiffSpace::Extensions::ActiveRecord::WhereChain)

data/lib/yiffspace/core_ext/all.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative("active_record/where_chain")
+require_relative("arel/all")
+require_relative("enumerable/all")
+require_relative("hash/all")
+require_relative("string/all")
+require_relative("open_hash")

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative("cross_join_lateral")
+require_relative("left_join_lateral")

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/arel/nodes/cross_join_lateral")
+require_relative("../../extensions/arel/visitors/postgresql/cross_join_lateral")
+require_relative("../../extensions/arel/table/cross_join_lateral")
+
+module Arel
+  module Nodes
+    CrossJoinLateral = YiffSpace::Extensions::Arel::Nodes::CrossJoinLateral
+  end
+
+  module Visitors
+    class PostgreSQL
+      include(YiffSpace::Extensions::Arel::Visitors::PostgreSQL::CrossJoinLateral)
+    end
+  end
+
+  class Table
+    include(YiffSpace::Extensions::Arel::Table::CrossJoinLateral)
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/arel/nodes/left_join_lateral")
+require_relative("../../extensions/arel/visitors/postgresql/left_join_lateral")
+require_relative("../../extensions/arel/table/left_join_lateral")
+
+module Arel
+  module Nodes
+    LeftJoinLateral = YiffSpace::Extensions::Arel::Nodes::LeftJoinLateral
+  end
+
+  module Visitors
+    class PostgreSQL
+      include(YiffSpace::Extensions::Arel::Visitors::PostgreSQL::LeftJoinLateral)
+    end
+  end
+
+  class Table
+    include(YiffSpace::Extensions::Arel::Table::LeftJoinLateral)
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative("parallel")

data/lib/yiffspace/core_ext/enumerable/parallel.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/enumerable/parallel")
+
+module Enumerable
+  include(YiffSpace::Extensions::Enumerable::Parallel)
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative("to_open_hash")

data/lib/yiffspace/core_ext/hash/to_open_hash.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/hash/to_open_hash")
+
+class Hash
+  include(YiffSpace::Extensions::Hash::ToOpenHash)
+end

data/lib/yiffspace/core_ext/open_hash.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+OpenHash = YiffSpace::Utils::OpenHash

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("sql")
+require_relative("to_b")
+require_relative("truthy_falsy")

data/lib/yiffspace/core_ext/string/sql.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/string/sql")
+
+class String
+  include(YiffSpace::Extensions::String::Sql)
+end

data/lib/yiffspace/core_ext/string/to_b.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/string/to_b")
+
+class String
+  include(YiffSpace::Extensions::String::ToB)
+end

data/lib/yiffspace/core_ext/string/truthy_falsy.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/string/truthy_falsy")
+
+class String
+  include(YiffSpace::Extensions::String::TruthyFalsy)
+end

data/lib/yiffspace/extensions/action_dispatch/set_auth_client/scoped.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module ActionDispatch
+      module SetAuthClient
+        module Scoped
+          def yiffspace_set_auth_client(name, &)
+            constraints(Auth::SetClientName.new(name), &)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/action_dispatch/set_auth_client.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module ActionDispatch
+      module SetAuthClient
+        def set_auth_client(name, &)
+          constraints(Auth::SetClientName.new(name), &)
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/active_record/where_chain.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module ActiveRecord
+      module WhereChain
+        %i[
+          lt lteq gt gteq
+          between not_between in not_in like
+          ilike not_like not_ilike
+          like_all ilike_all not_like_all not_ilike_all
+          like_any ilike_any not_like_any not_ilike_any
+          has_bits not_has_bits
+        ].each do |method|
+          define_method(method) do |conditions|
+            build(conditions, method)
+          end
+        end
+
+        alias lte lteq
+        alias gte gteq
+
+        # https://www.postgresql.org/docs/current/static/functions-matching.html#FUNCTIONS-POSIX-REGEXP
+        # "(?e)" means force use of ERE syntax; see sections 9.7.3.1 and 9.7.3.4.
+        def regex(conditions = {}, flags: "e", **kwargs)
+          conditions.merge!(kwargs) if conditions.is_a?(Hash)
+          build(conditions, :regex, flags)
+        end
+
+        def not_regex(conditions = {}, flags: "e", **kwargs)
+          conditions.merge!(kwargs) if conditions.is_a?(Hash)
+          build(conditions, :not_regex, flags)
+        end
+
+        def tsquery(conditions = {}, ts_config: "english", **kwargs)
+          conditions.merge!(kwargs) if conditions.is_a?(Hash)
+          build(conditions, :tsquery, ts_config)
+        end
+
+        METHODS = {
+          lt:            ->(table_name, column, value) { Arel::Table.new(table_name)[column].lt(value) },
+          lteq:          ->(table_name, column, value) { Arel::Table.new(table_name)[column].lteq(value) },
+          gt:            ->(table_name, column, value) { Arel::Table.new(table_name)[column].gt(value) },
+          gteq:          ->(table_name, column, value) { Arel::Table.new(table_name)[column].gteq(value) },
+          between:       ->(table_name, column, value) { Arel::Table.new(table_name)[column].between(value) },
+          not_between:   ->(table_name, column, value) { Arel::Table.new(table_name)[column].not_between(value) },
+          in:            ->(table_name, column, value) { Arel::Table.new(table_name)[column].in(value) },
+          not_in:        ->(table_name, column, value) { Arel::Table.new(table_name)[column].not_in(value) },
+          like:          ->(table_name, column, value) { Arel::Table.new(table_name)[column].matches(value.to_escaped_for_sql_like, Arel.sql("E'\\\\'"), true) },
+          ilike:         ->(table_name, column, value) { Arel::Table.new(table_name)[column].matches(value.to_escaped_for_sql_like, Arel.sql("E'\\\\'"), false) },
+          not_like:      ->(table_name, column, value) { Arel::Table.new(table_name)[column].does_not_match(value.to_escaped_for_sql_like, Arel.sql("E'\\\\'"), true) },
+          not_ilike:     ->(table_name, column, value) { Arel::Table.new(table_name)[column].does_not_match(value.to_escaped_for_sql_like, Arel.sql("E'\\\\'"), false) },
+          like_all:      ->(table_name, column, value) { Arel::Table.new(table_name)[column].matches_all(value.map(&:to_escaped_for_sql_like), Arel.sql("E'\\\\'"), true) },
+          ilike_all:     ->(table_name, column, value) { Arel::Table.new(table_name)[column].matches_all(value.map(&:to_escaped_for_sql_like), Arel.sql("E'\\\\'"), false) },
+          not_like_all:  ->(table_name, column, value) { Arel::Table.new(table_name)[column].does_not_match_all(value.map(&:to_escaped_for_sql_like), Arel.sql("E'\\\\'"), true) },
+          not_ilike_all: ->(table_name, column, value) { Arel::Table.new(table_name)[column].does_not_match_all(value.map(&:to_escaped_for_sql_like), Arel.sql("E'\\\\'"), false) },
+          like_any:      ->(table_name, column, value) { Arel::Table.new(table_name)[column].matches_any(value.map(&:to_escaped_for_sql_like), Arel.sql("E'\\\\'"), true) },
+          ilike_any:     ->(table_name, column, value) { Arel::Table.new(table_name)[column].matches_any(value.map(&:to_escaped_for_sql_like), Arel.sql("E'\\\\'"), false) },
+          not_like_any:  ->(table_name, column, value) { Arel::Table.new(table_name)[column].does_not_match_any(value.map(&:to_escaped_for_sql_like), Arel.sql("E'\\\\'"), true) },
+          not_ilike_any: ->(table_name, column, value) { Arel::Table.new(table_name)[column].does_not_match_any(value.map(&:to_escaped_for_sql_like), Arel.sql("E'\\\\'"), false) },
+          regex:         ->(table_name, column, value, flags) { Arel::Table.new(table_name)[column].matches_regexp("(?#{flags})#{value.is_a?(Regexp) ? value.source : value}") },
+          not_regex:     ->(table_name, column, value, flags) { Arel::Table.new(table_name)[column].does_not_match_regexp("(?#{flags})#{value.is_a?(Regexp) ? value.source : value}") },
+          tsquery:       ->(table_name, column, value, ts_config) { Arel.sql("to_tsvector(:ts_config, :table) @@ plainto_tsquery(:ts_config, :value)", ts_config: ts_config, value: value, table: Arel.sql("#{table_name}.#{column}")) },
+          has_bits:      ->(table_name, column, value) { Arel.sql("(#{table_name}.#{column} & #{Arel::Nodes.build_quoted(value).to_sql}) = #{Arel::Nodes.build_quoted(value).to_sql}") },
+          not_has_bits:  ->(table_name, column, value) { Arel.sql("(#{table_name}.#{column} & #{Arel::Nodes.build_quoted(value).to_sql}) != #{Arel::Nodes.build_quoted(value).to_sql}") },
+        }.freeze
+
+        private
+
+        def build(conditions, method, *extra)
+          model = @scope.klass
+
+          parsed_conditions = normalize_conditions(conditions, model)
+
+          arel_conditions = parsed_conditions.map do |(table_name, column), value|
+            METHODS.fetch(method).call(table_name, column, value, *extra)
+          end.reduce(:and)
+
+          @scope.where(arel_conditions)
+        end
+
+        def normalize_conditions(conditions, model, table_name = nil)
+          pairs = []
+
+          conditions.each do |key, value|
+            case key
+            when String, Symbol
+              key = key.to_s
+              if value.is_a?(Hash)
+                pairs.concat(normalize_conditions(value, model, key))
+              elsif key.include?(".")
+                table, col = key.split(".", 2)
+                pairs << [[table, col], value]
+              else
+                pairs << [[table_name || model.table_name, key], value]
+              end
+            else
+              raise(ArgumentError, "Unsupported key type: #{key.class}")
+            end
+          end
+
+          pairs
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/arel/nodes/cross_join_lateral.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require("arel")
+
+module YiffSpace
+  module Extensions
+    module Arel
+      module Nodes
+        class CrossJoinLateral < ::Arel::Nodes::Join
+          def initialize(left, right = nil)
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/arel/nodes/left_join_lateral.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require("arel")
+
+module YiffSpace
+  module Extensions
+    module Arel
+      module Nodes
+        class LeftJoinLateral < ::Arel::Nodes::Join
+          def initialize(left, right = nil)
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/arel/table/cross_join_lateral.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module Arel
+      module Table
+        module CrossJoinLateral
+          def cross_join_lateral(relation)
+            join(relation, ::Arel::Nodes::CrossJoinLateral)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/arel/table/left_join_lateral.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module Arel
+      module Table
+        module LeftJoinLateral
+          def left_join_lateral(relation)
+            join(relation, ::Arel::Nodes::LeftJoinLateral)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/arel/visitors/postgresql/cross_join_lateral.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module Arel
+      module Visitors
+        module PostgreSQL
+          module CrossJoinLateral
+            # noinspection RubyInstanceMethodNamingConvention
+            def visit_Arel_Nodes_CrossJoinLateral(o, collector)
+              collector << "CROSS JOIN LATERAL "
+              visit(o.left, collector)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/arel/visitors/postgresql/left_join_lateral.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module Arel
+      module Visitors
+        module PostgreSQL
+          module LeftJoinLateral
+            # noinspection RubyInstanceMethodNamingConvention
+            def visit_Arel_Nodes_LeftJoinLateral(o, collector)
+              collector << "LEFT JOIN LATERAL "
+              visit(o.left, collector)
+              return unless o.right
+
+              collector << " ON "
+              visit(o.right.expr, collector)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/enumerable/parallel.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require("active_support/core_ext/module/attribute_accessors")
+
+module YiffSpace
+  module Extensions
+    module Enumerable
+      module Parallel
+        mattr_accessor(:usable)
+        # Like `#each`, but perform the block on each item in parallel. Note that items aren't processed in order, so things
+        # like `parallel_each.map` that rely on ordering won't work.
+        def parallel_each(executor = :io, &)
+          return enum_for(:parallel_each, executor) unless block_given?
+
+          parallel_map(executor, &)
+          self
+        end
+
+        # Like `#map`, but in parallel.
+        def parallel_map(executor = :io, &)
+          return enum_for(:parallel_map, executor) unless block_given?
+
+          promises = map do |item|
+            Concurrent::Promises.future_on(executor, item, &)
+          end
+
+          Concurrent::Promises.zip_futures_on(executor, *promises).value!
+        end
+      end
+    end
+  end
+end
+
+begin
+  require("concurrent-ruby")
+  YiffSpace::Extensions::Enumerable::Parallel.usable = true
+rescue LoadError
+  YiffSpace::Extensions::Enumerable::Parallel.usable = false
+end

data/lib/yiffspace/extensions/hash/to_open_hash.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module Hash
+      module ToOpenHash
+        def to_open_hash
+          ::YiffSpace::Utils::OpenHash.from(self)
+        end
+
+        alias with_open_access to_open_hash
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/string/sql.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module String
+      module Sql
+        def to_escaped_for_sql_like
+          gsub(/%|_|\*|\\\*|\\\\|\\/) do |str|
+            case str
+            when "%" then '\%'
+            when "_" then '\_'
+            when "*" then "%"
+            when '\*' then "*"
+            when "\\\\", "\\" then "\\\\"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/string/to_b.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module String
+      module ToB
+        def to_b # rubocop:disable Naming/PredicateMethod
+          !match?(/\A(false|f|no|n|off|0)\z/i)
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/string/truthy_falsy.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module String
+      module TruthyFalsy
+        def truthy?
+          match?(/\A(true|t|yes|y|on|1)\z/i)
+        end
+
+        def falsy?
+          match?(/\A(false|f|no|n|off|0)\z/i)
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/images/avatar/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Images
+    module Avatar
+      class Base
+        def self.type = nil
+
+        attr_reader(:id, :type)
+
+        def initialize(id, type)
+          @id   = id
+          @type = type
+        end
+
+        def url
+          raise(NotImplementedError)
+        end
+
+        def update(*)
+          raise(NotImplementedError)
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/images/avatar/discord.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require("httparty")
+
+module YiffSpace
+  module Images
+    module Avatar
+      class Discord < Base
+        def self.type = :discord
+
+        def initialize(id)
+          super(id, self.class.type)
+        end
+
+        def url
+          "#{YiffSpace.config.images.server_url}/avatar/discord/#{id}"
+        end
+
+        def update(hash)
+          raise(StandardError, "images.update_token config option must be set to use avatar update") if YiffSpace.config.images.update_token.blank?
+
+          response = HTTParty.post("#{YiffSpace.config.images.server_url}/avatar/discord/update/#{id}",
+                                   YiffSpace.config.images.httparty_options.deep_merge(
+                                     headers: {
+                                       "Authorization" => "Bearer #{YiffSpace.config.images.update_token}",
+                                       "Content-Type"  => "application/json",
+                                     },
+                                     body:    { hash: hash }.to_json,
+                                   ))
+          Rails.logger.error("avatar update failed: #{response.to_json}") unless response.key?("updated")
+
+          response.fetch("updated", false)
+        end
+      end
+    end
+  end
+end