pg_tags_on 0.1.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aac909ac252ee49fd469857036866fb22fbc78db87e19f84f8448637a780af6c
-  data.tar.gz: 4ba45da54dc2782a11ce1cb67b5e61077447f544fcac29c0620c4e261d572ee0
+  metadata.gz: cf52d9810e0c765b90218fc5ef9f4bbd5ceb3f9f092e7fa4ade42d946165a8a1
+  data.tar.gz: 9911f4f06c06b5f3673220292b6cc0e36122a5ad2a86b3d587ed2565e8c66080
 SHA512:
-  metadata.gz: 19090081b0fe790204a5384bc85c9e90d29ea824eeb0ace2b103e6a68010379f65fd05e0deef79474a7bbfaa6fdb01b59aaf62d151af2f48317f502a70b43a4c
-  data.tar.gz: 0d2da6a30730fc639b915ceaf88a47bc6219d9ef111188a8f935f39aae936f6afbb36afbbef624ba6fb4b7f35eede5c89c3d0b3b917e526794c73cc16fa988a0
+  metadata.gz: 572db674007f2555744fb8420a847ae813caac80a2f9a803399f90207be5bf0f1c54efc536259d5395eb69248bba8af76ae345623e0972cebe782084d397132f
+  data.tar.gz: 8731695a2ac40afcba1dcf22d410fb78234b29ff67033d443a121ff2baf4838fab4d9859ac670d5713d718d91d416177246c5e50b5b08e4e066594ff97cc5727

data/CHANGELOG.md

@@ -1,3 +1,24 @@
-## 0.1.0 ( 2020-03-11 ) ##
+# Changelog
+
+## [0.4.0] - 2020-06-02
+- bump gems versions
+- ISSUE_TEMPLATE.md
+
+## [0.3.0] - 2020-04-15
+- apply PR for gem versions
+- fixed Arel deprecation warning
+- changed validation param names
+
+## [0.2.0] - 2020-09-02
+- Added support for multiple tags creation and deletion
+- Optimizations
+- Updated specs and documentation
+
+## [0.1.4] - 2020-04-12
+- Added support for returning columns after create,update or delete tags operations
+- Updated specs
+- Updated documentation
+
+## [0.1.0] - 2020-03-11
+- First release
 
-* First release

data/README.md

@@ -1,6 +1,6 @@
 # PgTagsOn
 
-```pg_tags_on``` is a gem that makes working with tags stored in a Postgresql column easy. Supported column types are: ```character varying[]```, ```text[]```, ```integer[]``` and ```jsonb[]```.
+```pg_tags_on``` - keep tags in a column. Supported column types are: ```character varying[]```, ```text[]```, ```integer[]``` and ```jsonb[]```.
 
 
 Requirements:
