pg_tags_on 0.1.1

data/spec/array_strings/tags_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ArrayStrings::Tags' 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 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
+
+  context 'cast integers to strings' do
+    before do
+      Entity.create(attr: 'int1', column => [1])
+    end
+
+    it 'find tags in numeric format' 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/config/database.yml

@@ -0,0 +1,6 @@
+adapter: postgresql
+host: <%= ENV.fetch("PG_HOST") { "localhost" } %>
+port: <%= ENV.fetch("PG_PORT") { 5432 } %>
+username: <%= ENV.fetch("PG_USER") { raise "PG_USER env. not set" } %>
+password: <%= ENV.fetch("PG_PSWD") { raise "PG_PSWD env. not set" } %>
+database: <%= ENV.fetch("PG_TAGS_ON_DB") { raise "PG_TAGS_ON_DB env. not set" } %>

data/spec/configuration_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+RSpec.describe 'configuration' do
+  before do
+    Entity.pg_tags_on_reset
+  end
+
+  it 'should set query class' do
+    PgTagsOn.configure do |c|
+      c.query_class = 'Tagz'
+    end
+    Entity.pg_tags_on :tags_int
+
+    expect(Kernel.const_defined?('Tagz')).to be_truthy
+  end
+
+  it 'should set columns for multiple models' do
+    class Entity1 < ActiveRecord::Base
+      self.table_name = 'entities'
+      pg_tags_on :tags_int
+    end
+
+    class Entity2 < ActiveRecord::Base
+      self.table_name = 'entities'
+      pg_tags_on :tags_str
+    end
+
+    expect(Entity1.pg_tags_on_settings).to be_eql('tags_int' => {})
+    expect(Entity2.pg_tags_on_settings).to be_eql('tags_str' => {})
+  end
+
+  it 'should set multiple columns for the same model' do
+    Entity.pg_tags_on :tags_int
+    Entity.pg_tags_on :tags_str
+
+    expect(Entity.pg_tags_on_settings).to be_eql('tags_int' => {}, 'tags_str' => {})
+  end
+
+  it 'should raise error if column does not exists' do
+    expect { Entity.pg_tags_on(:dummy) }.to raise_error(PgTagsOn::ColumnNotFoundError)
+  end
+
+  it 'should create named scopes' do
+    Entity.pg_tags_on :tags_int
+
+    expect(Entity).to respond_to(:tags_int)
+  end
+end

data/spec/helpers/database_helpers.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module DatabaseHelpers
+  def establish_connection
+    ActiveRecord::Base.establish_connection(config)
+  end
+
+  def config
+    @config ||= begin
+      file = File.expand_path('../config/database.yml', File.dirname(__FILE__))
+      YAML.safe_load(ERB.new(File.read(file)).result)
+    end
+  end
+
+  def load_schema
+    @connection = ActiveRecord::Base.connection
+    @connection.drop_table :entities
+    @connection.transaction do
+      @connection.create_table :entities, force: true do |t|
+        t.integer :tags_int, array: true
+        t.string  :tags_str, array: true
+        t.text    :tags_text, array: true
+        t.jsonb   :tags_jsonb, array: true
+        t.string  :attr
+      end
+      @connection.add_index :entities, :tags_str, using: 'gin'
+    end
+  end
+
+  def truncate
+    ActiveRecord::Base.connection.truncate(Entity.table_name)
+  end
+
+  def encode_json(json)
+    case json
+    when String
+      ActiveSupport::JSON.encode(json)
+    when Hash
+      ActiveSupport::JSON.encode(json.to_json)
+    when Array
+      "'{" + json.map { |item| encode_json(item) }.join(',') + "}'"
+    end
+  end
+
+  module_function :config, :establish_connection, :load_schema, :truncate
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+WITH_COVERAGE = ENV['COVERAGE']
+
+if WITH_COVERAGE
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter %r{/benchmark/}
+  end
+end
+
+require 'pg'
+require 'active_record'
+require 'bundler/setup'
+require 'pg_tags_on'
+require 'helpers/database_helpers'
+require 'support/factory'
+require 'pry'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.include DatabaseHelpers
+
+  config.before(:all) do
+    DatabaseHelpers.establish_connection
+    DatabaseHelpers.load_schema
+  end
+end
+
+Entity = Class.new(::ActiveRecord::Base)

