pg_taggable 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec57f99287e3bb16b29e459e42c0f3c5a24d6f967917906d88dadfe491d133e3
-  data.tar.gz: 525995c96c17957ba46a5025d250c1703efec6da6841277864befd0278072449
+  metadata.gz: d69f3ca42c6a0521d3c78f45b02aabd4ac22a2d2fc24a7292bff7cfffc55f954
+  data.tar.gz: 138eb372bdba0b11dd34d284c3c2d86afc81821140fb894c9b5787e5038f948d
 SHA512:
-  metadata.gz: caa213bb0b77a0c5f71922337563d9bf3222cf98a17571e90f700b5fabf5b345c1c4494c71c45889e8e081b1c0c44c200fa4c228638408d39d2039d26b5bca73
-  data.tar.gz: b4760ae519a53f6b414e5578ac6ec241b30b3342acdc82057a9a437599c65ce71bd473ef2be8ccd8c6ee99bff393fc775e647fee75ed5333f519b1ddb8617eda
+  metadata.gz: 3e7f136c064d12711f2bc8432881976df03332e3882e57dd548f107c7ebcecf97adac266569c17aada7c3c4d3fc3118fc68036d95869745ff16d6f7cf5e9d162
+  data.tar.gz: a49d82d021946a137e0b3ed82a644c346804f042df6c9b921a41d49dcf7c5040b2f266d28e189654cc41a99433cf48d8316bb1b88ad83e0c361d11be05feb1d7

data/README.md

@@ -87,12 +87,6 @@ Find records that have exact same tags as the list, order is not important
 Post.where(tags_eq: ['food', 'travel'])
 ```
 
-#### #{tag_name}
-Find records that have exact same tags as the list, order is important. This is the default behavior.
-```Ruby
-Post.where(tags: ['food', 'travel'])
-```
-
 Assume a post has tags: 'A', 'B'
 |Method|Query|Matched|
 |-|-|-|
@@ -112,10 +106,6 @@ Assume a post has tags: 'A', 'B'
 |tags_eq|A, B|True|
 |tags_eq|B, A|True|
 |tags_eq|A, B, C|False|
-|tags|A|False|
-|tags|A, B|True|
-|tags|B, A|False|
-|tags|A, B, C|False|
 
 ### Class Methods
 #### taggable(name, unique: true)
@@ -145,7 +135,7 @@ Post.tags
 Post.tags.size
 # => 4
 
-Post.tags.distinct.size
+Post.tags.select(:tag).distinct.size
 # => 3
 
 Post.tags.distinct.pluck(:tag)
@@ -155,6 +145,16 @@ Post.tags.group(:tag).count
 # => {"food"=>1, "travel"=>2, "technology"=>1}
 ```
 
+#### distinct_#{tag_name}
+Return an array of distinct tag records. It can be used for paging, count or other query.
+```Ruby
+Post.distinct_tags
+# => #<ActiveRecord::Relation [#<Post tag: "food", id: nil>, #<Post tag: "travel", id: nil>, #<Post tag: "technology", id: nil>]>
+
+# equal to
+Post.tags.select(:tag).distinct
+```
+
 #### uniq_#{tag_name}
 Return an array of unique tag strings.
 ```Ruby
@@ -175,6 +175,77 @@ Post.count_tags
 Post.tags.group(:tag).count
 ```
 
