yiffspace-search 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4921b1eca09fb7273db303f993933ad0fa3d8e133f6df4e173ddcdf7f39110e3
+  data.tar.gz: e7243afed8de644ff960bf7b7cbbc1dbe7409cff75b83287a371549de0221663
+SHA512:
+  metadata.gz: a71fab7d37d718372b4ff94719d88247d53ca88d54f26881948f73452a660034c2210ae247d98206b0e3404166c884cbc8dd0da9303b1124704d11807a2bbcc2
+  data.tar.gz: 9cf9638a9010c220204ef0abdfb1731545ceead28cb0ebb35604b3388b9fe3b56564f7a24dd61cffd0c2af18bee20c7ce9f2299a887107c8200fee7008f45d52

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.0.1
+
+- Initial release, extracted from the `yiffspace` gem's `YiffSpace::Search::QueryBuilder`/`QueryDSL`/`QueryHelper`.

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,28 @@
+# YiffSpace::Search
+
+Query-param search DSL (`YiffSpace::Search::QueryDSL`/`QueryBuilder`/
+`QueryHelper`), for https://yiff.space and related projects. Depends on
+`yiffspace-core` (attribute matchers), `yiffspace-ext` (`.where.like`/
+`.ilike`), and `yiffspace-user` (`user_class`).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "yiffspace-search"
+```
+
+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,9 @@
+# frozen_string_literal: true
+
+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/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/search/version.rb

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

data/lib/yiffspace/search.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require("yiffspace/core")
+require("yiffspace/ext")
+require("yiffspace/user")
+require("zeitwerk")
+
+module YiffSpace
+  module Search
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem_extension(YiffSpace)
+loader.inflector.inflect({ "query_dsl" => "QueryDSL" })
+loader.setup

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: yiffspace-search
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Donovan_DMC
+bindir: bin
+cert_chain: []
+date: 2026-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: yiffspace-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: yiffspace-ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: yiffspace-user
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Query-param search DSL (YiffSpace::Search::*), for https://yiff.space
+  and related projects
+email:
+- hewwo@yiff.rocks
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/yiffspace/search.rb
+- lib/yiffspace/search/query_builder.rb
+- lib/yiffspace/search/query_dsl.rb
+- lib/yiffspace/search/query_helper.rb
+- lib/yiffspace/search/version.rb
+homepage: https://yiff.space
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://yiff.space
+  source_code_uri: https://github.com/YiffSpace/Gem/tree/master/yiffspace-search
+  changelog_uri: https://github.com/YiffSpace/Gem/blob/master/yiffspace-search/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Query-param search DSL (YiffSpace::Search::*), for https://yiff.space and
+  related projects
+test_files: []