yiffspace 0.0.1 → 0.0.2

data/lib/yiffspace/configuration.rb

@@ -2,6 +2,76 @@
 
 module YiffSpace
   class Configuration
+    # Maximum number of comma-separated values allowed in a multi-value query parameter.
+    # Used by ParseValue.range and QueryBuilder.
+    attr_reader(:max_multi_count)
+
+    # Redis URL used by Utils::Cache for direct Redis connections.
+    attr_reader(:redis_url)
+
+    # The application's User model class. Used by Utils::Current, Search::QueryDSL, etc.
+    # Falls back to ::User at call time when nil.
+    attr_accessor(:user_class)
+
+    # The application's UserResolvable class. Used by Utils::Current.
+    # Falls back to ::UserResolvable at call time when nil.
+    attr_accessor(:user_resolvable_class)
+
+    # The CurrentAttributes class used to access the current user in model concerns.
+    # Defaults to YiffSpace::Utils::Current.
+    attr_writer(:current_class)
+
+    # The default IP address assigned to Utils::Current when none is present.
+    attr_accessor(:default_ip_address)
+
+    # Override the proc used to fetch the anonymous user. Must respond to #call.
+    # Default: -> { (user_class || ::User).anonymous }
+    attr_writer(:anonymous_user_getter)
+
+    # Override the proc used to fetch the system user. Must respond to #call.
+    # Default: -> { (user_class || ::User).system }
+    attr_writer(:system_user_getter)
+
+    # The anonymous user name
+    attr_reader(:anonymous_user_name)
+
+    def initialize
+      @max_multi_count       = -> { 100 }
+      @redis_url             = -> {}
+      @user_class            = nil
+      @user_resolvable_class = nil
+      @current_class         = nil
+      @default_ip_address    = "127.0.0.1"
+      @anonymous_user_name   = -> { "Anonymous" }
+    end
+
+    # Returns the configured current class, defaulting to YiffSpace::Utils::Current.
+    def current_class
+      @current_class || Utils::Current
+    end
+
+    # Lazily built: calls user_class (or ::User) at invocation time, not config time.
+    def anonymous_user_getter
+      @anonymous_user_getter ||= -> { (user_class || ::User).anonymous }
+    end
+
+    # Lazily built: calls user_class (or ::User) at invocation time, not config time.
+    def system_user_getter
+      @system_user_getter ||= -> { (user_class || ::User).system }
+    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 anonymous_user_name=(value)
+      @anonymous_user_name = value.is_a?(Proc) ? value : -> { value }
+    end
+
     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]
@@ -17,14 +87,4 @@ module YiffSpace
       @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/all.rb

@@ -5,4 +5,3 @@ require_relative("arel/all")
 require_relative("enumerable/all")
 require_relative("hash/all")
 require_relative("string/all")
-require_relative("open_hash")

data/lib/yiffspace/include/all.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative("cache")
+require_relative("current")
+require_relative("duration_parser")
+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("user_attribute")

data/lib/yiffspace/include/cache.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../utils/cache")
+
+Cache = YiffSpace::Utils::Cache

data/lib/yiffspace/include/current.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../utils/current")
+
+Current = YiffSpace::Utils::Current

data/lib/yiffspace/include/duration_parser.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../utils/duration_parser")
+
+DurationParser = YiffSpace::Utils::DurationParser

data/lib/yiffspace/include/helpers.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../utils/helpers")
+
+Helpers = YiffSpace::Utils::Helpers

data/lib/yiffspace/{core_ext → include}/open_hash.rb

@@ -1,3 +1,5 @@
 # frozen_string_literal: true
 
+require_relative("../utils/open_hash")
+
 OpenHash = YiffSpace::Utils::OpenHash

data/lib/yiffspace/include/parameter_builder.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../utils/parameter_builder")
+
+ParameterBuilder = YiffSpace::Utils::ParameterBuilder

data/lib/yiffspace/include/parse_value.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../utils/parse_value")
+
+ParseValue = YiffSpace::Utils::ParseValue

data/lib/yiffspace/include/query_builder.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../search/query_builder")
+
+QueryBuilder = YiffSpace::Search::QueryBuilder

data/lib/yiffspace/include/query_dsl.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../search/query_dsl")
+
+QueryDSL = YiffSpace::Search::QueryDSL

data/lib/yiffspace/include/query_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../search/query_helper")
+
+QueryHelper = YiffSpace::Search::QueryHelper

data/lib/yiffspace/include/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../utils/routes")
+
+Routes = YiffSpace::Utils::Routes

data/lib/yiffspace/include/table_builder.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../utils/table_builder")
+
+TableBuilder = YiffSpace::Utils::TableBuilder

