yiffspace 0.1.8 → 0.2.0

data/lib/generators/yiffspace/fixer/fixer_generator.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Yiffspace
-  # Scaffolds a new db/fixes/*.rb script for YiffSpace::FixTracker (see `rake fixes:list`).
-  #
-  # `--steps N` splits the fix into N ordered steps sharing an id, each one a copy of the generic
-  # fixer.rb template. A host app can instead define a YiffSpace::FixerTemplate subclass (see that
-  # class) to control both the step count and each step's file content, auto-discovered from
-  # YiffSpace.config.fixer_templates_path - reachable here with `--template <name>`/`-t <name>`,
-  # or with the template's own shortname flag if it registered one (e.g. `-e`).
-  class FixerGenerator < Rails::Generators::NamedBase
-    source_root(File.expand_path("templates", __dir__))
-    # No short alias - -s/-f/-p/-q are already claimed by Rails::Generators::Base's own runtime
-    # options (--skip/--force/--pretend/--quiet), and Thor silently lets the last-defined
-    # class_option win a collision instead of erroring.
-    class_option(:steps, type: :numeric, default: 1,
-                          desc: "Split the fix into N ordered steps sharing an id, e.g. 12_1_name.rb, 12_2_name.rb")
-    class_option(:template, type: :string, default: nil, aliases: ["-t"],
-                             desc: "Use a fixer template registered with YiffSpace.config.fixer_templates")
-
-    YiffSpace.config.fixer_templates.each do |template|
-      next unless template.short
-
-      class_option(template.name.to_sym, type: :boolean, default: false, aliases: ["-#{template.short}"],
-                                          desc: "Shortcut for --template #{template.name}")
-    end
-
-    def create_fixer
-      content_blocks = resolve_content_blocks
-
-      id = Dir[File.join(destination_root, "db/fixes/*.rb")].map { |f| File.basename(f, ".rb").split("_").first.to_i }.max.to_i + 1
-
-      if content_blocks.size == 1
-        create_fixer_file("db/fixes/#{id}_#{file_name}.rb", content_blocks.first)
-      else
-        content_blocks.each_with_index { |block, index| create_fixer_file("db/fixes/#{id}_#{index + 1}_#{file_name}.rb", block) }
-      end
-    end
-
-    private
-
-    # One entry per step - a block returning that step's file content, or nil to fall back to
-    # copying the generic fixer.rb template (a plain --steps N, or a manually
-    # YiffSpace.config.fixer_templates.register'd template, has no per-step content).
-    def resolve_content_blocks
-      template = resolve_template
-      return template.content_blocks if template
-
-      Array.new(steps_from_flag)
-    end
-
-    def resolve_template
-      name = template_name
-      return nil if name.nil?
-
-      template = YiffSpace.config.fixer_templates[name]
-      raise(Thor::Error, "no fixer template named #{name.inspect} is registered") unless template
-
-      template
-    end
-
-    # The template chosen via `--template <name>`, or via a registered template's own shortname
-    # flag (e.g. `-e` for a template registered with `short: "e"`) - nil if neither was passed.
-    def template_name
-      return options["template"] if options["template"]
-
-      YiffSpace.config.fixer_templates.find { |template| template.short && options[template.name] }&.name
-    end
-
-    def steps_from_flag
-      steps = options["steps"].to_i
-      raise(Thor::Error, "--steps must be at least 1") if steps < 1
-
-      steps
-    end
-
-    def create_fixer_file(path, content_block)
-      if content_block
-        create_file(path, content_block.call)
-        chmod(path, "+x")
-      else
-        copy_file("fixer.rb", path, mode: :preserve)
-      end
-    end
-  end
-end

data/lib/generators/yiffspace/fixer/templates/fixer.rb

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require(File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "config", "environment")))

data/lib/generators/yiffspace/install/fixes_generator.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Yiffspace
-  module Install
-    # Installs YiffSpace::FixTracker into a host app: `bin/rails generate yiffspace:install:fixes`
-    # copies the `fixes` tracking table migration. Run `bin/rails db:migrate` afterwards.
-    class FixesGenerator < Rails::Generators::Base
-      include(Rails::Generators::Migration)
-
-      source_root(File.expand_path("templates", __dir__))
-
-      def self.next_migration_number(dirname)
-        ActiveRecord::Migration.next_migration_number(current_migration_number(dirname) + 1)
-      end
-
-      def create_migration_file
-        migration_template("create_fixes.rb.erb", "db/migrate/create_fixes.rb")
-      end
-    end
-  end
-end

