pgrel 0.1.1 → 0.3.1

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', '~>4.0'
-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/rails40.gemfile

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

data/gemfiles/rails41.gemfile

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

data/gemfiles/rails42.gemfile

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

data/gemfiles/rails5.gemfile

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'arel', github: 'rails/arel'
-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.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.0"
-end

data/spec/pgrel/array_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe ArrayStore do
-  before 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 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
-end

data/spec/pgrel/hstore_spec.rb

@@ -1,130 +0,0 @@
-require 'spec_helper'
-
-describe Hstore do
-  before 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 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!(tags: { 1 => 2 })
-  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
-  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
-
-  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: 1, g: 'c').size).to eq 1
-    end
-
-    it '#any' do
-      expect(Hstore.where.store(:tags).not.any('a', 'f').size).to eq 1
-    end
-
-    it '#keys' do
-      expect(Hstore.where.store(:tags).not.keys('a', 'f').size).to eq 5
-    end
-  end
-end

data/spec/pgrel/jsonb_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-describe Jsonb do
-  before 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 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 } } } })
-  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
-  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
-
-  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
-end

data/spec/spec_helper.rb

@@ -1,35 +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',
-  username: 'pgrel',
-  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.mock_with :rspec
-end