+#### any_#{tag_name}(value, delimiter = ',')
+It will create some scopes, this is useful for using ransack
+```Ruby
+Post.any_tags(['food', 'travel'])
+
+# equal to
+Post.where(any_tags: ['food', 'travel'])
+```
+
+Scope support string input
+```Ruby
+Post.any_tags('food,travel')
+Post.any_tags('food|travel', '|')
+```
+
+#### all_#{tag_name}(value, delimiter = ',')
+```Ruby
+Post.all_tags(['food', 'travel'])
+
+# equal to
+Post.where(all_tags: ['food', 'travel'])
+```
+
+#### #{tag_name}_in(value, delimiter = ',')
+```Ruby
+Post.tags_in(['food', 'travel'])
+
+# equal to
+Post.where(tags_in: ['food', 'travel'])
+```
+
+#### #{tag_name}_eq(value, delimiter = ',')
+```Ruby
+Post.tags_eq(['food', 'travel'])
+
+# equal to
+Post.where(tags_eq: ['food', 'travel'])
+```
+
+#### not_any_#{tag_name}(value, delimiter = ',')
+```Ruby
+Post.not_any_tags(['food', 'travel'])
+
+# equal to
+Post.where.not(any_tags: ['food', 'travel'])
+```
+
+#### not_all_#{tag_name}(value, delimiter = ',')
+```Ruby
+Post.not_all_tags(['food', 'travel'])
+
+# equal to
+Post.where.not(all_tags: ['food', 'travel'])
+```
+
+#### not_#{tag_name}_in(value, delimiter = ',')
+```Ruby
+Post.not_tags_in(['food', 'travel'])
+
+# equal to
+Post.where.not(tags_in: ['food', 'travel'])
+```
+
+#### not_#{tag_name}_eq(value, delimiter = ',')
+```Ruby
+Post.not_tags_eq(['food', 'travel'])
+
+# equal to
+Post.where.not(tags_eq: ['food', 'travel'])
+```
+
 ### Case Insensitive
 If you use `string` type, it is case sensitive.
 ```Ruby
@@ -209,6 +280,21 @@ post.tags
 # => ['food', 'travel']
 ```
 
+### Ransack
+You can use with ransack
+```Ruby
+class Post < ActiveRecord::Base
+  def self.ransackable_scopes(_auth_object = nil)
+    %i[all_tags]
+  end
+end
+```
+
+And you can search
+```Ruby
+Post.ransack(all_tags: 'foold,travel')
+```
+
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 

data/lib/pg_taggable/predicate_handler.rb

@@ -15,7 +15,7 @@ module PgTaggable
         bind_param = Arel::Nodes::BindParam.new(query_attribute)
         if operator == '='
           operator = '@>'
-          Arel::Nodes::NamedFunction.new('ARRAY_LENGTH', [attribute, 1]).eq(query.size).and(
+          Arel::Nodes::NamedFunction.new('ARRAY_LENGTH', [ attribute, 1 ]).eq(query.size).and(
             Arel::Nodes::InfixOperation.new(operator, attribute, bind_param)
           )
         else

data/lib/pg_taggable/taggable.rb

@@ -16,13 +16,14 @@ module PgTaggable
 
     def taggable(name, unique: true)
       type = type_for_attribute(name)
-      @@taggable_attributes ||= {}
-      @@taggable_attributes = @@taggable_attributes.merge(
+      taggable_attributes = {
         "any_#{name}" => [ name, type, '&&' ],
         "all_#{name}" => [ name, type, '@>' ],
         "#{name}_in" => [ name, type, '<@' ],
         "#{name}_eq" => [ name, type, '=' ]
-      )
+      }
+      @@taggable_attributes ||= {}
+      @@taggable_attributes = @@taggable_attributes.merge(taggable_attributes)
 
       if unique
         if type.type == :citext
@@ -33,8 +34,13 @@ module PgTaggable
       end
 
       scope name, -> { unscope(:where).from(select("UNNEST(#{table_name}.#{name}) AS tag"), table_name) }
-      scope "uniq_#{name}", -> { public_send(name).distinct.pluck(:tag) }
+      scope "distinct_#{name}", -> { public_send(name).select(:tag).distinct }
+      scope "uniq_#{name}", -> { public_send("distinct_#{name}").pluck(:tag) }
       scope "count_#{name}", -> { public_send(name).group(:tag).count }
+      taggable_attributes.keys.each do |key|
+        scope key, ->(value, delimiter = ',') { where(key => value.is_a?(Array) ? value : value.split(delimiter)) }
+        scope "not_#{key}", ->(value, delimiter = ',') { where.not(key => value.is_a?(Array) ? value : value.split(delimiter)) }
+      end
     end
   end
 end

data/lib/pg_taggable/version.rb

@@ -1,3 +1,3 @@
 module PgTaggable
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_taggable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Yi-Cyuan Chen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-05 00:00:00.000000000 Z
+date: 2025-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails