yiffspace-ext 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4fc882fca40b80202278d32120a9431217eec12f12ecc87b3c6f822ed207beb1
+  data.tar.gz: 52aec8e7846120c2130d2a215fdb1ab9b20ab149f1dc91d8ee8daaaf16da493b
+SHA512:
+  metadata.gz: 26b0192994a1d69ed566098e9f25decc3ce9ac519c9b68133cb3eabad8a069b16ef7bf9f5f30c4a3db2911ce118f2a75b859d08a785c1f7286127b5d685e0d73
+  data.tar.gz: ac8f6ad4ff4a3291b1430de0314862f196dfab5771a812b5baab48fa8b2560299860612eed89c8216eea265208dfd0179f8b95c04b31723b0793a1ee33312a2d

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+## 0.0.1
+
+- Initial release, extracted from the `yiffspace` gem's generic
+  `YiffSpace::Extensions::{Object,Hash,Enumerable,String}` and
+  `YiffSpace::Extensions::ActiveRecord::WhereChain`, plus their `core_ext`
+  global aliases.

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,40 @@
+# YiffSpace::Ext
+
+Generic Ruby/ActiveRecord core extensions - `Object#to_b`/`#truthy?`/`#falsy?`,
+`Hash#to_open_hash`, `Enumerable#parallel`, `String#to_escaped_for_sql_like`,
+and the `.where` chain DSL (`.like`/`.ilike`/`.has_bits`/`.regex`/etc) - for
+https://yiff.space and related projects. No dependency on `yiffspace` itself.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "yiffspace-ext"
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Usage
+
+The namespaced extensions live under `YiffSpace::Extensions::*` and are
+autoloaded. The old global monkeypatch style is opt-in:
+
+```ruby
+require "yiffspace/core_ext/all" # or object/all, hash/all, etc individually
+```
+
+`core_ext/all` also picks up `yiffspace-arel`'s lateral-join/unnest globals
+if that gem happens to be installed too.
+
+## 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,3 @@
+# frozen_string_literal: true
+
+require("bundler/gem_tasks")

data/lib/yiffspace/core_ext/active_record/where_chain.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require("active_record/relation")
+require_relative("../../extensions/active_record/where_chain")
+
+ActiveRecord::QueryMethods::WhereChain.include(YiffSpace::Extensions::ActiveRecord::WhereChain)

data/lib/yiffspace/core_ext/all.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative("active_record/where_chain")
+require_relative("enumerable/all")
+require_relative("hash/all")
+require_relative("object/all")
+require_relative("string/all")
+
+# yiffspace-arel's lateral-join/unnest core_ext, only if that gem happens to be installed too.
+begin
+  require("yiffspace/core_ext/active_record/all")
+rescue LoadError
+  nil
+end

data/lib/yiffspace/core_ext/enumerable/all.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative("parallel")

data/lib/yiffspace/core_ext/enumerable/parallel.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/enumerable/parallel")
+
+module Enumerable
+  include(YiffSpace::Extensions::Enumerable::Parallel)
+end

data/lib/yiffspace/core_ext/hash/all.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative("to_open_hash")

data/lib/yiffspace/core_ext/hash/to_open_hash.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/hash/to_open_hash")
+
+class Hash
+  include(YiffSpace::Extensions::Hash::ToOpenHash)
+end

data/lib/yiffspace/core_ext/object/all.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative("to_b")
+require_relative("truthy_falsy")

data/lib/yiffspace/core_ext/object/to_b.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/object/to_b")
+
+class Object
+  include(YiffSpace::Extensions::Object::ToB)
+end

data/lib/yiffspace/core_ext/object/truthy_falsy.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/object/truthy_falsy")
+
+class Object
+  include(YiffSpace::Extensions::Object::TruthyFalsy)
+end

data/lib/yiffspace/core_ext/string/all.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative("sql")

data/lib/yiffspace/core_ext/string/sql.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative("../../extensions/string/sql")
+
+class String
+  include(YiffSpace::Extensions::String::Sql)
+end

data/lib/yiffspace/ext/version.rb

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

data/lib/yiffspace/ext.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require("zeitwerk")
+
+module YiffSpace
+  module Ext
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem_extension(YiffSpace)
+loader.ignore("#{__dir__}/core_ext")
+loader.setup

