yiffspace 0.1.7 → 0.2.0

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

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

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

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

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

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Extensions
-    module Arel
-      module Visitors
-        module PostgreSQL
-          module CrossJoinLateral
-            # noinspection RubyInstanceMethodNamingConvention
-            def visit_YiffSpace_Extensions_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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Extensions
-    module Arel
-      module Visitors
-        module PostgreSQL
-          module LeftJoinLateral
-            # noinspection RubyInstanceMethodNamingConvention
-            def visit_YiffSpace_Extensions_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

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

@@ -1,15 +0,0 @@
-# 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/object/to_b.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Extensions
-    module Object
-      module ToB
-        def to_b
-          case self
-          when ::String
-            !match?(/\A(false|f|no|n|off|0)\z/i)
-          when ::TrueClass
-            true
-          when ::FalseClass
-            false
-          else
-            to_s.to_b
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Extensions
-    module Object
-      module TruthyFalsy
-        def truthy?
-          case self
-          when ::String
-            match?(/\A(true|t|yes|y|on|1)\z/i)
-          when ::TrueClass
-            true
-          when ::FalseClass
-            false
-          else
-            to_s.truthy?
-          end
-        end
-
-        def falsy?
-          case self
-          when ::String
-            match?(/\A(false|f|no|n|off|0)\z/i)
-          when ::TrueClass
-            false
-          when ::FalseClass
-            true
-          else
-            to_s.falsy?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-# 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/images/avatar/base.rb

@@ -1,41 +0,0 @@
-# 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
-
-        def serializable_hash(*)
-          { "id" => @id, "type" => @type }
-        end
-
-        def self.from_json(data)
-          raise(ArgumentError, "invalid data") if data.blank?
-
-          data = JSON.parse(data) if data.is_a?(String)
-          data = ::YiffSpace::Utils::OpenHash.from(data)
-
-          return Avatar.find_type(data.type).from_json(data) if self == Base
-
-          new(data.id)
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require("httparty")
-
-module YiffSpace
-  module Images
-    module Avatar
-      class Gravatar < Base
-        def self.type = :gravatar
-
-        def initialize(id)
-          super(id, self.class.type)
-        end
-
-        def url
-          "#{YiffSpace.config.images.server_url}/avatar/gravatar/#{id}"
-        end
-      end
-    end
-  end
-end

data/lib/yiffspace/images/avatar.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Images
-    module Avatar
-      module_function
-
-      def default_for(id)
-        type = YiffSpace.config.images.default_avatar_type
-        get_for(id, type)
-      end
-
-      def get_for(id, type)
-        klass = find_type(type)
-        raise(StandardError, "No avatar class for type: #{type}") if klass.nil?
-
-        klass.new(id)
-      end
-
-      def find_type(type)
-        constants.map { |c| [c, const_get(c)] }.find do |_const, value|
-          next unless value < Base
-
-          value.try(:type)&.to_sym == type.to_sym
-        end&.second
-      end
-
-      def find_type!(type)
-        find_type(type) || raise(StandardError, "No avatar class for type: #{type}")
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Images
-    module Banner
-      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
-
-        def serializable_hash(*)
-          { "id" => @id, "type" => @type }
-        end
-
-        def self.from_json(data)
-          raise(ArgumentError, "invalid data") if data.blank?
-
-          data = JSON.parse(data) if data.is_a?(String)
-          data = ::YiffSpace::Utils::OpenHash.from(data)
-
-          return Banner.find_type(data.type).from_json(data) if self == Base
-
-          new(data.id)
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require("httparty")
-
-module YiffSpace
-  module Images
-    module Banner
-      class Discord < Base
-        def self.type = :discord
-
-        def initialize(id)
-          super(id, self.class.type)
-        end
-
-        def url
-          "#{YiffSpace.config.images.server_url}/banner/discord/#{id}"
-        end
-
-        def update(hash)
-          raise(StandardError, "images.update_token config option must be set to use banner update") if YiffSpace.config.images.update_token.blank?
-
-          response = HTTParty.post("#{YiffSpace.config.images.server_url}/banner/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("banner update failed: #{response.to_json}") unless response.key?("updated")
-
-          response.fetch("updated", false)
-        end
-      end
-    end
-  end
-end

data/lib/yiffspace/images/banner.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Images
-    module Banner
-      module_function
-
-      def default_for(id)
-        type = YiffSpace.config.images.default_banner_type
-        get_for(id, type)
-      end
-
-      def get_for(id, type)
-        klass = find_type(type)
-        raise(StandardError, "No banner class for type: #{type}") if klass.nil?
-
-        klass.new(id)
-      end
-
-      def find_type(type)
-        constants.map { |c| [c, const_get(c)] }.find do |_const, value|
-          next unless value < Base
-
-          value.try(:type)&.to_sym == type.to_sym
-        end&.second
-      end
-
-      def find_type!(type)
-        find_type(type) || raise(StandardError, "No banner class for type: #{type}")
-      end
-    end
-  end
-end

data/lib/yiffspace/images.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module YiffSpace
-  module Images
-  end
-end

data/lib/yiffspace/include/active_record_extensions.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require_relative("../concerns/active_record_extensions")
-
-ActiveRecordExtensions = YiffSpace::Concerns::ActiveRecordExtensions

data/lib/yiffspace/include/all.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative("active_record_extensions")
-require_relative("api_methods")
-require_relative("attribute_matchers")
-require_relative("attribute_methods")
-require_relative("cache")
-require_relative("concurrency_methods")
-require_relative("conditional_includes")
-require_relative("current")
-require_relative("current_methods")
-require_relative("duration_parser")
-require_relative("has_bit_flags")
-require_relative("helpers")
-require_relative("open_hash")
-require_relative("parameter_builder")
-require_relative("parse_value")
-require_relative("query_builder")
-require_relative("query_dsl")
-require_relative("query_helper")
-require_relative("routes")
-require_relative("table_builder")
-require_relative("trace_logger")
-require_relative("u2id")
-require_relative("user_attribute")
-require_relative("user_class_methods")
-require_relative("user_like")
-require_relative("user_methods")
-require_relative("user_name_methods")
-require_relative("user_resolvable")
-require_relative("user_resolvable_methods")

data/lib/yiffspace/include/api_methods.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require_relative("../concerns/api_methods")
-
-ApiMethods = YiffSpace::Concerns::ApiMethods

data/lib/yiffspace/include/attribute_matchers.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require_relative("../concerns/attribute_matchers")
-
-AttributeMatchers = YiffSpace::Concerns::AttributeMatchers

data/lib/yiffspace/include/attribute_methods.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require_relative("../concerns/attribute_methods")
-
-AttributeMethods = YiffSpace::Concerns::AttributeMethods