pg_tags_on 0.1.1

data/pg_tags_on.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pg_tags_on/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'pg_tags_on'
+  spec.version       = PgTagsOn::VERSION
+  spec.authors       = ['Catalin Marinescu']
+  spec.email         = ['catalin.marinescu@gmail.com']
+  spec.summary       = 'Manage tags stored in Postgresql column.'
+  spec.description   = 'A gem that makes working with tags stored in a Postgresql column easy.Support for array of string, integer and jsonb values.'
+  spec.homepage      = 'http://github.com/cata-m/pg_tags_on'
+  spec.license       = 'MIT'
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'http://github.com/cata-m/pg_tags_on'
+  spec.metadata['changelog_uri'] = 'http://github.com/cata-m/pg_tags_on/blob/master/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord', '~> 6.0'
+  spec.add_dependency 'activesupport', '~> 6.0'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'faker', '~> 2.10'
+  spec.add_development_dependency 'pg', '~> 1.2'
+  spec.add_development_dependency 'pry', '~> 0.12'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.9'
+  spec.add_development_dependency 'rubocop', '~> 0.80'
+  spec.add_development_dependency 'simplecov', '~> 0.18'
+end

data/spec/array_integers/records_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayIntegers::Records' do
+  before(:all) do
+    @column = :tags_int # defined as instance var as it is used in before_all callback
+    Entity.pg_tags_on @column
+    truncate && Factory.array_integers
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  it 'find records by tag' do
+    rel = Entity.where(column => Tags.one(2))
+
+    expect(rel.to_sql).to include(%(#{ref} @> '{2}'))
+    expect(rel.count).to be_eql(2)
+  end
+
+  it 'find records with exact same tags' do
+    rel = Entity.where(column => Tags.eq(%w[3 2]))
+
+    expect(rel.count).to be_eql(1)
+  end
+
+  it 'find records with all tags' do
+    rel = Entity.where(column => Tags.all([1, 2, 3]))
+
+    expect(rel.to_sql).to include(%(#{ref} @> '{1,2,3}'))
+    expect(rel.count).to be_eql(1)
+  end
+
+  it 'find records with any tag' do
+    rel = Entity.where(column => Tags.any([1, 2, 3]))
+
+    expect(rel.to_sql).to include(%(#{ref} && '{1,2,3}'))
+    expect(rel.count).to be_eql(2)
+  end
+
+  it 'find records with tags included in tag list' do
+    rel = Entity.where(column => Tags.in([1, 2, 3]))
+
+    expect(rel.to_sql).to include(%(#{ref} <@ '{1,2,3}'))
+    expect(rel.count).to be_eql(2)
+  end
+end

data/spec/array_integers/tag_ops_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayIntegers::TagOps' do
+  before(:all) do
+    @column = :tags_int # defined as instance var as it is used in before_all callback
+    Entity.pg_tags_on @column
+  end
+
+  before do
+    truncate && Factory.array_integers
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  context 'create' do
+    it 'create tag' do
+      relation.create(5)
+
+      Entity.all.each do |entity|
+        expect(entity.send(column)).to include(5)
+      end
+    end
+
+    it 'create tag for filtered records' do
+      Entity.where(attr: 'test2').send(column).create(6)
+
+      expect(Entity.find_by_attr('test1').send(column)).not_to include(6)
+      expect(Entity.find_by_attr('test2').send(column)).to include(6)
+    end
+  end
+
+  context 'update' do
+    it 'update tag' do
+      relation.update(2, 22)
+
+      count = Entity.where(column => Tags.all(22)).count
+      expect(count).to be_eql(2)
+    end
+
+    it 'update tag for filtered records' do
+      Entity.where(attr: 'test2').send(column).update(3, 33)
+
+      count = Entity.where(column => Tags.all(33)).count
+      expect(count).to be_eql(1)
+    end
+  end
+
+  context 'delete' do
+    it 'delete tag' do
+      relation.delete(2)
+
+      tags = relation.all.pluck(:name)
+      expect(tags).not_to include(2)
+    end
+
+    it 'delete tag for filtered records' do
+      Entity.where(attr: 'test2').send(column).delete(3)
+
+      expect(Entity.find_by_attr('test1').send(column)).to include(3)
+      expect(Entity.find_by_attr('test2').send(column)).not_to include(3)
+    end
+  end
+end

data/spec/array_integers/taggings_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayIntegers::Taggings' do
+  before(:all) do
+    @column = :tags_int # defined as instance var as it is used in before_all callback
+    Entity.pg_tags_on @column
+    truncate && Factory.array_integers
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  it 'find all taggings' do
+    taggings = relation.taggings.order('name')
+
+    expect(taggings.size).to be_eql(6)
+    expect(taggings.map(&:name)).to be_eql([1, 2, 2, 3, 3, 4])
+  end
+
+  it 'find all taggings for filtered records' do
+    taggings = Entity.where(attr: 'test2').send(column).taggings.order('name')
+
+    expect(taggings.size).to be_eql(2)
+    expect(taggings.map(&:name)).to be_eql([2, 3])
+  end
+end

data/spec/array_integers/tags_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayIntegers::Tags' do
+  before(:all) do
+    @column = :tags_int # defined as instance var as it is used in before_all callback
+    Entity.pg_tags_on @column
+    truncate && Factory.array_integers
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  it 'find all tags' do
+    tags = relation.all.order('name')
+    expect(tags.size).to be_eql(4)
+    expect(tags.map(&:name)).to be_eql([1, 2, 3, 4])
+  end
+
+  it 'find all tags for filtered records' do
+    tags = Entity.where(attr: 'test2').send(column).all
+
+    expect(tags.size).to be_eql(2)
+    expect(tags.map(&:name)).to be_eql([2, 3])
+  end
+
+  it 'find all tags with counts' do
+    tag = relation.all_with_counts.first
+
+    expect(tag.count).to be_eql(1)
+  end
+
+  it 'count tags' do
+    expect(relation.count).to be_eql(4)
+  end
+
+  it 'count tags for filtered records' do
+    expect(Entity.where(attr: 'test2').send(column).count).to be_eql(2)
+  end
+
+  context 'cast strings to integers' do
+    before do
+      Entity.create(attr: 'int1', column => %w[1])
+    end
+
+    it 'find tags' do
+      tags = relation.all.where(name: '1')
+
+      expect(tags.size).to be_eql(1)
+      expect(tags.map(&:name)).to be_eql([1])
+    end
+  end
+end

data/spec/array_jsonb/records_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayJsonb::Records' do
+  before(:all) do
+    @column = :tags_jsonb # defined as instance var as it is used in before_all callback
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  context 'objects have only one key' do
+    before(:all) do
+      Entity.pg_tags_on @column, key: :name
+      truncate && Factory.array_jsonb
+    end
+
+    it 'find records by tag' do
+      rel = Entity.where(column => Tags.one('b'))
+      expected_sql = %(#{ref} @> #{encode_json([{ name: 'b' }])})
+
+      expect(rel.to_sql).to include(expected_sql)
+      expect(rel.count).to be_eql(2)
+    end
+
+    it 'find records with exact same tags' do
+      rel = Entity.where(column => Tags.eq(%w[b c]))
+
+      expect(rel.count).to be_eql(1)
+    end
+
+    it 'find records with all tags' do
+      rel = Entity.where(column => Tags.all(%w[a b c]))
+      expected_sql = %(#{ref} @> #{encode_json([{ name: 'a' }, { name: 'b' }, { name: 'c' }])})
+
+      expect(rel.to_sql).to include(expected_sql)
+      expect(rel.count).to be_eql(1)
+    end
+
+    it 'find records with any tags' do
+      rel = Entity.where(column => Tags.any(%w[a b c]))
+      expected_sql = %(#{ref} && #{encode_json([{ name: 'a' }, { name: 'b' }, { name: 'c' }])})
+
+      expect(rel.to_sql).to include(expected_sql)
+      expect(rel.count).to be_eql(2)
+    end
+
+    it 'find records with tags included in tag list' do
+      rel = Entity.where(column => Tags.in(%w[a b c]))
+      expected_sql = %(#{ref} <@ #{encode_json([{ name: 'a' }, { name: 'b' }, { name: 'c' }])})
+
+      expect(rel.to_sql).to include(expected_sql)
+      expect(rel.count).to be_eql(2)
+    end
+  end
+
+  context 'objects have multiple keys' do
+    before(:all) do
+      Entity.pg_tags_on @column, key: :name, has_attributes: true
+      truncate && Factory.array_jsonb_with_attrs
+    end
+
+    it 'find records by tag' do
+      rel = Entity.where(column => Tags.one('b'))
+      expect(rel.count).to be_eql(2)
+    end
+
+    it 'find records with exact same tags' do
+      rel = Entity.where(column => Tags.eq(%w[b c]))
+
+      expect(rel.count).to be_eql(1)
+    end
+
+    it 'find records with all tags' do
+      rel = Entity.where(column => Tags.all(%w[a b c]))
+      expect(rel.count).to be_eql(1)
+    end
+
+    it 'find records with any tags' do
+      rel = Entity.where(column => Tags.any(%w[a b c]))
+      expect(rel.count).to be_eql(2)
+    end
+
+    it 'find records with tags included in tag list' do
+      rel = Entity.where(column => Tags.in(%w[a b c]))
+      expect(rel.count).to be_eql(2)
+    end
+  end
+end

data/spec/array_jsonb/tag_ops_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayJsonb::TagOps' do
+  before(:all) do
+    @column = :tags_jsonb
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  context 'objects has only one key' do
+    before(:all) do
+      Entity.pg_tags_on @column, key: :name
+      truncate && Factory.array_jsonb
+    end
+
+    context 'create' do
+      it 'create tag' do
+        relation.create('new-tag1')
+
+        Entity.all.each do |entity|
+          expect(entity.send(column)).to include({ 'name' => 'new-tag1' })
+        end
+      end
+
+      it 'create tag for filtered records' do
+        Entity.where(attr: 'test2').send(column).create('new-tag2')
+
+        expect(Entity.find_by_attr('test1').send(column)).not_to include({ 'name' => 'new-tag2' })
+        expect(Entity.find_by_attr('test2').send(column)).to include({ 'name' => 'new-tag2' })
+      end
+    end
+
+    context 'update' do
+      it 'update tag' do
+        relation.update('b', 'updated-b')
+
+        count = Entity.where(column => Tags.all('updated-b')).count
+        expect(count).to be_eql(2)
+      end
+
+      it 'update tag for filtered records' do
+        Entity.where(attr: 'test2').send(column).update('c', 'updated-c')
+
+        count = Entity.where(column => Tags.all('updated-c')).count
+        expect(count).to be_eql(1)
+      end
+    end
+
+    context 'delete' do
+      it 'delete tag' do
+        relation.delete('b')
+
+        tags = relation.all.pluck(:name)
+        expect(tags).not_to include('b')
+      end
+
+      it 'delete tag for filtered records' do
+        Entity.where(attr: 'test2').send(column).delete('c')
+
+        expect(Entity.where(attr: 'test1').send(column).all.pluck(:name)).to include('c')
+        expect(Entity.where(attr: 'test2').send(column).all.pluck(:name)).not_to include('c')
+      end
+    end
+  end
+
+  context 'objects have multiple keys' do
+    before(:all) do
+      Entity.pg_tags_on @column, key: :name, has_attributes: true
+    end
+
+    before(:each) do
+      truncate && Factory.array_jsonb_with_attrs
+    end
+
+    context 'update' do
+      it 'update tag' do
+        relation.update('b', 'updated-b')
+
+        rel = Entity.where(column => Tags.all('updated-b'))
+        expect(rel.count).to be_eql(2)
+        rel.all.each do |record|
+          expect(record.tags_jsonb).to include({ 'meta' => 'b', 'name' => 'updated-b' })
+        end
+      end
+
+      it 'update tag for filtered records' do
+        Entity.where(attr: 'test2').send(column).update('c', 'updated-c')
+
+        rel = Entity.where(column => Tags.all('updated-c'))
+        expect(rel.count).to be_eql(1)
+        rel.all.each do |record|
+          expect(record.tags_jsonb).to include({ 'meta' => 'c', 'name' => 'updated-c' })
+        end
+      end
+    end
+
+    context 'delete' do
+      it 'delete tag' do
+        relation.delete('b')
+
+        tags = relation.all.pluck(:name)
+        expect(tags).not_to include('b')
+      end
+
+      it 'delete tag for filtered records' do
+        Entity.where(attr: 'test2').send(column).delete('c')
+
+        expect(Entity.where(attr: 'test1').send(column).all.pluck(:name)).to include('c')
+        expect(Entity.where(attr: 'test2').send(column).all.pluck(:name)).not_to include('c')
+      end
+    end
+  end
+end

data/spec/array_jsonb/taggings_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayJsonb::Taggings' do
+  before(:all) do
+    @column = :tags_jsonb
+    Entity.pg_tags_on @column, key: :name
+    truncate && Factory.array_jsonb
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  it 'find all taggings' do
+    taggings = relation.taggings.order('name')
+
+    expect(taggings.size).to be_eql(6)
+    expect(taggings.map(&:name)).to be_eql(%w[a b b c c d])
+  end
+
+  it 'find all taggings for filtered records' do
+    taggings = Entity.where(attr: 'test2').send(column).taggings.order('name')
+
+    expect(taggings.size).to be_eql(2)
+    expect(taggings.map(&:name)).to be_eql(%w[b c])
+  end
+end

data/spec/array_jsonb/tags_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayJsonb::Tags' do
+  before(:all) do
+    @column = :tags_jsonb
+    Entity.pg_tags_on @column, key: :name
+    truncate && Factory.array_jsonb
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  it 'find all tags' do
+    tags = relation.all.order('name')
+
+    expect(tags.size).to be_eql(4)
+    expect(tags.map(&:name)).to be_eql(%w[a b c d])
+  end
+
+  it 'find all tags for filtered records' do
+    tags = Entity.where(attr: 'test2').send(column).all
+
+    expect(tags.size).to be_eql(2)
+    expect(tags.map(&:name)).to be_eql(%w[b c])
+  end
+
+  it 'find all tags with counts' do
+    tag = relation.all_with_counts.first
+
+    expect(tag.count).to be_eql(1)
+  end
+
+  it 'count tags' do
+    expect(relation.count).to be_eql(4)
+  end
+
+  it 'count tags for filtered records' do
+    expect(Entity.where(attr: 'test2').send(column).count).to be_eql(2)
+  end
+end

data/spec/array_strings/records_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayStrings::Records' do
+  before(:all) do
+    @column = :tags_str # defined as instance var as it is used in before_all callback
+    Entity.pg_tags_on @column
+    truncate && Factory.array_strings
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  it 'find records by tag' do
+    rel = Entity.where(column => Tags.one('b'))
+
+    expect(rel.to_sql).to include(%(#{ref} @> '{b}'))
+    expect(rel.count).to be_eql(2)
+  end
+
+  it 'find records without tag' do
+    rel = Entity.where.not(column => Tags.one('b'))
+
+    expect(rel.to_sql).to include(%(NOT (#{ref} @> '{b}')))
+    expect(rel.count).to be_eql(1)
+  end
+
+  it 'find records with exact same tags' do
+    rel = Entity.where(column => Tags.eq(%w[c b]))
+
+    expect(rel.count).to be_eql(1)
+  end
+
+  it 'find records with all tags' do
+    rel = Entity.where(column => Tags.all(%w[a b c]))
+
+    expect(rel.to_sql).to include(%(#{ref} @> '{a,b,c}'))
+    expect(rel.count).to be_eql(1)
+  end
+
+  it 'find records without tags' do
+    rel = Entity.where.not(column => Tags.all(%w[a b]))
+
+    expect(rel.to_sql).to include(%(NOT (#{ref} @> '{a,b}')))
+    expect(rel.count).to be_eql(2)
+  end
+
+  it 'find records with any tag' do
+    rel = Entity.where(column => Tags.any(%w[a b c]))
+
+    expect(rel.to_sql).to include(%(#{ref} && '{a,b,c}'))
+    expect(rel.count).to be_eql(2)
+  end
+
+  it 'find records with tags included in tag list' do
+    rel = Entity.where(column => Tags.in(%w[a b c]))
+
+    expect(rel.to_sql).to include(%(#{ref} <@ '{a,b,c}'))
+    expect(rel.count).to be_eql(2)
+  end
+end

data/spec/array_strings/tag_ops_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayStrings::TagOps' do
+  before(:all) do
+    @column = :tags_str # defined as instance var as it is used in before_all callback
+    Entity.pg_tags_on @column
+  end
+
+  before do
+    truncate && Factory.array_strings
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  context 'create' do
+    it 'create tag' do
+      relation.create('new-tag1')
+
+      Entity.all.each do |entity|
+        expect(entity.send(column)).to include('new-tag1')
+      end
+    end
+
+    it 'create tag for filtered records' do
+      Entity.where(attr: 'test2').send(column).create('new-tag2')
+
+      expect(Entity.find_by_attr('test1').send(column)).not_to include('new-tag2')
+      expect(Entity.find_by_attr('test2').send(column)).to include('new-tag2')
+    end
+  end
+
+  context 'update' do
+    it 'update tag' do
+      relation.update('b', 'updated-b')
+
+      count = Entity.where(column => Tags.all('updated-b')).count
+      expect(count).to be_eql(2)
+    end
+
+    it 'update tag for filtered records' do
+      Entity.where(attr: 'test2').send(column).update('c', 'updated-c')
+
+      count = Entity.where(column => Tags.all('updated-c')).count
+      expect(count).to be_eql(1)
+    end
+  end
+
+  context 'delete' do
+    it 'delete tag' do
+      relation.delete('b')
+
+      tags = relation.all.pluck(:name)
+      expect(tags).not_to include('b')
+    end
+
+    it 'delete tag for filtered records' do
+      Entity.where(attr: 'test2').send(column).delete('c')
+
+      expect(Entity.find_by_attr('test1').send(column)).to include('c')
+      expect(Entity.find_by_attr('test2').send(column)).not_to include('c')
+    end
+  end
+end

data/spec/array_strings/taggings_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayStrings::Taggings' do
+  before(:all) do
+    @column = :tags_str # defined as instance var as it is used in before_all callback
+    Entity.pg_tags_on @column
+    truncate && Factory.array_strings
+  end
+
+  let(:column) { @column }
+  let(:ref) { %("#{Entity.table_name}"."#{column}") }
+  let(:relation) { Entity.send(column) }
+
+  it 'find all taggings' do
+    taggings = relation.taggings.order('name')
+
+    expect(taggings.size).to be_eql(6)
+    expect(taggings.map(&:name)).to be_eql(%w[a b b c c d])
+  end
+
+  it 'find all taggings for filtered records' do
+    taggings = Entity.where(attr: 'test2').send(column).taggings.order('name')
+
+    expect(taggings.size).to be_eql(2)
+    expect(taggings.map(&:name)).to be_eql(%w[b c])
+  end
+end