pgrel 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62a79ba274061f7a36972f8817c5ee5b61242af5d92d8d7ca77f776cfb1ee802
-  data.tar.gz: f8c8da31f5ce40f8c1e3400dd154aac9f1a8309768586d7f1049e733a1e5650b
+  metadata.gz: 686f59a1c868b3ee3268ab06137c35dcd2f8e9fed9136bbbec2a27622401d301
+  data.tar.gz: a381b46c2a07d0193a5764d099e25f731ac90c17f2f9bef11ca600ac08f10c1c
 SHA512:
-  metadata.gz: 34d502c9098aa129c3a64acd5d48d722e31d38b3ececf9d930d9629da226e73aa9077643882341e6a01a9cf1ae95158348347a3b98f2ee92319b553aede53c8e
-  data.tar.gz: e7b38cbd1eaa94fffbecaa093caa87ebf4ae73aa128139db1efd8d022047d6775dbbf4452cb2e5ff94ccc8fc6dbc1cf0d93b29ee762230b8c2aafc9f6f450549
+  metadata.gz: 92b7300c636eb9f985a7a9b5b9467d1480b92ca38997d73cce0105915f1f2d50f7df5724b5b9e0c5c36e32dd5ea3999803145caa0b51a0561ba40d17603606f8
+  data.tar.gz: 7b7153c935e88f6084463e58639e9c297fb44dcc1d8c538a8e17e5cb3f6f836837ca7a8dbefd479dbf22ac5f4fd8e9a3400d47985a9c35b30f65238821cd0bc8

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 0.3.1 (2020-12-18)
+
+- Update internal query building for Rails 6.1 compatibility. ([@zokioki][])
+
 ## 0.3.0 (2019-28-01)
 
 - Rename `#value` method to `#overlap_values`.

data/{MIT-LICENSE → LICENSE.txt}

