pg_tags_on 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c61bd469e5458dd169e871a3af323806c36380beba46a575506d33cd18c730dd
-  data.tar.gz: c88ad1665a25c7e9ec406de248bdd0e845c5a1fe20d8fffd93e7e979a5a227fd
+  metadata.gz: cf52d9810e0c765b90218fc5ef9f4bbd5ceb3f9f092e7fa4ade42d946165a8a1
+  data.tar.gz: 9911f4f06c06b5f3673220292b6cc0e36122a5ad2a86b3d587ed2565e8c66080
 SHA512:
-  metadata.gz: 05c51681cf87704fb8363f147470e5d4ce85a1c7390f064c055f7da19cdb79a419d046eed1432992ca0e002afe50685fff0d1f84f14b472f8ebc4bf6e7df5d44
-  data.tar.gz: 7481b613c53054dd15ba0cef620dd25ba3f1d09d8b10b5d5a69d03ddc1f02c5c3cedca1f9787bc68fdbb925dd612ff0bc18ca6b1b7413fce70aebb81e50bb887
+  metadata.gz: 572db674007f2555744fb8420a847ae813caac80a2f9a803399f90207be5bf0f1c54efc536259d5395eb69248bba8af76ae345623e0972cebe782084d397132f
+  data.tar.gz: 8731695a2ac40afcba1dcf22d410fb78234b29ff67033d443a121ff2baf4838fab4d9859ac670d5713d718d91d416177246c5e50b5b08e4e066594ff97cc5727

data/lib/pg_tags_on/predicate_handler/array_jsonb_handler.rb

@@ -7,7 +7,7 @@ module PgTagsOn
       # Transforms value in Hash if :key option is set
       def value
         @value ||= begin
-          return query_value unless key?
+          return query_value unless nested?
 
           query_value.each.map do |val|
             key.reverse.inject(val) { |a, n| { n => a } }
@@ -23,7 +23,7 @@ module PgTagsOn
         @key ||= Array.wrap(settings[:key])
       end
 
-      def key?
+      def nested?
         key.present?
       end
     end

data/lib/pg_tags_on/predicate_handler/array_jsonb_with_attrs_handler.rb

@@ -13,11 +13,9 @@ module PgTagsOn
       }.freeze
 
       def left
-        node = arel_function('array_to_json', attribute)
-        node = arel_cast(node, 'jsonb')
-        node = arel_function('jsonb_path_query_array', node, arel_build_quoted("$[*].#{key.join('.')}"))
-
-        node
+        arel_function 'jsonb_path_query_array',
+                      arel_cast(arel_function('array_to_json', attribute), 'jsonb'),
+                      arel_build_quoted("$[*].#{key.join('.')}")
       end
 
       def right

data/lib/pg_tags_on/predicate_handler.rb

@@ -2,7 +2,7 @@
 
 module PgTagsOn
   # Models' predicate handlers register this class
-  class PredicateHandler < ::ActiveRecord::PredicateBuilder::BaseHandler
+  class PredicateHandler < ::ActiveRecord::PredicateBuilder::BasicObjectHandler
     def call(attribute, query)
       handler = Builder.new(attribute, query, predicate_builder).call
 
@@ -21,7 +21,7 @@ module PgTagsOn
         if column.array?
           array_handler
         else
-          BaseHandler.new(attribute, query, predicate_builder)
+          BasicObjectHandler.new attribute, query, predicate_builder
         end
       end
 

data/lib/pg_tags_on/repositories/array_jsonb/create.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  module Repositories
+    module ArrayJsonb
+      # This class is respnsible to create tags stored as JSON objects.
+      class Create
+        include ::PgTagsOn::ActiveRecord::Arel
+
+        delegate :column_name, :arel_column, :bind_for, to: :repository
+
+        def call(repository:, relation:, tags:, returning: nil)
+          @repository = repository
+          value = arel_array_cat arel_column, bind_for(Array.wrap(tags))
+
+          repository.update_attributes relation: relation,
+                                       attributes: { column_name => value },
+                                       returning: returning
+        end
+
+        private
+
+        attr_reader :repository
+      end
+    end
+  end
+end

