yiffspace-core 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 616274421a5c76dd24f3280528dba48846a7d8ffdbf2b6b77a8a9bc6ba243f5e
+  data.tar.gz: 49ef59c885784dc479dcc475a4bf55e24bf208a53e9a4288354a68072b2cfd1b
+SHA512:
+  metadata.gz: ae0ca898066aeb4781fc565f168189a42601476610b234bdf3fb3431a97dc275e2163a19db67fff2b10718b549bead50a715bcd721635f461d11028ae8b931d4
+  data.tar.gz: 7b358ed2a0c766ded8b197596eb768bcdfdc062d1f523f19bb271eda4259f484ce2aeaa7c48192600b1c11d44b91136772eae108a3a9ca594bb445305d475b70

data/CHANGELOG.md

@@ -0,0 +1,46 @@
+## Unreleased
+
+- **Breaking:** renamed the gem from `yiffspace` to `yiffspace-core`, and split
+  it further into standalone gems for complete modularity:
+  [`yiffspace-config`](https://github.com/YiffSpace/Gem/tree/master/yiffspace-config)
+  (`YiffSpace::ConfigBuilder`),
+  [`yiffspace-ext`](https://github.com/YiffSpace/Gem/tree/master/yiffspace-ext)
+  (generic Object/Hash/Enumerable/String core extensions + `WhereChain`),
+  [`yiffspace-arel`](https://github.com/YiffSpace/Gem/tree/master/yiffspace-arel)
+  (Postgres lateral-join/unnest extensions),
+  [`yiffspace-images`](https://github.com/YiffSpace/Gem/tree/master/yiffspace-images)
+  (avatar/banner URLs),
+  [`yiffspace-tables`](https://github.com/YiffSpace/Gem/tree/master/yiffspace-tables)
+  (`YiffSpace::Utils::TableBuilder`),
+  [`yiffspace-search`](https://github.com/YiffSpace/Gem/tree/master/yiffspace-search)
+  (`YiffSpace::Search::*`),
+  [`yiffspace-user`](https://github.com/YiffSpace/Gem/tree/master/yiffspace-user)
+  (the User/Current/UserResolvable concerns), and
+  [`yiffspace-include`](https://github.com/YiffSpace/Gem/tree/master/yiffspace-include)
+  (the deprecated global-alias layer). The `yiffspace` gem is now a husk that
+  just depends on all of the above, so `gem "yiffspace"` keeps working
+  unchanged for apps that want everything; apps that only need a subset can
+  depend on the specific gems instead.
+- **Breaking:** extracted the one-time db/fixes system (`YiffSpace::FixTracker`,
+  `YiffSpace::FixerTemplate`, `YiffSpace::Configuration::FixerTemplates`, the
+  `yiffspace:fixer`/`yiffspace:install:fixes` generators, and the `fixes:*`
+  rake tasks) into a separate gem,
+  [`yiffspace-fixers`](https://github.com/YiffSpace/Gem/tree/master/yiffspace-fixers).
+  Apps using the fixes system need to add that gem alongside `yiffspace`.
+- `YiffSpace::Configuration#fixer_templates`/`#fixer_templates_path` moved to
+  `yiffspace-fixers`.
+- The dummy test app no longer needs Postgres - only the fixes table's
+  `nulls_not_distinct` index required it, and that lives in `yiffspace-fixers`
+  now. Back to plain sqlite3, `docker-compose.yml` removed.
+
+## 0.1.0
+
+- **Breaking:** extracted the Logto auth engine (`YiffSpace::Auth::*`) into a
+  separate gem, [`yiffspace-auth`](https://github.com/YiffSpace/Auth.rb). Apps
+  using auth need to add that gem alongside `yiffspace`.
+- `YiffSpace::Configuration#auth`/`#add_auth`/`#add_default_auth` and the
+  `logto_api_*`/`discord_bot_token` settings moved to `yiffspace-auth`.
+- Replaced the dead `YiffSpace::Railtie` with a real `YiffSpace::Engine <
+  Rails::Engine`, so the shared `app/` directory (ApplicationController,
+  layout, error view, CSS, ActiveJob serializers) actually loads into host
+  apps again.

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,27 @@
+# YiffSpace::Core
+
+Core Rails engine, `YiffSpace::Configuration`, and shared concerns/utils for
+https://yiff.space and related projects. Everything else in the `yiffspace`
+family builds on this gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "yiffspace-core"
+```
+
+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,16 @@
+# frozen_string_literal: true
+
+require("bundler/setup")
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load("rails/tasks/engine.rake")
+
+load("rails/tasks/statistics.rake")
+
+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/app/assets/config/yiffspace_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/yiffspace .css

data/app/assets/stylesheets/yiffspace/application.css

@@ -0,0 +1,30 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */
+
+body {
+    background-color: #2C2F33;
+    color: #FFFDD0;
+    font-size: 2rem;
+}
+
+body div#page {
+    text-align: center;
+
+    ul.permissions-list {
+        display: inline-block;
+        text-align: left;
+    }
+}

data/app/controllers/yiff_space/application_controller.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/helpers/yiff_space/application_helper.rb

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

data/app/models/yiff_space/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/views/layouts/yiff_space/application.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>YiffSpace</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag("yiffspace/application", media: "all") %>
+</head>
+<body>
+
+<div id="page">
+  <%= yield %>
+</div>
+
+</body>
+</html>

data/app/views/yiff_space/error.html.erb

@@ -0,0 +1,3 @@
+<%# locals: (message:) %>
+<h1 class="title">Error</h1>
+<p class="message"><%= message %></p>

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
+          YiffSpace.config.application_record_class.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/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/configuration.rb

@@ -0,0 +1,43 @@
+# 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 (in yiffspace-search) QueryBuilder.
+    attr_reader(:max_multi_count)
+
+    # Redis URL used by Utils::Cache for direct Redis connections.
+    attr_reader(:redis_url)
+
+    # The application's ApplicationRecord class. Used by Concerns::ActiveRecordExtensions & (in
+    # yiffspace-tables) 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 & (in
+    # yiffspace-tables) Utils::TableBuilder.
+    # Falls back to ::ApplicationController at call time when nil.
+    attr_writer(:application_controller_class)
+
+    def initialize
+      @max_multi_count = -> { 100 }
+      @redis_url       = -> {}
+    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 application_record_class
+      @application_record_class || ::ApplicationRecord
+    end
+
+    def application_controller_class
+      @application_controller_class || ::ApplicationController
+    end
+  end
+end

data/lib/yiffspace/core/version.rb

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