data/lib/yiffspace/include/trace_logger.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../utils/trace_logger")
+
+TraceLogger = YiffSpace::Utils::TraceLogger

data/lib/yiffspace/include/user_attribute.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative("../utils/user_attribute")
+
+UserAttribute = YiffSpace::Utils::UserAttribute

data/lib/yiffspace/search/query_builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Search
+    class QueryBuilder
+      attr_reader(:dsl, :klass, :relation, :user, :q)
+
+      # [param, db_field, type]
+      def initialize(dsl, klass, relation, user)
+        dsl ||= []
+        @dsl = dsl
+        @klass = klass
+        @relation = relation
+        @user = user
+        @q = relation
+      end
+
+      def process_dsl(dsl, params)
+        dsl[:fields].each do |param, field, type = nil, block = nil, options = {}|
+          value = params[param]
+          multi = options.fetch(:multi, nil) || false
+          like = options.fetch(:like, nil) || false
+          ilike = options.fetch(:ilike, nil) || false
+          normalize = options.fetch(:normalize, nil) || ->(value) { value }
+          next if value.nil?
+
+          value = normalize.call(value)
+          @q = block.call(q) if block
+          if type.is_a?(Proc)
+            args = [q, value, user, params]
+            @q = type.call(*args.first(type.arity))
+            next
+          end
+          field ||= param
+          if like
+            @q = q.where.like(field => value)
+            next
+          elsif ilike
+            @q = q.where.ilike(field => value)
+            next
+          end
+          type ||= QueryHelper.get_column(field, klass.table_name).sql_type_metadata.type
+          case type
+          when :boolean
+            @q = q.boolean_attribute_matches(field, value)
+          when :integer
+            # multiple comma separated values are implicitly supported
+            # trimming them seems unneeded
+            # value = value[0.. value.index(",") - 1] unless multi
+            @q = q.numeric_attribute_matches(field, value)
+          when :datetime
+            @q = q.datetime_attribute_matches(field, value)
+          when :text, :string
+            value = value.split(",").first(YiffSpace.config.max_multi_count.call) if multi # explicitly supports arrays
+            @q = q.text_attribute_matches(field, value)
+          when :inet
+            @q = q.ip_attribute_matches(field, value)
+          when :present
+            @q = q.attribute_present(field, value)
+          else
+            raise(ArgumentError, "Unknown type: #{type} for field: #{field}")
+          end
+        end
+
+        dsl[:associations].each do |attribute, klass, nested_dsl, join|
+          next if params[attribute].nil?
+
+          @q = q.joins(join)
+          nested_relation = klass.all
+          nested_builder = QueryBuilder.new(nested_dsl, klass, nested_relation, user)
+          nested_relation = nested_builder.search(params[attribute])
+          @q = q.merge(nested_relation)
+        end
+      end
+
+      def search(params = {})
+        params.transform_keys!(&:to_sym)
+        process_dsl(dsl, params)
+        q
+      end
+    end
+  end
+end