@@ -1,4 +1,4 @@
-Copyright 2015 palkan
+Copyright 2015-2020 palkan
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,4 +1,5 @@
-[![Gem Version](https://badge.fury.io/rb/pgrel.svg)](https://rubygems.org/gems/pgrel) [![Build Status](https://travis-ci.org/palkan/pgrel.svg?branch=master)](https://travis-ci.org/palkan/pgrel)
+[![Gem Version](https://badge.fury.io/rb/pgrel.svg)](https://rubygems.org/gems/pgrel)
+![Build](https://github.com/palkan/pgrel/workflows/Build/badge.svg)
 
 ## Pgrel
 
@@ -11,14 +12,14 @@ Compatible with **Rails** >= 4.2 (including **Rails 6**).
 In your Gemfile:
 
 ```ruby
-gem "pgrel", "~> 0.2"
+gem "pgrel", "~> 0.3"
 ```
 
 ### HStore
 
 #### Querying
 
-The functionality is based on ActiveRecord `WhereChain`. 
+The functionality is based on ActiveRecord `WhereChain`.
 To start querying call `where(:store_name)` and chain it with store-specific call (see below).
 
 Query by key value:
@@ -103,7 +104,7 @@ Hstore.update_store(:tags).delete_pairs(a: 1, b: 2)
 
 All queries and updates for Hstore also available for JSONB.
 
-**NOTE**. Querying by array value always resolves to `(... or ...)` statement. 
+**NOTE**. Querying by array value always resolves to `(... or ...)` statement.
 Thus it's impossible to query json array value, e.g.:
 
 ```ruby

data/lib/pgrel.rb

@@ -1,2 +1,4 @@
-require 'pgrel/version'
-require 'pgrel/active_record'
+# frozen_string_literal: true
+
+require "pgrel/version"
+require "pgrel/active_record"

data/lib/pgrel/active_record.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'active_record'
-require 'pgrel/active_record/relation'
-require 'pgrel/active_record/store/flexible_store'
-require 'pgrel/active_record/store/flexible_hstore'
-require 'pgrel/active_record/store/flexible_jsonb'
-require 'pgrel/active_record/querying'
-require 'pgrel/active_record/query_methods'
+require "active_record"
+require "pgrel/active_record/relation"
+require "pgrel/active_record/store/flexible_store"
+require "pgrel/active_record/store/flexible_hstore"
+require "pgrel/active_record/store/flexible_jsonb"
+require "pgrel/active_record/querying"
+require "pgrel/active_record/query_methods"

data/lib/pgrel/active_record/query_methods.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'active_record/relation'
-require 'pgrel/active_record/store_chain'
-require 'pgrel/active_record/store_chain/array_chain'
-require 'pgrel/active_record/store_chain/hstore_chain'
-require 'pgrel/active_record/store_chain/jsonb_chain'
+require "active_record/relation"
+require "pgrel/active_record/store_chain"
+require "pgrel/active_record/store_chain/array_chain"
+require "pgrel/active_record/store_chain/hstore_chain"
+require "pgrel/active_record/store_chain/jsonb_chain"
 
 module ActiveRecord
   module QueryMethods

data/lib/pgrel/active_record/querying.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Querying
     delegate :update_store, to: :all

data/lib/pgrel/active_record/relation.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     def update_store(store_name)
       raise ArgumentError, "Empty store name to update" if store_name.blank?
       type = type_for_attribute(store_name.to_s).type
-      raise TypeConflictError, store_type_error_msg(type) if %i(hstore jsonb).exclude?(type)
+      raise TypeConflictError, store_type_error_msg(type) if %i[hstore jsonb].exclude?(type)
       klass = "ActiveRecord::Store::Flexible#{type.capitalize}".constantize
       klass.new(self, store_name)
     end

data/lib/pgrel/active_record/store/flexible_hstore.rb

@@ -10,13 +10,13 @@ module ActiveRecord
 
       def merge(pairs)
         relation.update_all(["#{store_name} = hstore(#{store_name}) || hstore(ARRAY[:keys])",
-                            keys: pairs.to_a.flatten.map(&:to_s)])
+          keys: pairs.to_a.flatten.map(&:to_s)])
       end
 
       def delete_pairs(pairs)
         relation.update_all(
           ["#{store_name} = delete(#{store_name}, hstore(ARRAY[:keys], ARRAY[:values]))",
-           keys: pairs.keys.map(&:to_s), values: pairs.values.map(&:to_s)]
+            keys: pairs.keys.map(&:to_s), values: pairs.values.map(&:to_s)]
         )
       end
     end

data/lib/pgrel/active_record/store/flexible_jsonb.rb

@@ -5,8 +5,8 @@ module ActiveRecord
     class FlexibleJsonb < ActiveRecord::Store::FlexibleStore
       def delete_keys(*keys)
         keys.flatten!
-        query = String.new "#{store_name} = #{store_name}"
-        keys.length.times { query.concat(' - ?') }
+        query = +"#{store_name} = #{store_name}"
+        keys.length.times { query.concat(" - ?") }
         relation.update_all([query, *keys])
       end
 
@@ -16,7 +16,7 @@ module ActiveRecord
 
       def delete_pairs(pairs)
         keys = pairs.keys
-        pairs = pairs.map { |k,v| { k => v } }
+        pairs = pairs.map { |k, v| {k => v} }
         @relation = relation.where.store(store_name, *pairs)
         delete_keys(keys)
       end

data/lib/pgrel/active_record/store_chain.rb

@@ -83,17 +83,17 @@ module ActiveRecord
               else
                 contains_clause(k => v)
               end
-            end.join(' and ')
-          end.join(' or ')
+            end.join(" and ")
+          end.join(" or ")
         )
         @scope
       end
 
-      if ActiveRecord.version.release >= Gem::Version.new("5")
-        protected
+      protected
 
+      if ActiveRecord.version.release >= Gem::Version.new("5")
         def update_scope(*opts)
-          where_clause = @scope.send(:where_clause_factory).build(opts, {})
+          where_clause = build_where_clause(opts)
           @scope.where_clause += @inverted ? where_clause.invert : where_clause
           @scope
         end
@@ -104,8 +104,6 @@ module ActiveRecord
           )
         end
       else
-        protected
-
         def update_scope(*opts)
           where_clause = @scope.send(:build_where, opts).map do |rel|
             @inverted ? invert_arel(rel) : rel
@@ -142,7 +140,15 @@ module ActiveRecord
       end
 
       def build_or_contains(k, vals)
-        vals.map { |v| contains_clause(k => v) }.join(' or ')
+        vals.map { |v| contains_clause(k => v) }.join(" or ")
+      end
+
+      def build_where_clause(opts)
+        if ActiveRecord.version.release >= Gem::Version.new("6.1.0")
+          @scope.send(:build_where_clause, opts)
+        else
+          @scope.send(:where_clause_factory).build(opts, [])
+        end
       end
     end
 
@@ -198,17 +204,30 @@ module ActiveRecord
 
       if ActiveRecord.version.release >= Gem::Version.new("5")
         def where_with_prefix(prefix, opts)
-          where_clause = @scope.send(:where_clause_factory).build(opts, [])
-          predicates = where_clause.ast.children.map do |rel|
-            rel.left = to_sql_literal(prefix, rel.left)
-            rel
+          where_clause = build_where_clause(opts)
+          where_clause_ast = where_clause.ast
+
+          # Converting `HomogenousIn` node to `In` type allows us to set its `left`
+          # to sql literal as with other node types (`HomogenousIn` does not support this).
+          if defined?(Arel::Nodes::HomogeneousIn) && where_clause_ast.is_a?(Arel::Nodes::HomogeneousIn)
+            where_clause_ast = Arel::Nodes::In.new(where_clause_ast.left, where_clause_ast.right)
+          end
+
+          predicates = if where_clause_ast.is_a?(Arel::Nodes::And)
+            where_clause.ast.children.map do |rel|
+              rel.left = to_sql_literal(prefix, rel.left)
+              rel
+            end
+          else
+            where_clause_ast.left = to_sql_literal(prefix, where_clause_ast.left)
+            [where_clause_ast]
           end
 
           params = if ActiveRecord.version.release >= Gem::Version.new("5.2.0")
-                     [predicates]
-                   else
-                     [predicates, where_clause.binds]
-                   end
+            [predicates]
+          else
+            [predicates, where_clause.binds]
+          end
 
           where_clause = ActiveRecord::Relation::WhereClause.new(*params)
           @scope.where_clause += @inverted ? where_clause.invert : where_clause

data/lib/pgrel/active_record/store_chain/jsonb_chain.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   module QueryMethods
     # Store chain for jsonb columns.
     class JsonbChain < KeyStoreChain
-      OPERATORS = { contains: '@>', overlap: '&&' }.freeze
+      OPERATORS = {contains: "@>", overlap: "&&"}.freeze
 
       # Query by value in path.
       #
@@ -18,17 +18,17 @@ module ActiveRecord
         args = flatten_hash(args.first) if args.size == 1
         val = args.pop
 
-        path = "{#{args.join(',')}}"
+        path = "{#{args.join(",")}}"
 
         case val
         when Hash
-          op = '#>'
+          op = "#>"
           val = ::ActiveSupport::JSON.encode(val)
         when Array
-          op = '#>>'
+          op = "#>>"
           val = val.map(&:to_s)
         else
-          op = '#>>'
+          op = "#>>"
           val = val.to_s
         end
 

data/lib/pgrel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pgrel # :nodoc:
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pgrel
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - palkan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-28 00:00:00.000000000 Z
+date: 2020-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -28,58 +28,30 @@ dependencies:
   name: pg
   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'
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.1'
-- !ruby/object:Gem::Dependency
-  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.8
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.3.8
-- !ruby/object:Gem::Dependency
-  name: pry-byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -101,17 +73,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rubocop.yml"
-- ".travis.yml"
 - CHANGELOG.md
-- Gemfile
-- MIT-LICENSE
+- LICENSE.txt
 - README.md
-- Rakefile
-- gemfiles/rails42.gemfile
-- gemfiles/rails5.gemfile
-- gemfiles/railsmaster.gemfile
 - lib/pgrel.rb
 - lib/pgrel/active_record.rb
 - lib/pgrel/active_record/query_methods.rb
@@ -125,15 +89,6 @@ files:
 - lib/pgrel/active_record/store_chain/hstore_chain.rb
 - lib/pgrel/active_record/store_chain/jsonb_chain.rb
 - lib/pgrel/version.rb
-- pgrel.gemspec
-- spec/pgrel/array_spec.rb
-- spec/pgrel/hstore_spec.rb
-- spec/pgrel/jsonb_spec.rb
-- spec/spec_helper.rb
-- spec/support/array_store.rb
-- spec/support/hstore.rb
-- spec/support/jsonb.rb
-- spec/support/user.rb
 homepage: http://github.com/palkan/pgrel
 licenses:
 - MIT
@@ -153,8 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: ActiveRecord extension for querying hstore and jsonb.

data/.gitignore

@@ -1,37 +0,0 @@
-# Numerous always-ignore extensions
-*.diff
-*.err
-*.orig
-*.log
-*.rej
-*.swo
-*.swp
-*.vi
-*~
-*.sass-cache
-*.iml
-.idea/
-
-# Sublime
-*.sublime-project
-*.sublime-workspace
-
-# OS or Editor folders
-.DS_Store
-.cache
-.project
-.settings
-.tmproj
-Thumbs.db
-coverage/
-
-.bundle/
-*.log
-*.gem
-pkg/
-spec/dummy/log/*.log
-spec/dummy/tmp/
-spec/dummy/.sass-cache
-Gemfile.local
-Gemfile.lock
-.rspec_status

data/.rubocop.yml

@@ -1,41 +0,0 @@
-# This strict rubocop config should be used before submiting PR and should pass
-# Doesn't include:
-# - specs
-
-
-AllCops:
-  # Include gemspec and Rakefile
-  Include:
-    - 'app/**/*.rb'
-    - 'config/**/*.rb'
-    - 'lib/**/*.rb'
-    - 'lib/**/*.rake'
-  Exclude:
-    - 'vendor/**/*'
-    - 'spec/**/*'
-    - 'db/*.rb'
-    - 'bin/**/*'
-  RunRailsCops: false
-  DisplayCopNames: true
-  StyleGuideCopsOnly: false
-
-Metrics/LineLength:
-  Max: 100
-
-Metrics/MethodLength:
-  Max: 15
-
-Metrics/AbcSize:
-  Max: 20
-
-Style/BarePercentLiterals:
-  Enabled: false
-
-Style/CommentAnnotation:
-  Enabled: false
-
-Style/RaiseArgs:
-  Enabled: false
-
-Style/StringLiterals: 
-  Enabled: false

data/.travis.yml

@@ -1,20 +0,0 @@
-language: ruby
-cache: bundler
-
-addons:
-  postgresql: "9.6"
-
-before_script:
-  - createdb pgrel
-  - psql -U postgres -d pgrel -c 'CREATE EXTENSION IF NOT EXISTS hstore;'
-
-matrix:
-  include:
-    - rvm: 2.6.0
-      gemfile: gemfiles/railsmaster.gemfile
-    - rvm: 2.6.0
-      gemfile: gemfiles/rails5.gemfile
-    - rvm: 2.4.3
-      gemfile: gemfiles/rails5.gemfile
-    - rvm: 2.3.2
-      gemfile: gemfiles/rails42.gemfile

data/Gemfile

@@ -1,11 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-local_gemfile = 'Gemfile.local'
-
-if File.exist?(local_gemfile)
-  eval(File.read(local_gemfile)) # rubocop:disable Lint/Eval
-else
-  gem 'activerecord', '~> 5.1'
-end

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec

data/gemfiles/rails42.gemfile

@@ -1,5 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'activerecord', "~>4.2"
-
-gemspec path: '..'

data/gemfiles/rails5.gemfile

@@ -1,5 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'activerecord', '~> 5.1'
-
-gemspec path: '..'

data/gemfiles/railsmaster.gemfile

@@ -1,5 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'rails', github: 'rails/rails'
-
-gemspec path: '..'

data/pgrel.gemspec

@@ -1,27 +0,0 @@
-$:.push File.expand_path("../lib", __FILE__)
-
-# Maintain your gem's version:
-require "pgrel/version"
-
-# Describe your gem and declare its dependencies:
-Gem::Specification.new do |s|
-  s.name        = "pgrel"
-  s.version     = Pgrel::VERSION
-  s.authors     = ["palkan"]
-  s.email       = ["dementiev.vm@gmail.com"]
-  s.homepage    = "http://github.com/palkan/pgrel"
-  s.summary     = "ActiveRecord extension for querying hstore and jsonb."
-  s.description = "ActiveRecord extension for querying hstore and jsonb."
-  s.license     = "MIT"
-
-  s.files         = `git ls-files`.split($/)
-  s.require_paths = ["lib"]
-
-  s.add_runtime_dependency "activerecord", ">= 4.0"
-
-  s.add_development_dependency "pg", "~>0.18"
-  s.add_development_dependency 'rake', '~> 10.1'
-  s.add_development_dependency "simplecov", ">= 0.3.8"
-  s.add_development_dependency 'pry-byebug'
-  s.add_development_dependency "rspec", ">= 3.1"
-end

data/spec/pgrel/array_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-describe ArrayStore do
-  before(:all) do
-    @connection = ActiveRecord::Base.connection
-
-    @connection.transaction do
-      @connection.create_table('array_stores') do |t|
-        t.string 'tags', default: [], null: false, array: true
-        t.string 'name'
-      end
-    end
-
-    ArrayStore.reset_column_information
-  end
-
-  after { ArrayStore.delete_all }
-
-  after(:all) do
-    @connection.drop_table 'array_stores', if_exists: true
-  end
-
-  let!(:setup) do
-    ArrayStore.create!(name: 'a', tags: [1, 2, 'a', 'b'])
-    ArrayStore.create!(name: 'b', tags: [2, 'b', 'e'])
-    ArrayStore.create!(name: 'c', tags: ['b'])
-    ArrayStore.create!(name: 'd')
-    ArrayStore.create!(name: 'e', tags: [2, 'x', 'c'])
-  end
-
-  context '#overlap' do
-    it "single simple argument" do
-      records = ArrayStore.where.store(:tags).overlap(:b)
-      expect(records.size).to eq 3
-    end
-
-    it "several arguments" do
-      records = ArrayStore.where.store(:tags).overlap('a', 1)
-      expect(records.size).to eq 1
-      expect(records.first.name).to eq 'a'
-    end
-
-    it "single array argument" do
-      records = ArrayStore.where.store(:tags).overlap([1, 'x'])
-      expect(records.size).to eq 2
-    end
-  end
-
-  it '#contains' do
-    records = ArrayStore.where.store(:tags).contains([2, 'b'])
-    expect(records.size).to eq 2
-
-    records = ArrayStore.where.store(:tags).contains([2, 'x'])
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'e'
-  end
-
-  it '#contained' do
-    records = ArrayStore.where.store(:tags).contained([1, 2, 'a', 'b'])
-    expect(records.size).to eq 3
-    expect(records.detect { |r| r.name == 'd' }).not_to be_nil
-
-    records = ArrayStore.where.store(:tags).contained([])
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'd'
-  end
-
-  context '#not' do
-    it '#overlap' do
-      expect(ArrayStore.where.store(:tags).not.overlap('b', 2).size).to eq 1
-    end
-  end
-
-  context "joins" do
-    before do
-      User.create!(name: "x", array_store: ArrayStore.find_by!(name: "a"))
-      User.create!(name: "y", array_store: ArrayStore.find_by!(name: "b"))
-      User.create!(name: "z", array_store: ArrayStore.find_by!(name: "c"))
-    end
-
-    it "works" do
-      users = User.joins(:array_store).merge(ArrayStore.where.store(:tags).overlap(2))
-      expect(users.size).to eq 2
-      expect(users.map(&:name)).to match_array(["x", "y"])
-    end
-  end
-end

data/spec/pgrel/hstore_spec.rb

@@ -1,237 +0,0 @@
-require 'spec_helper'
-
-describe Hstore do
-  before(:all) do
-    @connection = ActiveRecord::Base.connection
-
-    @connection.transaction do
-      @connection.create_table('hstores') do |t|
-        t.hstore 'tags', default: {}, null: false
-        t.string 'name'
-      end
-    end
-
-    Hstore.reset_column_information
-  end
-
-  after { Hstore.delete_all }
-
-  after(:all) do
-    @connection.drop_table 'hstores', if_exists: true
-  end
-
-  let!(:setup) do
-    Hstore.create!(name: 'a', tags: { a: 1, b: 2, f: true, d: 'a', g: 'b' })
-    Hstore.create!(name: 'b', tags: { a: 2, d: 'b', g: 'e' })
-    Hstore.create!(name: 'c', tags: { f: true, d: 'b' })
-    Hstore.create!(name: 'd', tags: { f: false })
-    Hstore.create!(name: 'e', tags: { a: 2, c: 'x', d: 'c', g: 'c' })
-    Hstore.create!(name: 'f', tags: { i: [1, 2, { a: 1 }], j: { a: 1, b: [1], f: false } } )
-    Hstore.create!(tags: { 1 => 2 })
-    Hstore.create!(name: 'z', tags: { z: nil })
-  end
-
-  context '#where' do
-    it 'simple values' do
-      expect(Hstore.where.store(:tags, a: 1, b: 2).first.name).to eq 'a'
-      expect(Hstore.where.store(:tags, a: 2, c: 'x').first.name).to eq 'e'
-      expect(Hstore.where.store(:tags, f: false).first.name).to eq 'd'
-    end
-
-    it 'integer keys' do
-      expect(Hstore.where.store(:tags, 1 => 2).size).to eq 1
-    end
-
-    it 'arrays' do
-      expect(Hstore.where.store(:tags, a: [1, 2, 3]).size).to eq 3
-    end
-
-    it 'many arrays' do
-      expect(
-        Hstore.where.store(
-          :tags,
-          a: [1, 2, 3],
-          c: %w(x y z),
-          d: %w(a c),
-          g: %w(b c)
-          ).size
-        ).to eq 1
-      expect(
-        Hstore.where.store(
-          :tags,
-          a: [1, 2, 3],
-          d: %w(a c),
-          g: %w(b c)
-          ).size
-        ).to eq 2
-    end
-
-    it 'lonely keys' do
-      records = Hstore.where.store(:tags, [:z])
-      expect(records.size).to eq 1
-      expect(records.first.name).to eq 'z'
-    end
-
-    it 'many hashes' do
-      expect(Hstore.where.store(:tags, { a: 2 }, { b: 2 }).size).to eq 3
-    end
-
-    it 'many hashes and lonely keys' do
-      expect(Hstore.where.store(:tags, { a: 1 }, :z).size).to eq 2
-      expect(Hstore.where.store(:tags, { a: 1 }, [:z]).size).to eq 2
-    end
-  end
-
-  it '#key' do
-    records = Hstore.where.store(:tags).key(:a)
-    expect(records.size).to eq 3
-
-    records = Hstore.where.store(:tags).key(:b)
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'a'
-  end
-
-  it '#keys' do
-    records = Hstore.where.store(:tags).keys('a', 'f')
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'a'
-
-    records = Hstore.where.store(:tags).keys([:a, :c])
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'e'
-  end
-
-  describe '#overlap_values' do
-    let(:records) { Hstore.where.store(:tags).overlap_values(1, false, [1, 2, { a: 1 }]) }
-
-    it 'returns records with overlapping values' do
-      expect(records.size).to eq 3
-    end
-
-    it 'calls avals function only once' do
-      expect(records.to_sql.scan(/avals/).count).to eq 1
-    end
-  end
-
-  it '#contains_values' do
-    records = Hstore.where.store(:tags).contains_values(1)
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'a'
-
-    records = Hstore.where.store(:tags).contains_values('2', 'b')
-    expect(records.size).to eq 2
-
-    records = Hstore.where.store(:tags).contains_values(true)
-    expect(records.size).to eq 2
-
-    records = Hstore.where.store(:tags).contains_values([1, 2, { a: 1 }], { a: 1, b: [1], f: false })
-    expect(records.size).to eq 1
-  end
-
-  it '#any' do
-    records = Hstore.where.store(:tags).any('b', 'f')
-    expect(records.size).to eq 3
-
-    records = Hstore.where.store(:tags).any([:c, :b])
-    expect(records.size).to eq 2
-  end
-
-  it '#contains' do
-    records = Hstore.where.store(:tags).contains(f: true)
-    expect(records.size).to eq 2
-
-    records = Hstore.where.store(:tags).contains(a: 2, c: 'x')
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'e'
-  end
-
-  it '#contained' do
-    records = Hstore.where.store(:tags).contained(
-      a: 2,
-      b: 2,
-      f: true,
-      d: 'b',
-      g: 'e'
-    )
-    expect(records.size).to eq 2
-
-    records = Hstore.where.store(:tags).contained(c: 'x', f: false)
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'd'
-  end
-
-  context '#not' do
-    it '#where' do
-      expect(Hstore.where.store(:tags).not(a: 2).size).to eq 6
-      expect(Hstore.where.store(:tags).not(a: 1, g: 'c').size).to eq 8
-    end
-
-    it '#any' do
-      expect(Hstore.where.store(:tags).not.any('a', 'f').size).to eq 3
-    end
-
-    it '#keys' do
-      expect(Hstore.where.store(:tags).not.keys('a', 'f').size).to eq 7
-    end
-  end
-
-  context "#update_store" do
-    let(:store) { :tags }
-
-    subject { Hstore.update_store(store) }
-
-    it "works on relation" do
-      Hstore.where.store(store).keys(:a).update_store(store).delete_keys(:a)
-      expect(Hstore.where.store(store).keys(:a)).to_not exist
-    end
-
-    it "#delete_keys" do
-      subject.delete_keys(:i)
-      expect(Hstore.where.store(store).keys(:i)).to_not exist
-
-      subject.delete_keys(:a, :b)
-      expect(Hstore.where.store(store).keys(:a)).to_not exist
-      expect(Hstore.where.store(store).keys(:b)).to_not exist
-
-      subject.delete_keys([:c, :d])
-      expect(Hstore.where.store(store).keys(:c)).to_not exist
-      expect(Hstore.where.store(store).keys(:d)).to_not exist
-    end
-
-    it "#merge" do
-      subject.merge(new_key: 1)
-      expect(Hstore.where.store(store).keys(:new_key).count).to be_eql Hstore.count
-
-      subject.merge([['new_key2', 'a'], ['new_key3', 'b']])
-      expect(Hstore.where.store(store).keys(:new_key2, :new_key3).count).to be_eql Hstore.count
-    end
-
-    it "#delete_pairs" do
-      subject.delete_pairs(f: true, a: 1)
-      expect(Hstore.where.store(store, f: true)).to_not exist
-      expect(Hstore.where.store(store, a: 1)).to_not exist
-      expect(Hstore.where.store(store, f: false)).to exist
-      expect(Hstore.where.store(store, a: 2)).to exist
-    end
-  end
-
-  context "joins" do
-    before do
-      User.create!(name: "x", hstore: Hstore.find_by!(name: "a"))
-      User.create!(name: "y", hstore: Hstore.find_by!(name: "b"))
-      User.create!(name: "z", hstore: Hstore.find_by!(name: "c"))
-    end
-
-    it "works" do
-      users = User.joins(:hstore).merge(Hstore.where.store(:tags).key(:a))
-      expect(users.size).to eq 2
-      expect(users.map(&:name)).to match_array(["x", "y"])
-    end
-
-    it "works with #contains_values" do
-      users = User.joins(:hstore).merge(Hstore.where.store(:tags).contains_values(1))
-      expect(users.size).to eq 1
-      expect(users.map(&:name)).to match_array(["x"])
-    end
-  end
-end

data/spec/pgrel/jsonb_spec.rb

@@ -1,239 +0,0 @@
-require 'spec_helper'
-
-describe Jsonb do
-  before(:all) do
-    @connection = ActiveRecord::Base.connection
-
-    @connection.transaction do
-      @connection.create_table('jsonbs') do |t|
-        t.jsonb 'tags', default: {}, null: false
-        t.string 'name'
-      end
-    end
-
-    Jsonb.reset_column_information
-  end
-
-  after { Jsonb.delete_all }
-
-  after(:all) do
-    @connection.drop_table 'jsonbs', if_exists: true
-  end
-
-  let!(:setup) do
-    Jsonb.create!(name: 'a')
-    Jsonb.create!(name: 'b', tags: { a: 1, d: { e: 2 } })
-    Jsonb.create!(name: 'c', tags: { a: 2, b: %w(c d) })
-    Jsonb.create!(name: 'd', tags: { a: 1, b: { c: 'd', e: true } })
-    Jsonb.create!(name: 'e', tags: { b: 2, c: 'e' })
-    Jsonb.create!(name: 'f', tags: { d: { e: 1, f: { h: { k: 'a', s: 2 } } } })
-    Jsonb.create!(name: 'g', tags: { f: false, g: { a: 1, b: '1' }, h: [1, '1'] })
-    Jsonb.create!(name: 'z', tags: { z: nil } )
-  end
-
-  context '#where' do
-    it 'simple values' do
-      expect(Jsonb.where.store(:tags, b: 2, c: 'e').first.name).to eq 'e'
-    end
-
-    it 'nested values' do
-      expect(
-        Jsonb.where.store(
-          :tags,
-          a: 1,
-          b: { c: 'd', e: true }
-        ).first.name).to eq 'd'
-    end
-
-    it 'arrays (as IN)' do
-      expect(Jsonb.where.store(:tags, a: [1, 2, 3]).size).to eq 3
-    end
-
-    it 'lonely keys' do
-      records = Jsonb.where.store(:tags, [:z])
-      expect(records.size).to eq 1
-      expect(records.first.name).to eq 'z'
-    end
-
-    it 'many hashes' do
-      expect(Jsonb.where.store(:tags, { a: 2 }, { b: 2 }).size).to eq 2
-    end
-
-    it 'many hashes and lonely keys' do
-      expect(Jsonb.where.store(:tags, { a: 2 }, :z).size).to eq 2
-      expect(Jsonb.where.store(:tags, { a: 2 }, [:z]).size).to eq 2
-    end
-  end
-
-  context '#path' do
-    it 'pass object' do
-      expect(Jsonb.where.store(:tags).path(b: { c: 'd' }).first.name).to eq 'd'
-
-      expect(
-        Jsonb.where.store(:tags).path(
-          d: { f:  { h: { s: 2 } } }
-        ).first.name
-      ).to eq 'f'
-    end
-
-    it 'pass array' do
-      expect(Jsonb.where.store(:tags).path(:b, :c, 'd').first.name).to eq 'd'
-    end
-
-    it 'match object' do
-      expect(
-        Jsonb.where.store(:tags).path(:d, :f, :h, k: 'a', s: 2).first.name
-      ).to eq 'f'
-    end
-
-    it 'match array (as IN)' do
-      expect(Jsonb.where.store(:tags).path(:d, :e, [1, 2]).size).to eq 2
-      expect(Jsonb.where.store(:tags).path(d: { e: [1, 2] }).size).to eq 2
-    end
-  end
-
-  it '#key' do
-    records = Jsonb.where.store(:tags).key(:a)
-    expect(records.size).to eq 3
-
-    records = Jsonb.where.store(:tags).key(:c)
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'e'
-  end
-
-  it '#keys' do
-    records = Jsonb.where.store(:tags).keys('a', 'b')
-    expect(records.size).to eq 2
-
-    records = Jsonb.where.store(:tags).keys([:b, :c])
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'e'
-  end
-
-  describe '#overlap_values' do
-    let(:records) { Jsonb.where.store(:tags).overlap_values(1, false, { e: 2 }) }
-
-    it 'returns records with overlapping values' do
-      expect(records.size).to eq 3
-    end
-
-    it 'calls array_agg function only once' do
-      expect(records.to_sql.scan(/array_agg/).count).to eq 1
-    end
-  end
-
-  it '#contains_values' do
-    records = Jsonb.where.store(:tags).contains_values(1)
-    expect(records.size).to eq 2
-
-    records = Jsonb.where.store(:tags).contains_values(2, 'e')
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'e'
-
-    records = Jsonb.where.store(:tags).contains_values(e: 1, f: { h: { k: 'a', s: 2 } })
-    expect(records.size).to eq 1
-
-    records = Jsonb.where.store(:tags).contains_values(false, { a: 1, b: '1' }, [1, '1'])
-    expect(records.size).to eq 1
-  end
-
-  it '#any' do
-    records = Jsonb.where.store(:tags).any('a', 'b')
-    expect(records.size).to eq 4
-
-    records = Jsonb.where.store(:tags).any([:c, :b])
-    expect(records.size).to eq 3
-  end
-
-  it '#contains' do
-    records = Jsonb.where.store(:tags).contains(a: 1)
-    expect(records.size).to eq 2
-
-    records = Jsonb.where.store(:tags).contains(a: 1, b: { c: 'd' })
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'd'
-  end
-
-  it '#contained' do
-    records = Jsonb.where.store(:tags).contained(
-      a: 2,
-      b: 2,
-      f: true,
-      c: 'e',
-      g: 'e'
-    )
-    expect(records.size).to eq 2
-
-    records =
-      Jsonb
-      .where.store(:tags).key(:a)
-      .where.store(:tags).contained(a: 2, b: %w(a b c d))
-
-    expect(records.size).to eq 1
-    expect(records.first.name).to eq 'c'
-  end
-
-  context '#not' do
-    it '#path' do
-      expect(
-        Jsonb.where.store(:tags).not.path(:d, :f, :h, k: 'a', s: 2).size
-      ).to eq 0
-    end
-  end
-
-  context "#update_store" do
-    let(:store) { :tags }
-
-    subject { Jsonb.update_store(store) }
-
-    it "#delete_keys" do
-      subject.delete_keys(:e)
-      expect(Jsonb.where.store(store).keys(:i)).to_not exist
-
-      subject.delete_keys(:a, :b)
-      expect(Jsonb.where.store(store).keys(:a)).to_not exist
-      expect(Jsonb.where.store(store).keys(:b)).to_not exist
-
-      subject.delete_keys([:c, :d])
-      expect(Jsonb.where.store(store).keys(:c)).to_not exist
-      expect(Jsonb.where.store(store).keys(:d)).to_not exist
-    end
-
-    it "#merge" do
-      subject.merge(new_key: 1)
-      expect(Jsonb.where.store(store).keys(:new_key).count).to be_eql Jsonb.count
-    end
-
-    it "#delete_pairs" do
-      subject.delete_pairs(a: 1, d: { e: 2 })
-      expect(Jsonb.where.store(store, a: 1)).to_not exist
-      expect(Jsonb.where.store(store, d: { e: 2 })).to_not exist
-    end
-  end
-
-  context "joins" do
-    before do
-      User.create!(name: "x", jsonb: Jsonb.find_by!(name: "a"))
-      User.create!(name: "y", jsonb: Jsonb.find_by!(name: "b"))
-      User.create!(name: "z", jsonb: Jsonb.find_by!(name: "c"))
-    end
-
-    it "works" do
-      users = User.joins(:jsonb).merge(Jsonb.where.store(:tags).key(:a))
-      expect(users.size).to eq 2
-      expect(users.map(&:name)).to match_array(["y", "z"])
-    end
-
-    it "works with #path" do
-      users = User.joins(:jsonb).merge(Jsonb.where.store(:tags).path(:a, 2))
-      expect(users.size).to eq 1
-      expect(users.map(&:name)).to match_array(["z"])
-    end
-
-    it "works with #contains_values" do
-      users = User.joins(:jsonb).merge(Jsonb.where.store(:tags).contains_values(1))
-      expect(users.size).to eq 1
-      expect(users.map(&:name)).to match_array(["y"])
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,44 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-if ENV['COVER']
-  require 'simplecov'
-  SimpleCov.root File.join(File.dirname(__FILE__), '..')
-  SimpleCov.start
-end
-
-require 'rspec'
-require 'pry-byebug'
-require 'active_record'
-require 'pg'
-require 'pgrel'
-
-ActiveRecord::Base.establish_connection(
-  adapter: 'postgresql',
-  host: 'localhost',
-  database: 'pgrel'
-)
-connection = ActiveRecord::Base.connection
-
-unless connection.extension_enabled?('hstore')
-  connection.enable_extension 'hstore'
-  connection.commit_db_transaction
-end
-
-connection.reconnect!
-
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-RSpec.configure do |config|
-  config.example_status_persistence_file_path = '.rspec_status'
-  config.filter_run focus: true
-  config.run_all_when_everything_filtered = true
-
-  config.order = :random
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  config.after(:each) { User.delete_all }
-end

data/spec/support/array_store.rb

@@ -1,2 +0,0 @@
-class ArrayStore < ActiveRecord::Base
-end

data/spec/support/hstore.rb

@@ -1,2 +0,0 @@
-class Hstore < ActiveRecord::Base
-end

data/spec/support/jsonb.rb

@@ -1,2 +0,0 @@
-class Jsonb < ActiveRecord::Base
-end

data/spec/support/user.rb

@@ -1,16 +0,0 @@
-ActiveRecord::Schema.define do
-  create_table :users, force: true do |t|
-    t.string :name
-    t.string :tags
-    t.integer :jsonb_id
-    t.integer :array_store_id
-    t.integer :hstore_id
-    t.timestamps null: true
-  end
-end
-
-class User < ActiveRecord::Base
-  belongs_to :jsonb
-  belongs_to :array_store
-  belongs_to :hstore
-end