data/spec/support/factory.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Factory
+  def self.array_strings
+    Entity.insert_all([
+                        { tags_str: %w[a b c], attr: 'test1' },
+                        { tags_str: %w[b c],   attr: 'test2' },
+                        { tags_str: ['d'],     attr: 'test3' }
+                      ])
+  end
+
+  def self.array_integers
+    Entity.insert_all([
+                        { tags_int: [1, 2, 3], attr: 'test1' },
+                        { tags_int: [2, 3],    attr: 'test2' },
+                        { tags_int: [4],       attr: 'test3' }
+                      ])
+  end
+
+  def self.array_jsonb
+    Entity.insert_all([
+                        { tags_jsonb: [{ name: 'a' },
+                                       { name: 'b' },
+                                       { name: 'c' }],
+                          attr: 'test1' },
+                        { tags_jsonb: [{ name: 'b' },
+                                       { name: 'c' }],
+                          attr: 'test2' },
+                        { tags_jsonb: [{ name: 'd' }],
+                          attr: 'test3' }
+                      ])
+  end
+
+  def self.array_jsonb_with_attrs
+    Entity.insert_all([
+                        { tags_jsonb: [{ name: 'a', meta: 'a' },
+                                       { name: 'b', meta: 'b' },
+                                       { name: 'c', meta: 'c' }],
+                          attr: 'test1' },
+                        { tags_jsonb: [{ name: 'b', meta: 'b' },
+                                       { name: 'c', meta: 'c' }],
+                          attr: 'test2' },
+                        { tags_jsonb: [{ name: 'd', meta: 'd' }],
+                          attr: 'test3' }
+                      ])
+  end
+end

data/spec/tags_query_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+RSpec.describe 'TagsQuery' do
+  it 'accept String arguments' do
+    query = PgTagsOn::TagsQuery.all('a')
+
+    expect(query.value).to be_eql('a')
+    expect(query.predicate).to be_eql('all')
+  end
+
+  it 'accept Integer arguments' do
+    query = PgTagsOn::TagsQuery.all(1)
+
+    expect(query.value).to be_eql(1)
+    expect(query.predicate).to be_eql('all')
+  end
+
+  it 'accept Array arguments' do
+    query = PgTagsOn::TagsQuery.all(%w[a b c])
+
+    expect(query.value).to be_eql(%w[a b c])
+    expect(query.predicate).to be_eql('all')
+  end
+
+  it 'accept arguments list' do
+    query = PgTagsOn::TagsQuery.all('a', 'b', 'c')
+
+    expect(query.value).to be_eql(%w[a b c])
+    expect(query.predicate).to be_eql('all')
+  end
+end

data/spec/validator_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Validator' do
+  before(:all) do
+    Entity.pg_tags_on :tags_str, limit: 2, tag_length: 3
+    Entity.pg_tags_on :tags_jsonb, key: :name, limit: 2, tag_length: 3
+  end
+
+  context 'string tags' do
+    it 'add errors if number of tags exceeds limit' do
+      entity = Entity.new(tags_str: %w[a b c])
+      entity.valid?
+
+      expect(entity.errors.full_messages.first).to include('size exceeded')
+    end
+
+    it 'add errors if tag length exceeds limit' do
+      entity = Entity.new(tags_str: %w[a x123])
+      entity.valid?
+
+      expect(entity.errors.full_messages.first).to include('length exceeded')
+    end
+  end
+
+  context 'jsonb tags' do
+    it 'add errors if number of tags exceeds limit' do
+      entity = Entity.new(tags_jsonb: [{ name: 'a' }, { name: 'b' }, { name: 'c' }])
+      entity.valid?
+
+      expect(entity.errors.full_messages.first).to include('size exceeded')
+    end
+
+    it 'add errors if tag length exceeds limit' do
+      entity = Entity.new(tags_jsonb: [{ name: 'x123' }])
+      entity.valid?
+
+      expect(entity.errors.full_messages.first).to include('length exceeded')
+    end
+  end
+end