@@ -15,7 +15,7 @@ Note: this gem is in early stage of development.
 - [Installation](#installation)
 - [Usage](#usage)
   - [ActiveRecord model setup](#activerecord-model-setup)
-  - [Records queries](#records-queries)
+  - [Records queries](#queries)
   - [Tags](#tags)
   - [Set record's tags](#set-records-tags)
   - [Configuration](#configuration)
@@ -42,7 +42,7 @@ Or install it yourself as:
 ## Usage
 ### ActiveRecord model setup
 
-One or multiple columns can be specified:
+One or multiple columns that store tags can be specified:
 
 ```ruby
 class Entity < ActiveRecord::Base
@@ -51,7 +51,7 @@ class Entity < ActiveRecord::Base
 end
 ```
 
-For ```jsonb[]``` columns you'll have to specify the key for the tag value. If you store multiple attributes in the objects then you must set also ```has_attributes: true```.
+In ```jsonb[]``` columns, by default each tag is stored as an object with a single key. For example ```{"tag": "rubygems"}```. If you store multiple attributes in the objects, then you must set also ```has_attributes: true```.
 
 ```ruby
 class Entity < ActiveRecord::Base
@@ -65,7 +65,7 @@ Maximum number of tags and maximum tag length can be validated. Errors will be i
 
 ```ruby
 class Entity < ActiveRecord::Base
-  pg_tags_on :tags, limit: 10, tag_length: 50 # limit to 10 tags and 50 chars. per tag.
+  pg_tags_on :tags, limit: 10, length: 50 # limit to 10 tags and 50 chars. per tag.
 end
 ```
 
@@ -140,20 +140,22 @@ Entity.tags.taggings
   => [#<PgTagsOn::Tag name: "alpha", entity_id: 1>, #<PgTagsOn::Tag name: "beta", entity_id: 1>, #<PgTagsOn::Tag name: "alpha", entity_id: 2>, ... ]
 ```
 
-Create, update and delete methods are using, for performance reasons, Postgresql functions to manipulate the arrays, so ActiveRecord models are not instantiated. A frequent problem is to ensure uniqueness of the tags for a record, but this can be achieved at the database level by creating a before create/update row trigger.
+Create, update and delete methods are using, for performance reasons, Postgresql functions to manipulate the arrays, so ActiveRecord models are not instantiated. A frequent problem is to ensure uniqueness of the tags for a record, and this can be achieved at the database level by creating a before create/update row trigger.
 
 ```ruby
 # create
-Entity.tags.create('alpha')             # add tag to all records
-Entity.where(...).tags.create('alpha')  # add tag to filtered records
+Entity.tags.create('alpha')              # add tag to all records
+Entity.tags.create(%w[alpha beta gamma]) # add many tags to all records
+Entity.where(...).tags.create('alpha')   # add tag to filtered records
 
 # update
 Entity.tags.update('alpha', 'a')             # rename tag for all records
 Entity.where(...).tags.update('alpha', 'a')  # rename tag for filtered records
 
 # delete
-Entity.tags.delete('alpha')             # delete tag from all records
-Entity.where(...).tags.delete('alpha')  # delete tag from filtered records
+Entity.tags.delete('alpha')              # delete tag from all records
+Entity.tags.delete(%w[alpha beta gamma]) # delete many tags from all records
+Entity.where(...).tags.delete('alpha')   # delete tag from filtered records
 
 # any of these methods accepts :returning option
 Entity.tags.update('alpha', 'a', returning: %w[id tags])

data/lib/pg_tags_on/active_record/base.rb

@@ -12,7 +12,7 @@ module PgTagsOn
 
           pg_tags_on_init_model unless @pg_tags_on_init_model
           pg_tags_on_settings[name] = options.deep_symbolize_keys
-          validates(name, 'pg_tags_on/tags': true) if %i[limit tag_length].any? { |k| options[k] }
+          validates(name, 'pg_tags_on/tags': true) if %i[limit length].any? { |k| options[k] }
           instance_eval <<-RUBY, __FILE__, __LINE__ + 1
             scope :#{name}, -> { PgTagsOn::Repository.new(self, "#{name}") }
           RUBY

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,90 +4,134 @@ module PgTagsOn
   module Repositories
     # Operatons for 'jsonb[]' column type
     class ArrayJsonbRepository < ArrayRepository
-      def create(tag, returning: nil)
-        with_normalized_tags(tag) do |n_tag|
-          super(n_tag, returning: returning)
-        end
+      ##
+      # 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
 
-      def update(tag, new_tag, returning: nil)
-        with_normalized_tags(tag, new_tag) do |n_tag, n_new_tag|
-          sql_set = <<-SQL.strip
-            #{column_name}[index] = #{column_name}[index] || $2
-          SQL
-
-          update_tag(n_tag,
-                     sql_set,
-                     bindings: [query_attribute(n_new_tag.to_json)],
-                     returning: returning)
-        end
+      ##
+      # Returns true if JSON object has nested attributes.
+      #
+      def nested?
+        key.present?
       end
 
-      def delete(tag, returning: nil)
-        with_normalized_tags(tag) do |n_tag|
-          sql_set = <<-SQL.strip
-            #{column_name} = #{column_name}[1:index-1] || #{column_name}[index+1:2147483647]
-          SQL
-
-          update_tag(n_tag, sql_set, returning: returning)
-        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)
+        tags = normalize_tags tag_or_tags
+
+        ArrayJsonb::Create.new.call repository: self,
+                                    relation: klass,
+                                    tags: tags,
+                                    returning: returning
       end
 
-      private
-
-      def with_normalized_tags(*tags, &block)
-        normalized_tags = Array.wrap(tags).flatten.map do |tag|
-          key? && Array.wrap(key).reverse.inject(tag) { |a, n| { n => a } } || tag
-        end
-
-        block.call(*normalized_tags)
+      ##
+      # 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
 
-      def array_to_recordset
-        return unnest unless key?
-
-        arel_jsonb_extract_path(unnest, *key_sql)
+      ##
+      # 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
+        relation = klass.where(column_name => PgTagsOn.query_class.any(tag_or_tags))
+
+        ArrayJsonb::Delete.new.call repository: self,
+                                    relation: relation,
+                                    tags: tags,
+                                    returning: returning
       end
 
-      def key
-        @key ||= options[:key]
-      end
+      def normalize_tags(tags)
+        return normalize_one_tag(tags) unless tags.is_a?(Array)
 
-      def key_sql
-        @key_sql ||= Array.wrap(key).map { |k| Arel.sql("'#{k}'") }
+        tags.map { |t| normalize_one_tag(t) }
       end
 
-      def key?
-        key.present?
+      def normalize_one_tag(tag)
+        return tag unless nested?
+        return { key => tag } unless key.is_a?(Array)
+
+        key.reverse.inject(tag) { |a, k| { k => a } }
       end
 
-      def taggings_with_ordinality_query(tag)
-        column = Arel::Table.new('t')['name']
-        value = bind_for(tag.to_json, nil)
+      ##
+      # @return [Arel::SelectManager]
+      #
+      def select_tags
+        return super unless nested?
 
-        arel_table
-          .project('id, name, index')
-          .from("#{table_name}, #{unnest_with_ordinality}")
-          .where(arel_infix_operation('@>', column, value))
+        klass
+          .select(arel_distinct(extract_tag_by_path).as(tag_alias))
+          .arel
       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)))
+      ##
+      # @return [Arel::SelectManager]
+      #
+      def select_taggings
+        return super unless nested?
 
-        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?
+        klass
+          .select(extract_tag_by_path.as(tag_alias),
+                  arel_table['id'].as('entity_id'))
+          .arel
+      end
 
-        bindings = [query_attribute(tag.to_json)] + Array.wrap(bindings)
-        result = klass.connection.exec_query(sql, 'SQL', bindings).rows
+      def tag_path_array
+        @tag_path_array ||= Array.wrap(key).map { |k| Arel.sql("'#{k}'") }
+      end
 
-        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,131 +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
 
-      def create(tag, returning: nil)
-        raise 'Tag cannot be blank' if tag.blank?
-
-        perform_update(klass,
-                       { column_name => arel_array_cat(arel_column, bind_for(Array.wrap(tag))) },
-                       returning: returning)
-      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)
+        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)
-        raise 'Tag cannot be blank' if tag.blank? || new_tag.blank?
-
-        rel = klass.where(column_name => PgTagsOn.query_class.one(tag))
-
-        perform_update(rel,
-                       { column_name => arel_array_replace(arel_column, bind_for(tag), bind_for(new_tag)) },
-                       returning: returning)
-      end
-
-      def delete(tag, returning: nil)
-        raise 'Tag cannot be blank' if tag.blank?
-
-        rel = klass.where(column_name => PgTagsOn.query_class.one(tag))
-
-        perform_update(rel, { column_name => arel_array_remove(arel_column, bind_for(tag)) }, returning: returning)
-      end
-
-      private
-
-      def perform_update(rel, updates, returning: nil)
-        updater = update_manager(rel, updates)
-        sql, binds = klass.connection.send :to_sql_and_binds, updater
-        sql += " RETURNING #{Array.wrap(returning).join(', ')}" if returning.present?
-
-        result = klass.connection.exec_query(sql, 'SQL', binds).rows
-
-        returning ? result : true
-      end
-
-      # Method copied from ActiveRecord as there is no way to inject sql into update manager.
-      def update_manager(rel, updates)
-        raise ArgumentError, 'Empty list of attributes to change' if updates.blank?
-
-        stmt = ::Arel::UpdateManager.new
-        stmt.table(arel_table)
-        stmt.key = klass.arel_attribute(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
-      end
-
-      def array_to_recordset
-        unnest
-      end
-
-      def taggings_query
+        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))
+
+        ArrayValue::Delete.new.call repository: self,
+                                    relation: relation,
+                                    tags: tag_or_tags,
+                                    returning: returning
+      end
+
+      def tag_alias
+        'name'
+      end
+
+      # protected
+
+      ##
+      # @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 ref
-        "#{table_name}.#{column_name}"
-      end
-
-      def unnest
-        arel_unnest(arel_column)
-      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

@@ -28,10 +28,6 @@ module PgTagsOn
         @table_name ||= klass.table_name
       end
 
-      def cast_type
-        @cast_type ||= klass.type_for_attribute(column_name)
-      end
-
       def arel_table
         klass.arel_table
       end
@@ -39,6 +35,60 @@ module PgTagsOn
       def arel_column
         arel_table[column_name]
       end
+
+      ##
+      # ActiveRecord Column instance
+      #
+      def ar_column
+        @ar_column ||= klass.columns_hash[column_name.to_s]
+      end
+
+      ##
+      # Column's Type instance
+      #
+      # @return [ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array]
+      #
+      def cast_type
+        @cast_type ||= klass.type_for_attribute(column_name)
+      end
+
+      ##
+      # 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?
+
+        type
+      end
+
+      # Method copied from ActiveRecord as there is no way to inject sql into update manager.
+      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(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/validations/validator.rb

@@ -4,7 +4,7 @@ module PgTagsOn
   # Validator for max. number of tags and max. tag length.
   #
   #   class Entity
-  #     pg_tags_on :tags, limit: 20, tag_length: 64
+  #     pg_tags_on :tags, limit: 20, length: 64
   #   end
   #
   class TagsValidator < ActiveModel::EachValidator
@@ -15,7 +15,7 @@ module PgTagsOn
 
     def validate_each(record, attribute, value)
       validate_limit(record, attribute, value)
-      validate_tag_length(record, attribute, value)
+      validate_length(record, attribute, value)
 
       record.errors.present?
     end
@@ -31,8 +31,8 @@ module PgTagsOn
       record.errors.add(attr, "size exceeded #{limit} tags") if value.size > limit.to_i
     end
 
-    def validate_tag_length(record, attr, value)
-      limit, key = klass.pg_tags_on_options_for(attr).values_at(:tag_length, :key)
+    def validate_length(record, attr, value)
+      limit, key = klass.pg_tags_on_options_for(attr).values_at(:length, :key)
       return true unless limit && value
 
       value.map! { |tag| tag.with_indifferent_access.dig(*key) } if key

data/lib/pg_tags_on/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgTagsOn
-  VERSION = '0.1.4'
+  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.1.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Catalin Marinescu
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-12 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.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        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
@@ -122,7 +128,7 @@ metadata:
   changelog_uri: https://github.com/cata-m/pg_tags_on/blob/master/CHANGELOG.md
   homepage_uri: http://github.com/cata-m/pg_tags_on
   source_code_uri: https://github.com/cata-m/pg_tags_on
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -130,15 +136,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Query and manage tags stored in a Postgresql column.
 test_files: []