data/lib/pg_tags_on/repositories/array_jsonb/delete.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  module Repositories
+    module ArrayJsonb
+      # This class is respnsible to delete tags stored as JSON objects.
+      class Delete
+        include ::PgTagsOn::ActiveRecord::Arel
+
+        delegate :column_name, :tag_alias,
+                 :arel_column, :bind_for, to: :repository
+
+        def call(repository:, relation:, tags:, returning: nil)
+          @repository = repository
+          @tags = tags
+
+          repository.update_attributes relation: relation,
+                                       attributes: { column_name => arel_function('array', active_tags) },
+                                       returning: returning
+        end
+
+        private
+
+        attr_reader :repository, :tags
+
+        ##
+        # For each record explode tags and filter out tags to be removed
+        #
+        def active_tags
+          query = Arel::SelectManager.new
+                                     .project(tag_alias)
+                                     .from(Arel::SelectManager.new
+                                            .project(arel_unnest(arel_column).as(tag_alias))
+                                            .as('update_tags'))
+          Array.wrap(tags).each do |tag|
+            query.where arel_infix_operation('@>', Arel.sql(tag_alias), bind_for(tag.to_json, nil)).not
+          end
+
+          query
+        end
+      end
+    end
+  end
+end

data/lib/pg_tags_on/repositories/array_jsonb/update.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  module Repositories
+    module ArrayJsonb
+      # This class is respnsible to update tags stored as JSON objects.
+      class Update
+        include ::PgTagsOn::ActiveRecord::Arel
+
+        delegate :table_name, :column_name, :tag_alias,
+                 :arel_table, :arel_column, :cast_type, :bind_for, to: :repository
+
+        def call(repository:, relation:, tag:, new_tag:, returning: nil)
+          @repository = repository
+          @relation = relation
+          sql = <<-SQL
+            WITH tag_positions AS ( #{select_tag_positions(tag).to_sql} )
+            UPDATE #{table_name}
+            SET #{column_name}[index] = #{column_name}[index] || $2
+            FROM tag_positions
+            WHERE #{table_name}.id = tag_positions.id
+          SQL
+          sql += " RETURNING #{returning}" if returning.present?
+          bindings = [
+            arel_query_attribute(arel_column, tag.to_json, cast_type),
+            arel_query_attribute(arel_column, new_tag.to_json, cast_type)
+          ]
+
+          result = relation.connection.exec_query(sql, 'SQL', bindings).rows
+
+          returning ? result : true
+        end
+
+        private
+
+        attr_reader :repository, :relation
+
+        ##
+        # For each record explode tags and their position index
+        # and select only occurences of the given tag value
+        #
+        # @param tag [String|Hash] Normalized tag value.
+        #
+        def select_tag_positions(tag)
+          condition1 = arel_infix_operation '@>',
+                                            Arel::Table.new('t')[tag_alias],
+                                            bind_for(tag.to_json, nil)
+          condition2 = arel_table[:id].in arel_sql(relation.reselect('id').to_sql)
+
+          arel_table
+            .project("id, #{tag_alias}, index")
+            .from("#{table_name}, #{arel_unnest(arel_column).to_sql} WITH ORDINALITY t(#{tag_alias}, index)")
+            .where(condition1)
+            .where(condition2)
+        end
+      end
+    end
+  end
+end

data/lib/pg_tags_on/repositories/array_jsonb_repository.rb

@@ -4,107 +4,134 @@ module PgTagsOn
   module Repositories
     # Operatons for 'jsonb[]' column type
     class ArrayJsonbRepository < ArrayRepository
-      def create(tag_or_tags, returning: nil)
-        tags = normalize_tags(tag_or_tags)
+      ##
+      # Tag's key in the JSON object.
+      # Can be a String or Array for nested attributes.
+      #
+      # @example
+      #   { "name" => "lorem" } ;              key = 'tag'
+      #   { "tag" => { "name" => "lorem" } } ; key = ['tag', 'name']
+      #
+      def key
+        @key ||= options[:key]
+      end
 
-        super(tags, returning: returning)
+      ##
+      # Returns true if JSON object has nested attributes.
+      #
+      def nested?
+        key.present?
       end
 
-      def update(tag, new_tag, returning: nil)
-        n_tag, n_new_tag = normalize_tags([tag, new_tag])
+      ##
+      # Add tag(s) to records.
+      #
+      # @param tag_or_tags [String|Array] Tags to be added.
+      # @param returning   [String]         Model's columns that'll be returned.
+      #
+      # @return [Array|Boolean] Returns boolean if :returning argument is nil
+      #
+      # @example
+      #   Entity.tags.create "lorem", returning: "id,name"
+      #     => [[1, 'row1'], [2, 'row2']]
+      #
+      def create(tag_or_tags, returning: nil)
+        tags = normalize_tags tag_or_tags
 
-        sql_set = <<-SQL.strip
-          #{column_name}[index] = #{column_name}[index] || $2
-        SQL
+        ArrayJsonb::Create.new.call repository: self,
+                                    relation: klass,
+                                    tags: tags,
+                                    returning: returning
+      end
 
-        update_tag(n_tag,
-                   sql_set,
-                   bindings: [query_attribute(n_new_tag.to_json)],
-                   returning: returning)
+      ##
+      # Rename tag(s).
+      #
+      # @param tag       [String] Tag that'll be renamed.
+      # @param new_tag   [String] New tag name.
+      # @param returning [String] Model's columns that'll be returned.
+      #
+      # @return [Array|Boolean] Returns boolean if :returning argument is nil
+      #
+      # @example
+      #   Entity.tags.update "lorem", "ipsum", returning: "id,name"
+      #     => [[1, 'row1'], [2, 'row2']]
+      #
+      def update(tag, new_tag, returning: nil)
+        tag = normalize_one_tag tag
+        new_tag = normalize_one_tag new_tag
+
+        ArrayJsonb::Update.new.call repository: self,
+                                    relation: klass,
+                                    tag: tag,
+                                    new_tag: new_tag,
+                                    returning: returning
       end
 
+      ##
+      # Delete tag(s).
+      #
+      # @param tag_or_tags [String] Tag that'll be renamed.
+      # @param returning   [String] Model's columns that'll be returned.
+      #
+      # @return [Array|Boolean] Returns boolean if :returning argument is nil
+      #
+      # @example
+      #   Entity.tags.delete "lorem", returning: "id,name"
+      #     => [[1, 'row1'], [2, 'row2']]
+      #
       def delete(tag_or_tags, returning: nil)
-        tags = normalize_tags(tag_or_tags)
-        sm = build_tags_select_manager
+        tags = normalize_tags tag_or_tags
+        relation = klass.where(column_name => PgTagsOn.query_class.any(tag_or_tags))
 
-        tags.each do |tag|
-          sm.where(arel_infix_operation('@>', Arel.sql('tag'), bind_for(tag.to_json, nil)).not)
-        end
-
-        rel = klass.where(column_name => PgTagsOn.query_class.any(tag_or_tags))
-        value = arel_function('array', sm)
-
-        perform_update(rel, { column_name => value }, returning: returning)
+        ArrayJsonb::Delete.new.call repository: self,
+                                    relation: relation,
+                                    tags: tags,
+                                    returning: returning
       end
 
-      private
+      def normalize_tags(tags)
+        return normalize_one_tag(tags) unless tags.is_a?(Array)
 
-      # Returns SelectManager for unnested tags.
-      # sql: select tag from ( select unnest(tags_jsonb) as tag ) as _tags
-      def build_tags_select_manager
-        Arel::SelectManager.new
-                           .project('tag')
-                           .from(Arel::SelectManager.new
-                  .project(unnest.as('tag'))
-                  .as('_tags'))
+        tags.map { |t| normalize_one_tag(t) }
       end
 
-      def normalize_tags(tag_or_tags)
-        tags = Array.wrap(tag_or_tags)
-
-        return tags unless key?
+      def normalize_one_tag(tag)
+        return tag unless nested?
+        return { key => tag } unless key.is_a?(Array)
 
-        tags.map do |tag|
-          Array.wrap(key).reverse.inject(tag) { |a, n| { n => a } }
-        end
+        key.reverse.inject(tag) { |a, k| { k => a } }
       end
 
-      def array_to_recordset
-        return unnest unless key?
+      ##
+      # @return [Arel::SelectManager]
+      #
+      def select_tags
+        return super unless nested?
 
-        arel_jsonb_extract_path(unnest, *key_sql)
+        klass
+          .select(arel_distinct(extract_tag_by_path).as(tag_alias))
+          .arel
       end
 
-      def key
-        @key ||= options[:key]
-      end
+      ##
+      # @return [Arel::SelectManager]
+      #
+      def select_taggings
+        return super unless nested?
 
-      def key_sql
-        @key_sql ||= Array.wrap(key).map { |k| Arel.sql("'#{k}'") }
+        klass
+          .select(extract_tag_by_path.as(tag_alias),
+                  arel_table['id'].as('entity_id'))
+          .arel
       end
 
-      def key?
-        key.present?
+      def tag_path_array
+        @tag_path_array ||= Array.wrap(key).map { |k| Arel.sql("'#{k}'") }
       end
 
-      def taggings_with_ordinality_query(tag)
-        column = Arel::Table.new('t')['name']
-        value = bind_for(tag.to_json, nil)
-
-        arel_table
-          .project('id, name, index')
-          .from("#{table_name}, #{unnest_with_ordinality}")
-          .where(arel_infix_operation('@>', column, value))
-      end
-
-      def update_tag(tag, set_sql, bindings: [], returning: nil)
-        subquery = taggings_with_ordinality_query(tag)
-                   .where(arel_table[:id].in(arel_sql(klass.reselect('id').to_sql)))
-
-        sql = <<-SQL.strip
-          WITH records as ( #{subquery.to_sql} )
-          UPDATE #{table_name}
-          SET #{set_sql}
-          FROM records
-          WHERE #{table_name}.id = records.id
-        SQL
-
-        sql += " RETURNING #{Array.wrap(returning).join(', ')}" if returning.present?
-
-        bindings = [query_attribute(tag.to_json)] + Array.wrap(bindings)
-        result = klass.connection.exec_query(sql, 'SQL', bindings).rows
-
-        returning ? result : true
+      def extract_tag_by_path
+        arel_jsonb_extract_path arel_unnest(arel_column), *tag_path_array
       end
     end
   end

data/lib/pg_tags_on/repositories/array_repository.rb

@@ -4,112 +4,163 @@ module PgTagsOn
   module Repositories
     # This repository works with "character varying[]" and "integer[]" column types
     class ArrayRepository < BaseRepository
+      ##
+      # Select all tags ordered by name
+      #
+      # @return [Array[PgTagsOn::Tag]] Tags list.
+      #
+      # @example
+      #   Entity.tags.all
+      #
       def all
-        subquery = klass
-                   .select(arel_distinct(array_to_recordset).as('name'))
-                   .arel
-                   .as('tags')
-
         PgTagsOn::Tag
           .select(Arel.star)
-          .from(subquery)
-          .order('tags.name') # override rails' default order by id
-      end
-
+          .from(select_tags.as('tags'))
+          .order(tag_alias)
+      end
+
+      ##
+      # Select all tags with counts
+      #
+      # @return [Array[PgTagsOn::Tag]] Tags list.
+      #
+      # @example
+      #   Entity.tags.all_with_counts
+      #
       def all_with_counts
         taggings
-          .except(:select)
-          .select('name, count(name) as count')
-          .group('name')
+          .reselect("#{tag_alias}, count(*) as count")
+          .group(tag_alias)
       end
 
+      ##
+      # Find one tag.
+      #
+      # @return [PgTagsOn::Tag]
+      #
       def find(tag)
         all.where(name: tag).first
       end
 
+      ##
+      # Returns true if tag exists.
+      #
+      # @return [Boolean]
+      #
       def exists?(tag)
-        all.exists?(tag)
+        all.exists? tag
       end
 
+      ##
+      # Select taggings.
+      #
+      # @return [[PgTagsOn::Tag<entity_id, name>]]
+      #
       def taggings
         PgTagsOn::Tag
           .select(Arel.star)
-          .from(taggings_query)
-          .order('taggings.name')
+          .from(select_taggings.as('taggings'))
+          .order(tag_alias)
       end
 
+      ##
+      # Get tags count.
+      #
       def count
         all.count
       end
 
+      ##
+      # Add tag(s) to records.
+      #
+      # @param tag_or_tags [String|Array] Tags to be added.
+      # @param returning   [String]         Model's columns that'll be returned.
+      #
+      # @return [Array|Boolean] Returns boolean if :returning argument is nil
+      #
+      # @example
+      #   Entity.tags.create "lorem", returning: "id,name"
+      #     => [[1, 'row1'], [2, 'row2']]
+      #
       def create(tag_or_tags, returning: nil)
-        value = arel_array_cat(arel_column, bind_for(Array.wrap(tag_or_tags)))
-
-        perform_update(klass, { column_name => value }, returning: returning)
-      end
-
+        ArrayValue::Create.new.call repository: self,
+                                    relation: klass,
+                                    tags: tag_or_tags,
+                                    returning: returning
+      end
+
+      ##
+      # Rename tag(s).
+      #
+      # @param tag       [String] Tag that'll be renamed.
+      # @param new_tag   [String] New tag name.
+      # @param returning [String] Model's columns that'll be returned.
+      #
+      # @return [Array|Boolean] Returns boolean if :returning argument is nil
+      #
+      # @example
+      #   Entity.tags.update "lorem", "ipsum", returning: "id,name"
+      #     => [[1, 'row1'], [2, 'row2']]
+      #
       def update(tag, new_tag, returning: nil)
-        rel = klass.where(column_name => PgTagsOn.query_class.one(tag))
-        value = arel_array_replace(arel_column, bind_for(tag), bind_for(new_tag))
+        relation = klass.where(column_name => PgTagsOn.query_class.one(tag))
+
+        ArrayValue::Update.new.call repository: self,
+                                    relation: relation,
+                                    tag: tag,
+                                    new_tag: new_tag,
+                                    returning: returning
+      end
+
+      ##
+      # Delete tag(s).
+      #
+      # @param tag_or_tags [String] Tag that'll be renamed.
+      # @param returning   [String] Model's columns that'll be returned.
+      #
+      # @return [Array|Boolean] Returns boolean if :returning argument is nil
+      #
+      # @example
+      #   Entity.tags.delete "lorem", returning: "id,name"
+      #     => [[1, 'row1'], [2, 'row2']]
+      #
+      def delete(tag_or_tags, returning: nil)
+        relation = klass.where(column_name => PgTagsOn.query_class.any(tag_or_tags))
 
-        perform_update(rel, { column_name => value }, returning: returning)
+        ArrayValue::Delete.new.call repository: self,
+                                    relation: relation,
+                                    tags: tag_or_tags,
+                                    returning: returning
       end
 
-      def delete(tag_or_tags, returning: nil)
-        tags = Array.wrap(tag_or_tags)
-        rel = klass.where(column_name => PgTagsOn.query_class.any(tags))
-        sm = Arel::SelectManager.new
-                                .project(unnest)
-                                .except(
-                                  Arel::SelectManager.new
-                                    .project(arel_unnest(arel_cast(bind_for(tags), native_column_type)))
-                                )
-        value = arel_function('array', sm)
-
-        perform_update(rel, { column_name => value }, returning: returning)
+      def tag_alias
+        'name'
       end
 
-      private
-
-      def perform_update(rel, updates, returning: nil)
-        update_manager = get_update_manager(rel, updates)
-        sql, binds = klass.connection.send :to_sql_and_binds, update_manager
-        sql += " RETURNING #{Array.wrap(returning).join(', ')}" if returning.present?
-
-        result = klass.connection.exec_query(sql, 'SQL', binds).rows
+      # protected
 
-        returning ? result : true
-      end
-
-      def taggings_query
+      ##
+      # @return [Arel::SelectManager]
+      #
+      def select_tags
         klass
-          .select(
-            array_to_recordset.as('name'),
-            arel_table['id'].as('entity_id')
-          )
+          .select(arel_distinct(arel_unnest(arel_column)).as(tag_alias))
           .arel
-          .as('taggings')
-      end
-
-      def unnest
-        arel_unnest(arel_column)
-      end
-
-      def array_to_recordset
-        unnest
-      end
-
-      def unnest_with_ordinality(alias_table: 't')
-        "#{unnest.to_sql} WITH ORDINALITY #{alias_table}(name, index)"
       end
 
-      def query_attribute(value)
-        arel_query_attribute(arel_column, value, cast_type)
+      ##
+      # @return [Arel::SelectManager]
+      #
+      def select_taggings
+        klass
+          .select(arel_unnest(arel_column).as(tag_alias),
+                  arel_table['id'].as('entity_id'))
+          .arel
       end
 
       def bind_for(value, attr = arel_column)
-        query_attr = arel_query_attribute(attr, value, cast_type)
-        arel_bind(query_attr)
+        query_attr = arel_query_attribute attr, value, cast_type
+        arel_bind query_attr
       end
     end
   end

data/lib/pg_tags_on/repositories/array_value/create.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  module Repositories
+    module ArrayValue
+      # This class is respnsible to delete tags stored as JSON objects.
+      class Create
+        include ::PgTagsOn::ActiveRecord::Arel
+
+        delegate :column_name, :arel_column, :bind_for, to: :repository
+
+        def call(repository:, relation:, tags:, returning: nil)
+          @repository = repository
+          value = arel_array_cat arel_column, bind_for(Array.wrap(tags))
+
+          repository.update_attributes relation: relation,
+                                       attributes: { column_name => value },
+                                       returning: returning
+        end
+
+        private
+
+        attr_reader :repository, :tags
+      end
+    end
+  end
+end

data/lib/pg_tags_on/repositories/array_value/delete.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  module Repositories
+    module ArrayValue
+      # This class is respnsible to delete tags stored as JSON objects.
+      class Delete
+        include ::PgTagsOn::ActiveRecord::Arel
+
+        delegate :column_name, :arel_column, :bind_for, :native_column_type, to: :repository
+
+        def call(repository:, relation:, tags:, returning: nil)
+          @repository = repository
+          @tags = tags
+
+          repository.update_attributes relation: relation,
+                                       attributes: { column_name => arel_function('array', active_tags) },
+                                       returning: returning
+        end
+
+        private
+
+        attr_reader :repository, :tags
+
+        ##
+        # For each record explode tags and filter out tags to be removed
+        #
+        def active_tags
+          Arel::SelectManager.new
+                             .project(arel_unnest(arel_column))
+                             .except(Arel::SelectManager.new
+                              .project(arel_unnest(arel_cast(bind_for(Array.wrap(tags)), native_column_type))))
+        end
+      end
+    end
+  end
+end

data/lib/pg_tags_on/repositories/array_value/update.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PgTagsOn
+  module Repositories
+    module ArrayValue
+      # This class is respnsible to delete tags stored as JSON objects.
+      class Update
+        include ::PgTagsOn::ActiveRecord::Arel
+
+        delegate :column_name, :arel_column, :bind_for, to: :repository
+
+        def call(repository:, relation:, tag:, new_tag:, returning: nil)
+          @repository = repository
+          value = arel_array_replace arel_column, bind_for(tag), bind_for(new_tag)
+
+          repository.update_attributes relation: relation,
+                                       attributes: { column_name => value },
+                                       returning: returning
+        end
+
+        private
+
+        attr_reader :repository, :tags
+      end
+    end
+  end
+end

data/lib/pg_tags_on/repositories/base_repository.rb

@@ -36,22 +36,27 @@ module PgTagsOn
         arel_table[column_name]
       end
 
-      # Returns ActiveRecord Column instance
+      ##
+      # ActiveRecord Column instance
+      #
       def ar_column
         @ar_column ||= klass.columns_hash[column_name.to_s]
       end
 
-      def ref
-        "#{table_name}.#{column_name}"
-      end
-
-      # Returns Type instance
+      ##
+      # Column's Type instance
+      #
+      # @return [ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array]
+      #
       def cast_type
         @cast_type ||= klass.type_for_attribute(column_name)
       end
 
-      # Returns db type as string.
-      # Ex: character varying[], integer[]
+      ##
+      # Database column type as string.
+      #
+      # @return [String] "character varying[]", "integer[]"
+      #
       def native_column_type
         type = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES.fetch(cast_type.type)[:name]
         type += '[]' if ar_column.array?
@@ -60,20 +65,30 @@ module PgTagsOn
       end
 
       # Method copied from ActiveRecord as there is no way to inject sql into update manager.
-      def get_update_manager(rel, updates)
+      def get_update_manager(relation:, updates:)
         raise ArgumentError, 'Empty list of attributes to change' if updates.blank?
 
         stmt = ::Arel::UpdateManager.new
         stmt.table(arel_table)
         stmt.key = arel_table[klass.primary_key]
-        stmt.take(rel.arel.limit)
-        stmt.offset(rel.arel.offset)
-        stmt.order(*rel.arel.orders)
-        stmt.wheres = rel.arel.constraints
-        stmt.set rel.send(:_substitute_values, updates)
+        stmt.take(relation.arel.limit)
+        stmt.offset(relation.arel.offset)
+        stmt.order(*relation.arel.orders)
+        stmt.wheres = relation.arel.constraints
+        stmt.set relation.send(:_substitute_values, updates)
 
         stmt
       end
+
+      def update_attributes(relation:, attributes:, returning: nil)
+        manager = get_update_manager relation: relation, updates: attributes
+        sql, binds = klass.connection.send :to_sql_and_binds, manager
+        sql += " RETURNING #{returning}" if returning.present?
+
+        result = klass.connection.exec_query(sql, 'SQL', binds).rows
+
+        returning ? result : true
+      end
     end
   end
 end

data/lib/pg_tags_on/repository.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 module PgTagsOn
+  ##
   # Repository class for tags.
+  #
   # Examples:
   #
   #   repo = PgTagsOn::Repository.new(Entity, :tags)

data/lib/pg_tags_on/tags_query.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module PgTagsOn
+  ##
   # Helper class to construct queries.
   # This class is registered in models' predicate builders.
   # See configuration in order to create an alias for it.
@@ -14,9 +15,7 @@ module PgTagsOn
       RUBY
     end
 
-    attr_reader :value
-    attr_reader :predicate
-    attr_reader :options
+    attr_reader :value, :predicate, :options
 
     def initialize(value, predicate, options = {})
       @value = value

data/lib/pg_tags_on/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgTagsOn
-  VERSION = '0.4.0'
+  VERSION = '1.0.0'
 end

data/lib/pg_tags_on.rb

@@ -18,7 +18,13 @@ require 'pg_tags_on/validations/validator'
 require 'pg_tags_on/repository'
 require 'pg_tags_on/repositories/base_repository'
 require 'pg_tags_on/repositories/array_repository'
+require 'pg_tags_on/repositories/array_value/create'
+require 'pg_tags_on/repositories/array_value/update'
+require 'pg_tags_on/repositories/array_value/delete'
 require 'pg_tags_on/repositories/array_jsonb_repository'
+require 'pg_tags_on/repositories/array_jsonb/create'
+require 'pg_tags_on/repositories/array_jsonb/update'
+require 'pg_tags_on/repositories/array_jsonb/delete'
 require 'pg_tags_on/benchmark/benchmark'
 
 # PgTagsOn configuration methods

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_tags_on
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Catalin Marinescu
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-02 00:00:00.000000000 Z
+date: 2022-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,42 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 1.2.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 1.2.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -106,8 +106,14 @@ files:
 - lib/pg_tags_on/predicate_handler/array_string_handler.rb
 - lib/pg_tags_on/predicate_handler/array_text_handler.rb
 - lib/pg_tags_on/predicate_handler/base_handler.rb
+- lib/pg_tags_on/repositories/array_jsonb/create.rb
+- lib/pg_tags_on/repositories/array_jsonb/delete.rb
+- lib/pg_tags_on/repositories/array_jsonb/update.rb
 - lib/pg_tags_on/repositories/array_jsonb_repository.rb
 - lib/pg_tags_on/repositories/array_repository.rb
+- lib/pg_tags_on/repositories/array_value/create.rb
+- lib/pg_tags_on/repositories/array_value/delete.rb
+- lib/pg_tags_on/repositories/array_value/update.rb
 - lib/pg_tags_on/repositories/base_repository.rb
 - lib/pg_tags_on/repository.rb
 - lib/pg_tags_on/tag.rb
@@ -130,14 +136,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.9
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Query and manage tags stored in a Postgresql column.