data/lib/yiffspace/search/query_dsl.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Search
+    class QueryDSL
+      attr_accessor(:relation, :fields, :associations, :no_id, :no_dates)
+
+      # [param, field, type/proc, Proc(relation)]
+      def initialize(relation)
+        @relation = relation
+        @fields = []
+        @associations = []
+        @no_id = false
+        @no_dates = false
+      end
+
+      def custom(param, proc, not: false, multi: false, &block)
+        @fields << [param, nil, proc, block, { not: binding.local_variable_get(:not), multi: multi }]
+        self
+      end
+
+      def field(param, db_field = param, type = nil, not: false, multi: false, wildcard: false, like: false, ilike: false, normalize: nil, &block)
+        type ||= QueryHelper.get_column(db_field, relation.table_name).sql_type_metadata.type
+        @fields << [param, db_field, type, block, { not: binding.local_variable_get(:not), multi: multi, wildcard: wildcard, like: like, ilike: ilike, normalize: normalize }]
+        self
+      end
+
+      def user(param, association = nil, not: false, &)
+        if param.is_a?(Array)
+          raise(ArgumentError, "You must specify an association when passing an array of parameters") if association.nil?
+        else
+          association ||= param
+          param = [:"#{param}_id", :"#{param}_name"]
+        end
+
+        case association
+        when Symbol, String
+          association = association.to_sym
+          associations = relation.reflect_on_all_associations(:belongs_to).map(&:name)
+          if associations.include?(association)
+            column = association_column(association)
+          else
+            column = association
+          end
+        when Array
+          column = association.first
+          association = association.second
+        end
+        field(param.first, column, not: binding.local_variable_get(:not), &) if param.first
+        custom(param.second, ->(q, v) { q.user_name_matches(association, v) }, not: binding.local_variable_get(:not), &) if param.second
+        self
+      end
+
+      def present(param, db_field = param, &)
+        field(param, db_field, :present, &)
+      end
+
+      # [attribute, class, dsl, join]
+      def association(*args, **kwargs)
+        if args.any?
+          attribute = args.first
+          as = args.second || attribute
+          ref = relation.reflect_on_association(attribute)
+          raise("Association #{attribute} does not exist on #{relation.name}") if ref.nil?
+
+          klass = ref.klass
+          dsl = klass.query_dsl.build
+          @associations << [as, klass, dsl, attribute]
+          user_class = YiffSpace.config.user_class
+          user(as, attribute) if klass == user_class && @fields.none? { |f| f.second == association_column(attribute) }
+        elsif kwargs.any?
+          attribute = kwargs.delete(:as)
+          to_array = lambda { |h|
+            k, v = h.first
+            [k, v.is_a?(Hash) ? to_array.call(v) : v].flatten
+          }
+          through = to_array.call(kwargs)
+          attribute ||= through.last
+          klass = relation
+          through.each { |k| klass = klass.reflect_on_association(k).klass }
+          dsl = klass.query_dsl.build
+          join = through.reverse.reduce { |acc, key| { key => acc } }
+          @associations << [attribute, klass, dsl, join]
+        else
+          raise(ArgumentError, "Missing association")
+        end
+        self
+      end
+
+      def no_id!
+        @no_id = true
+        @fields.reject! { |field| field.first == :id }
+        self
+      end
+
+      def no_dates!
+        @no_dates = true
+        @fields.reject! { |field| %i[created_at updated_at].include?(field.first) }
+        self
+      end
+
+      def build
+        @fields << %i[id id integer] if @fields.none? { |field| field.first == :id }
+        @fields << %i[created_at created_at datetime] if @fields.none? { |field| field.first == :created_at } && relation.attribute_names.include?("created_at")
+        @fields << %i[updated_at updated_at datetime] if @fields.none? { |field| field.first == :updated_at } && relation.attribute_names.include?("updated_at")
+        {
+          fields:       fields,
+          associations: associations,
+        }
+      end
+
+      private
+
+      def association_column(association)
+        :"#{relation.table_name}.#{relation.reflect_on_association(association).foreign_key}"
+      end
+    end
+  end
+end

data/lib/yiffspace/search/query_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Search
+    module QueryHelper
+      module_function
+
+      def parse_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(parse_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
+
+      def get_column(attribute, table = nil)
+        attribute = attribute.to_s
+        if attribute.include?(".")
+          table, column = attribute.split(".", 2)
+        else
+          column = attribute
+        end
+        raise(ArgumentError, "Missing table") if table.nil?
+
+        c = ActiveRecord::Base.connection.columns(table).find { |c| c.name == column }
+        raise(StandardError, "Column #{column} does not exist in table #{table}") unless c
+
+        c
+      rescue ActiveRecord::StatementInvalid
+        raise(StandardError, "Table #{table} does not exist")
+      end
+    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/current.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    class Current < ActiveSupport::CurrentAttributes
+      attribute(:user, :ip_addr, :request)
+
+      def initialize
+        super
+        reset
+      end
+
+      after_reset do
+        attributes[:user]    = YiffSpace.config.anonymous_user_getter.call
+        attributes[:ip_addr] = YiffSpace.config.default_ip_address
+      end
+
+      def user
+        value = super
+        return value if value.is_a?(YiffSpace.config.user_resolvable_class) || !value.is_a?(YiffSpace.config.user_class)
+        return YiffSpace.config.user_resolvable_class.new(value, ip_addr) if ip_addr.present?
+
+        value
+      end
+
+      def user=(value)
+        if value.is_a?(YiffSpace.config.user_resolvable_class)
+          self.ip_addr = value.ip_addr
+          value = value.user
+        end
+        super
+      end
+
+      def self.scoped(user, ip_addr = YiffSpace.config.default_ip_address, &)
+        set(user: user, ip_addr: ip_addr, &)
+      end
+
+      def self.as_system(&)
+        scoped(YiffSpace.config.system_user_getter.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,24 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Utils
+    module Helpers
+      module_function
+
+      def method_missing(name, *, &)
+        target.send(name, *, &)
+      end
+
+      def respond_to_missing?(...)
+        target.respond_to?(...)
+      end
+
+      private
+
+      # Lazily resolved so ApplicationController is not referenced at load time.
+      def target
+        ApplicationController.helpers
+      end
+    end
+  end
+end