data/lib/yiffspace/extensions/active_record/where_chain.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module ActiveRecord
+      module WhereChain
+        %i[
+          lt lteq gt gteq
+          between not_between in not_in like
+          ilike not_like not_ilike
+          like_all ilike_all not_like_all not_ilike_all
+          like_any ilike_any not_like_any not_ilike_any
+          has_bits not_has_bits
+        ].each do |method|
+          define_method(method) do |conditions|
+            build(conditions, method)
+          end
+        end
+
+        alias lte lteq
+        alias gte gteq
+
+        # https://www.postgresql.org/docs/current/static/functions-matching.html#FUNCTIONS-POSIX-REGEXP
+        # "(?e)" means force use of ERE syntax; see sections 9.7.3.1 and 9.7.3.4.
+        def regex(conditions = {}, flags: "e", **kwargs)
+          conditions.merge!(kwargs) if conditions.is_a?(::Hash)
+          build(conditions, :regex, flags)
+        end
+
+        def not_regex(conditions = {}, flags: "e", **kwargs)
+          conditions.merge!(kwargs) if conditions.is_a?(::Hash)
+          build(conditions, :not_regex, flags)
+        end
+
+        def tsquery(conditions = {}, ts_config: "english", **kwargs)
+          conditions.merge!(kwargs) if conditions.is_a?(::Hash)
+          build(conditions, :tsquery, ts_config)
+        end
+
+        METHODS = {
+          lt:            ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].lt(value) },
+          lteq:          ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].lteq(value) },
+          gt:            ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].gt(value) },
+          gteq:          ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].gteq(value) },
+          between:       ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].between(value) },
+          not_between:   ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].not_between(value) },
+          in:            ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].in(value) },
+          not_in:        ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].not_in(value) },
+          like:          ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].matches(value.to_escaped_for_sql_like, ::Arel.sql("E'\\\\'"), true) },
+          ilike:         ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].matches(value.to_escaped_for_sql_like, ::Arel.sql("E'\\\\'"), false) },
+          not_like:      ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].does_not_match(value.to_escaped_for_sql_like, ::Arel.sql("E'\\\\'"), true) },
+          not_ilike:     ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].does_not_match(value.to_escaped_for_sql_like, ::Arel.sql("E'\\\\'"), false) },
+          like_all:      ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].matches_all(value.map(&:to_escaped_for_sql_like), ::Arel.sql("E'\\\\'"), true) },
+          ilike_all:     ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].matches_all(value.map(&:to_escaped_for_sql_like), ::Arel.sql("E'\\\\'"), false) },
+          not_like_all:  ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].does_not_match_all(value.map(&:to_escaped_for_sql_like), ::Arel.sql("E'\\\\'"), true) },
+          not_ilike_all: ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].does_not_match_all(value.map(&:to_escaped_for_sql_like), ::Arel.sql("E'\\\\'"), false) },
+          like_any:      ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].matches_any(value.map(&:to_escaped_for_sql_like), ::Arel.sql("E'\\\\'"), true) },
+          ilike_any:     ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].matches_any(value.map(&:to_escaped_for_sql_like), ::Arel.sql("E'\\\\'"), false) },
+          not_like_any:  ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].does_not_match_any(value.map(&:to_escaped_for_sql_like), ::Arel.sql("E'\\\\'"), true) },
+          not_ilike_any: ->(table_name, column, value) { ::Arel::Table.new(table_name)[column].does_not_match_any(value.map(&:to_escaped_for_sql_like), ::Arel.sql("E'\\\\'"), false) },
+          regex:         ->(table_name, column, value, flags) { ::Arel::Table.new(table_name)[column].matches_regexp("(?#{flags})#{value.is_a?(Regexp) ? value.source : value}") },
+          not_regex:     ->(table_name, column, value, flags) { ::Arel::Table.new(table_name)[column].does_not_match_regexp("(?#{flags})#{value.is_a?(Regexp) ? value.source : value}") },
+          tsquery:       ->(table_name, column, value, ts_config) { ::Arel.sql("to_tsvector(:ts_config, :table) @@ plainto_tsquery(:ts_config, :value)", ts_config: ts_config, value: value, table: ::Arel.sql("#{table_name}.#{column}")) },
+          has_bits:      ->(table_name, column, value) { ::Arel.sql("(#{table_name}.#{column} & #{::Arel::Nodes.build_quoted(value).to_sql}) = #{::Arel::Nodes.build_quoted(value).to_sql}") },
+          not_has_bits:  ->(table_name, column, value) { ::Arel.sql("(#{table_name}.#{column} & #{::Arel::Nodes.build_quoted(value).to_sql}) != #{::Arel::Nodes.build_quoted(value).to_sql}") },
+        }.freeze
+
+        private
+
+        def build(conditions, method, *extra)
+          model = @scope.klass
+
+          parsed_conditions = normalize_conditions(conditions, model)
+
+          arel_conditions = parsed_conditions.map do |(table_name, column), value|
+            METHODS.fetch(method).call(table_name, column, value, *extra)
+          end.reduce(:and)
+
+          @scope.where(arel_conditions)
+        end
+
+        def normalize_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(normalize_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
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/enumerable/parallel.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require("active_support/core_ext/module/attribute_accessors")
+
+module YiffSpace
+  module Extensions
+    module Enumerable
+      module Parallel
+        mattr_accessor(:usable)
+        # Like `#each`, but perform the block on each item in parallel. Note that items aren't processed in order, so things
+        # like `parallel_each.map` that rely on ordering won't work.
+        def parallel_each(executor = :io, &)
+          return enum_for(:parallel_each, executor) unless block_given?
+
+          parallel_map(executor, &)
+          self
+        end
+
+        # Like `#map`, but in parallel.
+        def parallel_map(executor = :io, &)
+          return enum_for(:parallel_map, executor) unless block_given?
+
+          promises = map do |item|
+            Concurrent::Promises.future_on(executor, item, &)
+          end
+
+          Concurrent::Promises.zip_futures_on(executor, *promises).value!
+        end
+      end
+    end
+  end
+end
+
+begin
+  require("concurrent-ruby")
+  YiffSpace::Extensions::Enumerable::Parallel.usable = true
+rescue LoadError
+  YiffSpace::Extensions::Enumerable::Parallel.usable = false
+end

data/lib/yiffspace/extensions/hash/to_open_hash.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module Hash
+      module ToOpenHash
+        def to_open_hash
+          ::YiffSpace::Utils::OpenHash.from(self)
+        end
+
+        alias with_open_access to_open_hash
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/object/to_b.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module Object
+      module ToB
+        def to_b
+          case self
+          when ::String
+            !match?(/\A(false|f|no|n|off|0)\z/i)
+          when ::TrueClass
+            true
+          when ::FalseClass
+            false
+          else
+            to_s.to_b
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/object/truthy_falsy.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module Object
+      module TruthyFalsy
+        def truthy?
+          case self
+          when ::String
+            match?(/\A(true|t|yes|y|on|1)\z/i)
+          when ::TrueClass
+            true
+          when ::FalseClass
+            false
+          else
+            to_s.truthy?
+          end
+        end
+
+        def falsy?
+          case self
+          when ::String
+            match?(/\A(false|f|no|n|off|0)\z/i)
+          when ::TrueClass
+            false
+          when ::FalseClass
+            true
+          else
+            to_s.falsy?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/extensions/string/sql.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Extensions
+    module String
+      module Sql
+        def to_escaped_for_sql_like
+          gsub(/%|_|\*|\\\*|\\\\|\\/) do |str|
+            case str
+            when "%" then '\%'
+            when "_" then '\_'
+            when "*" then "%"
+            when '\*' then "*"
+            when "\\\\", "\\" then "\\\\"
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: yiffspace-ext
+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: activesupport
+  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: 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: Generic Ruby/ActiveRecord core extensions (Object/Hash/Enumerable/String,
+  WhereChain), 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/core_ext/active_record/where_chain.rb
+- lib/yiffspace/core_ext/all.rb
+- lib/yiffspace/core_ext/enumerable/all.rb
+- lib/yiffspace/core_ext/enumerable/parallel.rb
+- lib/yiffspace/core_ext/hash/all.rb
+- lib/yiffspace/core_ext/hash/to_open_hash.rb
+- lib/yiffspace/core_ext/object/all.rb
+- lib/yiffspace/core_ext/object/to_b.rb
+- lib/yiffspace/core_ext/object/truthy_falsy.rb
+- lib/yiffspace/core_ext/string/all.rb
+- lib/yiffspace/core_ext/string/sql.rb
+- lib/yiffspace/ext.rb
+- lib/yiffspace/ext/version.rb
+- lib/yiffspace/extensions/active_record/where_chain.rb
+- lib/yiffspace/extensions/enumerable/parallel.rb
+- lib/yiffspace/extensions/hash/to_open_hash.rb
+- lib/yiffspace/extensions/object/to_b.rb
+- lib/yiffspace/extensions/object/truthy_falsy.rb
+- lib/yiffspace/extensions/string/sql.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-ext
+  changelog_uri: https://github.com/YiffSpace/Gem/blob/master/yiffspace-ext/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: Generic Ruby/ActiveRecord core extensions (Object/Hash/Enumerable/String,
+  WhereChain), for https://yiff.space and related projects
+test_files: []