data/lib/generators/yiffspace/install/templates/create_fixes.rb.erb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-# Tracks which db/fixes/*.rb scripts have been applied, the same way schema_migrations tracks
-# migrations - see YiffSpace::FixTracker and `rake fixes:migrate`/`rake fixes:list`.
-#
-# `id` is the fix's own leading number (e.g. 12, 23), not a surrogate key, so it isn't unique on
-# its own - a fix can be split into ordered sub-steps (12_1, 12_2, ...) that share an id and are
-# distinguished by `index`. `index` is null for fixes with no subtype.
-class CreateFixes < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
-  def change
-    create_table(:fixes, id: false) do |t|
-      t.integer(:id, null: false) # not a surrogate key, this is the fix's own leading number
-      t.integer(:index)
-    end
-
-    add_index(:fixes, %i[id index], unique: true, nulls_not_distinct: true)
-  end
-end

data/lib/tasks/fixes.rake

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-# Keep structure.sql's fixes rows in sync with the database on every schema dump, the same way
-# ActiveRecord keeps schema_migrations rows in sync - not just when `fixes:migrate` runs.
-Rake::Task["db:schema:dump"].enhance do
-  YiffSpace::FixTracker.dump_structure_sql!
-end
-
-namespace(:fixes) do
-  desc("List available fix scripts in db/fixes, marking which have already been applied")
-  task(list: :environment) do
-    applied = YiffSpace::FixTracker.applied
-    YiffSpace::FixTracker.all_fixes.each do |name|
-      puts("#{applied.include?(YiffSpace::FixTracker.key_for(name)) ? '[x]' : '[ ]'} #{name}")
-    end
-  end
-
-  desc("Run a fix script from db/fixes by id or name, e.g. `rake fixes:run[1]` - re-runs even if already recorded as applied")
-  task(:run, [:name] => :environment) do |_task, args|
-    name = args[:name].to_s.delete_suffix(".rb")
-    abort("Usage: rake fixes:run[id_or_name] (see `rake fixes:list`)") if name.blank?
-
-    candidates = Dir["db/fixes/*.rb"]
-    exact = candidates.find { |path| File.basename(path, ".rb") == name }
-    matches = exact ? [exact] : candidates.select { |path| File.basename(path, ".rb").start_with?("#{name}_") || File.basename(path, ".rb").include?(name) }
-
-    if matches.empty?
-      abort("No fix matches \"#{name}\". Run `rake fixes:list` to see available fixes.")
-    elsif matches.size > 1
-      abort("Multiple fixes match \"#{name}\", be more specific:\n#{matches.map { |m| "  #{File.basename(m, '.rb')}" }.join("\n")}")
-    end
-
-    puts("Running #{File.basename(matches.first, '.rb')}...")
-    name = YiffSpace::FixTracker.run!(matches.first)
-    puts("Recorded #{name} as applied")
-  end
-
-  desc("Apply all fix scripts not yet recorded as applied, in order, then dump the schema like db:migrate does")
-  task(migrate: :environment) do
-    pending = YiffSpace::FixTracker.pending
-
-    if pending.empty?
-      puts("No pending fixes.")
-    else
-      pending.each do |name|
-        puts("Running #{name}...")
-        YiffSpace::FixTracker.run!(YiffSpace::FixTracker.fix_path(name))
-        puts("Recorded #{name} as applied")
-      end
-    end
-
-    Rake::Task["db:_dump"].invoke
-  end
-
-  desc("Record all of the current fixes as having been applied")
-  task(load: :environment) do
-    list = YiffSpace::FixTracker.all_fixes.map { YiffSpace::FixTracker.key_for(it) }
-    existing = ActiveRecord::Base.connection.select_all('SELECT id, "index" FROM fixes ORDER BY id, "index"').rows
-    list.reject! { |id, index| existing.any? { |e| e[0] == id && e[1] == index } }
-    unless list.empty?
-      values = list.map { |id, index| "(#{id}, #{index.nil? ? 'NULL' : index})" }.join(", ")
-      ActiveRecord::Base.connection.execute(%(INSERT INTO fixes (id, "index") VALUES #{values}))
-    end
-    puts("Loaded #{list.length} #{'fix'.pluralize(list.length)}")
-  end
-end

data/lib/yiffspace/concerns/active_record_extensions.rb

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

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

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

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

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

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

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

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