data/tasks/benchmark.rake

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require './spec/helpers/database_helpers'
+require 'lib/pg_tags_on'
+require 'pry'
+
+namespace :pg_tags_on do
+  task :benchmark do
+    DatabaseHelpers.establish_connection
+    DatabaseHelpers.load_schema
+
+    Entity = Class.new(::ActiveRecord::Base)
+    Entity.pg_tags_on :tags_int
+    Entity.pg_tags_on :tags_str
+    Entity.pg_tags_on :tags_jsonb, key: :name
+
+    puts 'How many records to generate? (default 10_000)'
+    records = STDIN.gets.chomp.to_i
+    puts 'Minimum tags per record (default 1):'
+    min_tags = STDIN.gets.chomp.to_i
+    puts 'Maximum tags per record (default 10):'
+    max_tags = STDIN.gets.chomp.to_i
+
+    records = 10_000 if records.zero?
+    min_tags = 1 if min_tags.zero?
+    max_tags = 10 if max_tags.zero?
+
+    data = []
+    str_tags = Array.new(100) { Faker::Name.first_name }
+
+    puts "Generating #{records} records..."
+    records.times do
+      tags_count = rand(min_tags..max_tags)
+
+      data << {
+        tags_int: Array.new(tags_count) { rand(1..100) },
+        tags_str: str_tags.sample(tags_count),
+        tags_jsonb: Array.new(tags_count) { { name: str_tags.sample } }
+      }
+
+      if data.size == 5_000
+        Entity.insert_all data
+        data = []
+      end
+    end
+
+    Entity.insert_all(data) if data.present?
+    puts 'Done'
+
+    puts "\n\n* character varying[]\n\n"
+    PgTagsOn::Benchmark.new(Entity, :tags_str).call
+    puts "\n\n* integer[]\n\n"
+    PgTagsOn::Benchmark.new(Entity, :tags_int).call
+    puts "\n\n* jsonb[]\n\n"
+    PgTagsOn::Benchmark.new(Entity, :tags_jsonb).call
+  end
+end

metadata

@@ -0,0 +1,260 @@
+--- !ruby/object:Gem::Specification
+name: pg_tags_on
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Catalin Marinescu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.80'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.80'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+description: A gem that makes working with tags stored in a Postgresql column easy.Support
+  for array of string, integer and jsonb values.
+email:
+- catalin.marinescu@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/pg_tags_on.rb
+- lib/pg_tags_on/active_record/arel.rb
+- lib/pg_tags_on/active_record/base.rb
+- lib/pg_tags_on/benchmark/benchmark.rb
+- lib/pg_tags_on/predicate_handler.rb
+- lib/pg_tags_on/predicate_handler/array_integer_handler.rb
+- lib/pg_tags_on/predicate_handler/array_jsonb_handler.rb
+- lib/pg_tags_on/predicate_handler/array_jsonb_with_attrs_handler.rb
+- 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_repository.rb
+- lib/pg_tags_on/repositories/array_repository.rb
+- lib/pg_tags_on/repositories/base_repository.rb
+- lib/pg_tags_on/repository.rb
+- lib/pg_tags_on/tag.rb
+- lib/pg_tags_on/tags_query.rb
+- lib/pg_tags_on/validations/validator.rb
+- lib/pg_tags_on/version.rb
+- pg_tags_on.gemspec
+- spec/array_integers/records_spec.rb
+- spec/array_integers/tag_ops_spec.rb
+- spec/array_integers/taggings_spec.rb
+- spec/array_integers/tags_spec.rb
+- spec/array_jsonb/records_spec.rb
+- spec/array_jsonb/tag_ops_spec.rb
+- spec/array_jsonb/taggings_spec.rb
+- spec/array_jsonb/tags_spec.rb
+- spec/array_strings/records_spec.rb
+- spec/array_strings/tag_ops_spec.rb
+- spec/array_strings/taggings_spec.rb
+- spec/array_strings/tags_spec.rb
+- spec/config/database.yml
+- spec/configuration_spec.rb
+- spec/helpers/database_helpers.rb
+- spec/spec_helper.rb
+- spec/support/factory.rb
+- spec/tags_query_spec.rb
+- spec/validator_spec.rb
+- tasks/benchmark.rake
+homepage: http://github.com/cata-m/pg_tags_on
+licenses:
+- MIT
+metadata:
+  homepage_uri: http://github.com/cata-m/pg_tags_on
+  source_code_uri: http://github.com/cata-m/pg_tags_on
+  changelog_uri: http://github.com/cata-m/pg_tags_on/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Manage tags stored in Postgresql column.
+test_files:
+- spec/array_integers/records_spec.rb
+- spec/array_integers/tag_ops_spec.rb
+- spec/array_integers/taggings_spec.rb
+- spec/array_integers/tags_spec.rb
+- spec/array_jsonb/records_spec.rb
+- spec/array_jsonb/tag_ops_spec.rb
+- spec/array_jsonb/taggings_spec.rb
+- spec/array_jsonb/tags_spec.rb
+- spec/array_strings/records_spec.rb
+- spec/array_strings/tag_ops_spec.rb
+- spec/array_strings/taggings_spec.rb
+- spec/array_strings/tags_spec.rb
+- spec/config/database.yml
+- spec/configuration_spec.rb
+- spec/helpers/database_helpers.rb
+- spec/spec_helper.rb
+- spec/support/factory.rb
+- spec/tags_query_spec.rb
+- spec/validator_spec.rb