yiffspace-core 0.2.0

data/lib/yiffspace/core.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require("zeitwerk")
+require("active_support/all")
+require("active_support/core_ext/object/blank")
+
+module YiffSpace
+  module Core
+  end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield(config)
+    end
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem_extension(YiffSpace)
+loader.ignore("#{__dir__}/engine.rb")
+loader.setup
+
+# Require the engine eagerly so it registers with Rails before the host app's
+# active_support.initialize_per_engine_zeitwerk_loaders initializer runs. Without this,
+# the engine is only loaded lazily (after Zeitwerk setup) and its app/controllers
+# path is never added to the app's autoload roots.
+require_relative("engine") if defined?(Rails)

data/lib/yiffspace/engine.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require("rails")
+
+module YiffSpace
+  class Engine < ::Rails::Engine
+    config.root = File.expand_path("../..", __dir__)
+
+    initializer("yiffspace.assets") do |app|
+      app.config.assets.precompile += %w[yiffspace/application.css] if app.config.respond_to?(:assets)
+    end
+  end
+end

data/lib/yiffspace/utils/cache.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    module Cache
+      module_function
+
+      def read_multi(keys, prefix)
+        sanitized_key_to_key_hash = keys.index_by { |key| "#{prefix}:#{key}" }
+
+        sanitized_keys = sanitized_key_to_key_hash.keys
+        sanitized_key_to_value_hash = Rails.cache.read_multi(*sanitized_keys)
+
+        sanitized_key_to_value_hash.transform_keys(&sanitized_key_to_key_hash)
+      end
+
+      def fetch(key, expires_in: nil, &)
+        Rails.cache.fetch(key, expires_in: expires_in, &)
+      end
+
+      def write(key, value, expires_in: nil)
+        Rails.cache.write(key, value, expires_in: expires_in)
+      end
+
+      def delete(key)
+        Rails.cache.delete(key)
+      end
+
+      def clear
+        Rails.cache.clear
+      end
+
+      def redis
+        # Using a shared variable like this here is OK
+        # since pitchfork spawns a new process for each worker
+        @redis ||= Redis.new(url: YiffSpace.config.redis_url.call)
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/duration_parser.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require("abbrev")
+
+module YiffSpace
+  module Utils
+    module DurationParser
+      def self.parse(string)
+        abbrevs = Abbrev.abbrev(%w[seconds minutes hours days weeks months years])
+
+        raise unless string =~ /(.*?)([a-z]+)\z/i
+
+        size = Float($1)
+        unit = abbrevs.fetch($2.downcase)
+
+        raise(NotImplementedError) unless %w[seconds minutes hours days weeks months years].include?(unit)
+
+        size.public_send(unit)
+      rescue # rubocop:disable Style/RescueStandardError
+        raise(ArgumentError, "'#{string}' is not a valid duration")
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/helpers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    module Helpers
+      module_function
+
+      # Uses send/respond_to?(name, true) (not public_send/respond_to?(name)) because host apps
+      # commonly call helpers through this proxy with an explicit receiver (e.g. a decorator's
+      # `h.some_helper`), including ones marked private in their helper module - private only
+      # restricts calling with an explicit receiver, and normal view rendering (which invokes
+      # helpers without one) isn't affected either way.
+      def method_missing(name, *, &)
+        helpers = YiffSpace.config.application_controller_class.helpers
+        return helpers.send(name, *, &) if helpers.respond_to?(name, true)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        YiffSpace.config.application_controller_class.helpers.respond_to?(name, true) || super
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/open_hash.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require("active_support/hash_with_indifferent_access")
+
+module YiffSpace
+  module Utils
+    class OpenHash < ActiveSupport::HashWithIndifferentAccess
+      def initialize(constructor = nil, respond_to_missing: true)
+        super(constructor)
+        @respond_to_missing = respond_to_missing
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        return true if @respond_to_missing
+
+        name = name.to_s
+        key?(name) || name.end_with?("=") || super
+      end
+
+      def method_missing(name, *args)
+        if name.end_with?("=")
+          public_send(:[]=, name.to_s.chomp("=").to_sym, args.first)
+        elsif key?(name)
+          public_send(:[], name)
+        elsif @respond_to_missing
+          nil
+        else
+          super
+        end
+      end
+
+      def self.from(hash = nil, recursive: true, respond_to_missing: true, **kwargs)
+        hash = kwargs if hash.nil? && kwargs.any?
+        raise(ArgumentError, "no hash provided") if hash.nil?
+
+        oh = OpenHash.new(respond_to_missing: respond_to_missing)
+        hash.each do |key, value|
+          if recursive && value.is_a?(Hash)
+            oh[key] = OpenHash.from(value, recursive: recursive)
+          elsif recursive && value.is_a?(Array)
+            oh[key] = value.map { |v| v.is_a?(Hash) ? OpenHash.from(v, recursive: recursive, respond_to_missing: respond_to_missing) : v }
+          else
+            oh[key] = value
+          end
+        end
+        oh
+      end
+
+      def marshal_dump
+        [to_h, @respond_to_missing]
+      end
+
+      def marshal_load(data)
+        hash, @respond_to_missing = data
+        replace(hash)
+      end
+
+      def self.from_array(items, **)
+        items.map { |item| from(item, **) }
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/parameter_builder.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    class ParameterBuilder
+      def self.serial_parameters(only_string, object, options = {})
+        only_array = split_only_string(only_string)
+        get_only_hash(only_array, object, options)
+      end
+
+      def self.get_only_hash(only_array, object, options = {}, seen_objects = [])
+        return {} if object.nil?
+
+        is_root = seen_objects.empty?
+        only_hash = { only: [], include: [], methods: [] }
+        available_includes = object.available_includes
+        attributes, methods = object.api_attributes(options[:user]).partition { |attr| object.has_attribute?(attr) }
+        methods -= available_includes
+        # Attributes and/or methods may be included in the final pass, but not includes
+        seen_objects << object.class.name
+        underscore = false
+        only_array.each do |item|
+          if item == "_"
+            underscore = true
+            next
+          end
+          match = item.match(/(\w+)\[(.+?)\]$/)
+          item = (match || [])[1] || item
+          item_sym = item.to_sym
+          was_seen = inclusion_seen?(item, object.class, seen_objects)
+          if match && available_includes.include?(item_sym) && (!was_seen || is_root)
+            item_object = object.send(item_sym)
+            next if item_object.nil?
+
+            item_object = item_object[0] if item_object.is_a?(ActiveRecord::Relation)
+            item_array = split_only_string(match[2])
+            item_hash = get_only_hash(item_array, item_object, options, seen_objects.clone)
+            only_hash[:include] << { item_sym => item_hash }
+          elsif available_includes.include?(item_sym) && (!was_seen || is_root)
+            only_hash[:include] << item_sym
+          elsif attributes.include?(item_sym)
+            only_hash[:only] << item_sym
+          elsif methods.include?(item_sym)
+            only_hash[:methods] << item_sym
+            only_hash[:only] << item_sym
+          end
+        end
+        only_hash.delete(:include) if only_hash[:include].empty?
+        only_hash.delete(:methods) if only_hash[:methods].empty?
+        only_hash[:only].unshift("_") if underscore
+        only_hash
+      end
+
+      def self.includes_parameters(only_string, model_name)
+        return [] if only_string.blank?
+
+        only_array = split_only_string(only_string)
+        get_includes_array(only_array, model_name)
+      end
+
+      def self.get_includes_array(only_array, model_name, seen_objects = [])
+        is_root = seen_objects.empty?
+        include_array = []
+        model = Kernel.const_get(model_name)
+        available_includes = model.available_includes
+        # Attributes and/or methods may be included in the final pass, but not includes
+        seen_objects << model_name
+        only_array.each do |item|
+          match = item.match(/(\w+)\[(.+?)\]$/)
+          item = (match || [])[1] || item
+          item_sym = item.to_sym
+          was_seen = inclusion_seen?(item, model, seen_objects)
+          if match && available_includes.include?(item_sym) && (!was_seen || is_root)
+            item_array = split_only_string(match[2])
+            model.associated_models(item).each do |m|
+              item_array = get_includes_array(item_array, m, seen_objects.clone)
+              include_array << (item_array.empty? ? item_sym : { item_sym => item_array })
+            end
+          elsif available_includes.include?(item_sym) && (!was_seen || is_root)
+            include_array << item_sym
+          end
+        end
+        include_array
+      end
+
+      def self.inclusion_seen?(inclusion, class_object, seen_objects)
+        if class_object.reflections[inclusion]
+          inclusion_class = class_object.reflections[inclusion].class_name
+          max_seen = (class_object.multiple_includes.include?(inclusion.to_sym) ? 1 : 0)
+          seen_objects.count(inclusion_class) > max_seen
+        else
+          false
+        end
+      end
+
+      def self.split_only_string(only_string)
+        only_array = []
+        offset = 0
+        position = 0
+        level = 0
+        loop do
+          str = only_string[Range.new(position, -1)]
+          match = str.match(/[,\[\]]/)
+          break unless match
+
+          start_pos, end_pos = match.offset(0)
+          if match[0] == "," && level.zero?
+            only_array << only_string[Range.new(offset, position + start_pos - 1)]
+            offset = position + end_pos
+          elsif match[0] == "["
+            level += 1
+          elsif match[0] == "]"
+            level -= 1
+          end
+          position += end_pos
+        end
+        only_array << only_string[Range.new(offset, -1)]
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/parse_value.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    module ParseValue
+      MAX_INT = 2_147_483_647
+      MIN_INT = -2_147_483_648
+      extend(self)
+
+      def date_range(target)
+        case target
+          # 10_yesterweeks_ago, 10yesterweekago
+        when /\A(\d{1,2})_?yester(week|month|year)s?_?ago\z/
+          yester_range($1.to_i, $2)
+        when /\Ayester(week|month|year)\z/
+          yester_range(1, $1)
+        when /\A(day|week|month|year)\z/
+          [:gte, Time.zone.now - 1.send($1)]
+          # 10_weeks_ago, 10w
+        when /\A(\d+)_?(s(econds?)?|mi(nutes?)?|h(ours?)?|d(ays?)?|w(eeks?)?|mo(nths?)?|y(ears?)?)_?(ago)?\z/i
+          [:gte, time_string(target)]
+        else
+          range(target, :date)
+        end
+      end
+
+      def range_fudged(range, type)
+        result = range(range, type)
+        if result[0] == :eq
+          new_min = [(result[1] * 0.95).to_i, MIN_INT].max
+          new_max = [(result[1] * 1.05).to_i, MAX_INT].min
+          [:between, new_min, new_max]
+        else
+          result
+        end
+      end
+
+      def range(range, type = :integer)
+        if range.start_with?("<=")
+          [:lte, cast(range.delete_prefix("<="), type)]
+
+        elsif range.start_with?("..")
+          [:lte, cast(range.delete_prefix(".."), type)]
+
+        elsif range.start_with?("<")
+          [:lt, cast(range.delete_prefix("<"), type)]
+
+        elsif range.start_with?(">=")
+          [:gte, cast(range.delete_prefix(">="), type)]
+
+        elsif range.end_with?("..")
+          [:gte, cast(range.delete_suffix(".."), type)]
+
+        elsif range.start_with?(">")
+          [:gt, cast(range.delete_prefix(">"), type)]
+
+        elsif range.include?("..")
+          left, right = range.split("..", 2)
+          [:between, cast(left, type), cast(right, type)]
+
+        elsif range.include?(",")
+          [:in, range.split(",").first(YiffSpace.config.max_multi_count.call).map { |x| cast(x, type) }]
+
+        else
+          [:eq, cast(range, type)]
+
+        end
+      end
+
+      RANGE_INVERSIONS = {
+        lte: :gte,
+        lt:  :gt,
+        gte: :lte,
+        gt:  :lt,
+      }.freeze
+
+      def invert_range(range)
+        # >10 <=> <10
+        range[0] = RANGE_INVERSIONS[range[0]] || range[0]
+        # 10..20 <=> 20..10
+        range[1], range[2] = range[2], range[1] if range[0] == :between
+        range
+      end
+
+      private
+
+      def cast(object, type)
+        case type
+        when :integer
+          object.to_i.clamp(MIN_INT, MAX_INT)
+
+        when :float
+          # Floats obviously have a different range but this is good enough
+          object.to_f.clamp(MIN_INT, MAX_INT)
+
+        when :date, :datetime
+          case object
+          when "today"
+            return Date.current
+          when "yesterday"
+            return Date.yesterday
+          when "decade"
+            return Date.current - 10.years
+          when /\A(day|week|month|year)\z/
+            return Date.current - 1.send($1.to_sym)
+          end
+
+          ago = time_string(object)
+          return ago if ago.present?
+
+          begin
+            Time.zone.parse(object)
+          rescue ArgumentError
+            nil
+          end
+
+        when :age
+          time_string(object)
+
+        when :ratio
+          left, right = object.split(":", 10)
+
+          if right && right.to_f != 0.0
+            (left.to_f / right.to_f).round(10)
+          elsif right
+            0.0
+          else
+            object.to_f.round(2)
+          end
+
+        when :filesize
+          size = object.downcase
+          if size.end_with?("kb")
+            size.to_f.kilobytes
+          elsif size.end_with?("mb")
+            size.to_f.megabytes
+          else
+            size.to_f
+          end.to_i
+        end
+      end
+
+      def yester_range(count, unit)
+        origin = Date.current - count.send(unit)
+        start = origin.send("beginning_of_#{unit}")
+        stop = origin.send("end_of_#{unit}")
+        [:between, start, stop]
+      end
+
+      def time_string(target)
+        target =~ /\A(\d+)_?(s(econds?)?|mi(nutes?)?|h(ours?)?|d(ays?)?|w(eeks?)?|mo(nths?)?|y(ears?)?)_?(ago)?\z/i
+
+        size = $1.to_i
+        unit = $2&.downcase || ""
+
+        if unit.start_with?("s")
+          size.seconds.ago
+        elsif unit.start_with?("mi")
+          size.minutes.ago
+        elsif unit.start_with?("h")
+          size.hours.ago
+        elsif unit.start_with?("d")
+          size.days.ago
+        elsif unit.start_with?("w")
+          size.weeks.ago
+        elsif unit.start_with?("mo")
+          size.months.ago
+        elsif unit.start_with?("y")
+          size.years.ago
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/routes.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    # Allow Rails URL helpers to be used outside of views.
+    #
+    # @example
+    #   Routes.posts_path(tags: "male")
+    #   => "/posts?tags=male"
+    #
+    # @see config/routes.rb
+    # @see https://guides.rubyonrails.org/routing.html
+    module Routes
+      module_function
+
+      def method_missing(name, *, &)
+        url_helpers = Rails.application.routes.url_helpers
+        return url_helpers.public_send(name, *, &) if url_helpers.respond_to?(name)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        Rails.application.routes.url_helpers.respond_to?(name, include_private) || super
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/set_env_constraint.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    class SetEnvConstraint
+      attr_reader(:key, :value)
+
+      def initialize(key, value)
+        @key   = key.to_s
+        @value = value
+      end
+
+      def matches?(request)
+        request.env[key.to_s] = value
+      end
+    end
+  end
+end

data/lib/yiffspace/utils/trace_logger.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    module TraceLogger
+      module_function
+
+      COLORS = {
+        black:   "\e[30m",
+        red:     "\e[31m",
+        green:   "\e[32m",
+        yellow:  "\e[33m",
+        blue:    "\e[34m",
+        magenta: "\e[35m",
+        cyan:    "\e[36m",
+        white:   "\e[37m",
+        reset:   "\e[0m",
+      }.freeze
+
+      # noinspection RubyLiteralArrayInspection
+      LEVELS = {
+        debug:   ["%<cyan>s", "%<blue>s"],
+        error:   ["%<red>s", "%<red>s"],
+        info:    ["%<cyan>s", "%<blue>s"],
+        warn:    ["%<yellow>s", "%<yellow>s"],
+        default: ["%<white>s", "%<white>s"],
+      }.freeze
+
+      def format_level(level)
+        level = level.to_sym
+        primary, alternate = LEVELS.fetch(level, LEVELS[:default])
+        colorize("#{alternate}[%<reset>s#{primary}#{level.to_s.upcase}%<reset>s#{alternate}]%<reset>s")
+      end
+
+      def colorize(text, **)
+        format(text, **COLORS, **)
+      end
+
+      def debug(*, **)
+        _log(*, level: :debug, **)
+      end
+
+      def error(*, **)
+        _log(*, level: :error, **)
+      end
+
+      def info(*, **)
+        _log(*, level: :info, **)
+      end
+
+      def warn(*, **)
+        _log(*, level: :warn, **)
+      end
+
+      def _log(*arg, ignore: nil, level: :log, lines: 3, format: nil)
+        return unless Rails.logger.public_send("#{level}?")
+
+        if arg.one?
+          name = nil
+          message = arg.first
+        else
+          name = arg.shift
+          message = arg.join
+        end
+        primary, alternate = LEVELS.fetch(level, LEVELS[:default])
+        args = { level: format_level(level), name: name, message: message }
+        fmt = "%<level>s"
+        if format.nil?
+          if name.present?
+            fmt += " #{alternate}[%<reset>s%<magenta>s%<name>s%<reset>s#{alternate}]%<reset>s " \
+                   "#{primary}%<message>s%<reset>s"
+          else
+            fmt += " #{primary}%<message>s%<reset>s"
+          end
+        else
+          fmt += " #{format}%<reset>s"
+        end
+        ignore = Array(ignore).unshift(%r{/yiffspace/utils/trace_logger\.rb})
+        callers = caller_locations.reject do |loc|
+          path = loc.absolute_path || loc.path
+          !Rails.backtrace_cleaner.clean_frame("#{path}:#{loc.lineno}") || ignore.any? { |i| path.match?(i) }
+        end
+        callers = callers.take(lines) if lines.present?
+        Rails.logger.public_send(level, colorize(fmt, **args))
+        callers.each { |c| Rails.logger.public_send(level, "↳ #{c.path.gsub(%r{^/app/}, '')}:#{c.lineno} in `#{c.label}`") }
+      end
+
+      private_class_method(:_log)
+    end
+  end
+end

data/lib/yiffspace/utils.rb

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