pgrel 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7879b5fb4b3bac896964ab6e0e5827ce6f088a37
-  data.tar.gz: 22bd6d7ad1f87a9c9044eb845cf6140e93e27c88
+  metadata.gz: 642a7d4b7a7b19f5acc220e6f74d41d6d0e00524
+  data.tar.gz: 007ba40877cfc0c6bdbb260502b98b1627ceaaa6
 SHA512:
-  metadata.gz: 821537ca351a39f7e4707ab5d7c482b4f417ba12c0eaac8a7b5a164d3df971ff4b23a2d941d1504c7748f00611ef3ed9c5d7c64bc222606d125679c0dd5dd14a
-  data.tar.gz: d6f51444606d5f574b427aad9c932f7186ee2f54d712dbc509e2c573eeefcf1172445e8777278934835d4881d7e000af6a7eab00cb8908eac9106d51655de41e
+  metadata.gz: 82cf0b3c4ed6c5ec72a55e6572ee0a197cb15079c70f48d61499acaac15d4d98bcb2262f5965a55c5c669bd4a98e04edd0e18da9b0ff7e018ae94ca82b2363e5
+  data.tar.gz: 130ed3ac3d71c6c98f72a33a881877f23f147653a1735a68a4bc8016996345cca77721713874d9f0a8d9b2991f2ccc4758b026224b4aa450e9b2cf0e0c8c8ce9

data/.gitignore

@@ -23,6 +23,7 @@
 .settings
 .tmproj
 Thumbs.db
+coverage/
 
 .bundle/
 log/*.log
@@ -30,3 +31,5 @@ pkg/
 spec/dummy/log/*.log
 spec/dummy/tmp/
 spec/dummy/.sass-cache
+Gemfile.local
+Gemfile.lock

data/.rubocop.yml

@@ -0,0 +1,45 @@
+# 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
+
+Style/Documentation:
+  Exclude:
+    - 'lib/**/version.rb'
+
+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,21 +1,21 @@
 language: ruby
 cache: bundler
-rvm:
-  - 2.2
 
-gemfile:
-  - Gemfile
+addons:
+  postgresql: "9.4"
+
+before_script:
+  - createuser pgrel -d
+  - createdb -U pgrel pgrel
+  - psql -U postgres -d pgrel -c 'CREATE EXTENSION IF NOT EXISTS hstore;'
 
 matrix:
   include:
-    - rvm: 2.2
-      gemfile: gemfiles/rails40.gemfile
-
-    - rvm: 2.2
-      gemfile: gemfiles/rails41.gemfile
-
-    - rvm: 2.2
+    - rvm: 2.2.1
+      gemfile: gemfiles/rails5.gemfile
+    - rvm: 2.2.1
       gemfile: gemfiles/rails42.gemfile
-
-    - rvm: 2.2
-      gemfile: gemfiles/rails5.gemfile
+    - rvm: 2.1
+      gemfile: gemfiles/rails41.gemfile
+    - rvm: 2.1
+      gemfile: gemfiles/rails40.gemfile

data/Gemfile

@@ -1,2 +1,11 @@
 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/README.md

@@ -2,4 +2,6 @@
 
 ## Pgrel
 
+**Rails 5**
+
 ActiveRecord extension for querying hstore and jsonb.

data/gemfiles/rails40.gemfile

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

data/gemfiles/rails41.gemfile

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

data/gemfiles/rails42.gemfile

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

data/gemfiles/rails5.gemfile

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

data/lib/pgrel/active_record/query_methods.rb

@@ -0,0 +1,31 @@
+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
+    # Extend WhereChain with 'store' method.
+    class WhereChain
+      def store(store_name, *opts)
+        store_name = store_name.to_s
+        column = @scope.klass.columns_hash[store_name]
+
+        # Rails 4 column has method 'array'
+        # but Rails 5 has 'array?'.
+        #
+        # So, check both(
+        if (arr = column.try(:array)) || (arr.nil? && column.array?)
+          klass = ArrayChain
+        else
+          column_klass = column.type.capitalize
+          klass = "ActiveRecord::QueryMethods::#{column_klass}Chain".constantize
+        end
+        chain = klass.new(@scope, store_name)
+        return chain.where(*opts) unless opts.empty?
+        chain
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module ActiveRecord
+  module QueryMethods
+    # Store chain for array columns.
+    class ArrayChain < StoreChain
+      # Whether the array overlaps provided array.
+      #
+      # Example
+      #   Model.create!(name: 'first', store: ['b', 'c'])
+      #   Model.create!(name: 'second', store: ['a', 'b'])
+      #
+      #   Model.store(:store).overlap('c').all #=> [Model(name: 'first', ...)]
+      #   Model.store(:store).overlap(['b']).size #=> 2
+      def overlap(*vals)
+        update_scope "#{@store_name} && #{type_cast(vals.flatten)}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module ActiveRecord
+  module QueryMethods
+    # Store chain for hstore columns.
+    class HstoreChain < KeyStoreChain
+      # Query by store values.
+      #
+      # Supports array values.
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {b: 1, c: 2})
+      #   Model.create!(name: 'second', store: {b: 2, c: 3})
+      #
+      #   Model.store(:store, c: 2).all #=> [Model(name: 'first', ...)]
+      #   Model.store(:store, b: [1, 2]).size #=> 2
+      def where(opts)
+        opts = stringify(opts)
+        where_with_prefix "#{@store_name}->", opts
+      end
+
+      private
+
+      def stringify(val)
+        case val
+        when String
+          val
+        when Array
+          val.map { |v| stringify(v) }
+        when Hash
+          Hash[val.map { |k, v| [k, stringify(v)] }]
+        else
+          val.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module ActiveRecord
+  module QueryMethods
+    # Store chain for jsonb columns.
+    class JsonbChain < KeyStoreChain
+      # Query by store values.
+      # Supports array values (convert to IN statement).
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {b: 1, c: 2})
+      #   Model.create!(name: 'second', store: {b: 2, c: 3})
+      #
+      #   Model.store(:store, c: 2).all #=> [Model(name: 'first', ...)]
+      #   Model.store(:store, b: [1, 2]).size #=> 2
+      def where(opts)
+        opts = flatten_json(opts)
+        where_with_prefix "#{@store_name}->", opts
+      end
+
+      # Query by quality in path.
+      #
+      # Path can be set as object or as args.
+      #
+      # Example:
+      #   Model.create!(name: 'first', store: {b: 1, c: { d: 3 } })
+      #   Model.create!(name: 'second', store: {b: 2, c: { d: 1 }})
+      #
+      #   Model.store(:store).path(c: {d: 3}).all #=> [Model(name: 'first', ...)]
+      #   Model.store(:store).path('c', 'd', [1, 3]).size #=> 2
+      def path(*args)
+        args = flatten_hash(args.first) if args.size == 1
+        val = args.pop
+
+        path = "{#{args.join(',')}}"
+
+        case val
+        when Hash
+          op = '#>'
+          val = ::ActiveSupport::JSON.encode(val)
+        when Array
+          op = '#>>'
+          val = val.map(&:to_s)
+        else
+          op = '#>>'
+          val = val.to_s
+        end
+
+        where_with_prefix "#{@store_name}#{op}", path => val
+      end
+
+      private
+
+      def flatten_json(val)
+        Hash[
+          val.map do |k, v|
+            if v.is_a?(Array)
+              [k, v.map { |i| ::ActiveSupport::JSON.encode(i) }]
+            else
+              [k, ::ActiveSupport::JSON.encode(v)]
+            end
+          end
+        ]
+      end
+
+      def flatten_hash(hash)
+        case hash
+        when Hash
+          hash.flat_map { |k, v| [k, *flatten_hash(v)] }
+        when Array
+          [hash]
+        else
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/pgrel/active_record/store_chain.rb

@@ -0,0 +1,176 @@
+# Check rails version
+RAILS_5 = ActiveRecord.version.release >= Gem::Version.new("5")
+
+module ActiveRecord
+  module QueryMethods
+    # Base class for different store chains (hstore, jsonb, array).
+    # Provides _containment_ queries methods.
+    # Provides basic methods.
+    class StoreChain
+      def initialize(scope, store_name)
+        @scope = scope
+        @store_name = store_name
+        @inverted = false
+      end
+
+      # Whether the store contains provided store
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {a: 1, b: 2})
+      #   Model.create!(name: 'second', store: {b: 1, c: 3})
+      #
+      #   data = {a: 1}
+      #   Model.store(:store).contains(data).all #=> [Model(name: 'first', ...)]
+      def contains(opts)
+        update_scope "#{@store_name} @> #{type_cast(opts)}"
+      end
+
+      # Whether the store is contained within provided store
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {b: 1})
+      #   Model.create!(name: 'second', store: {b: 1, c: 3})
+      #
+      #   data = {b: 1, c: 2}
+      #   Model.store(:store).contains(data).all #=> [Model(name: 'first', ...)]
+      def contained(opts)
+        update_scope "#{@store_name} <@ #{type_cast(opts)}"
+      end
+
+      # Add negation to condition.
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {b: 2})
+      #   Model.create!(name: 'second', store: {b: 1, c: 3})
+      #
+      #   Model.store(:store).not.contains({c: 3}).all #=> [Model(name: 'first')]
+      #
+      #   Model.store(:store).not(b: 2).all #=> [Model(name: 'second')]
+      def not(opts = :chain)
+        @inverted = true
+        return where(opts) unless opts == :chain
+        self
+      end
+
+      if RAILS_5
+        protected
+
+        def update_scope(*opts)
+          where_clause = @scope.send(:where_clause_factory).build(opts, {})
+          @scope.where_clause += @inverted ? where_clause.invert : where_clause
+          @scope
+        end
+
+        def type_cast(value)
+          ActiveRecord::Base.connection.quote(
+            @scope.table.type_cast_for_database(@store_name, value)
+          )
+        end
+
+        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
+          end
+          where_clause = ActiveRecord::Relation::WhereClause.new(
+            predicates,
+            where_clause.binds
+          )
+          @scope.where_clause += @inverted ? where_clause.invert : where_clause
+          @scope
+        end
+      else
+        protected
+
+        def update_scope(*opts)
+          where_clause = @scope.send(:build_where, opts).map do |rel|
+            @inverted ? invert_arel(rel) : rel
+          end
+          @scope.where_values += where_clause
+          @scope
+        end
+
+        def type_cast(value)
+          ActiveRecord::Base.connection.quote(
+            value,
+            @scope.klass.columns_hash[@store_name]
+          )
+        end
+
+        def where_with_prefix(prefix, opts)
+          where_value = @scope.send(:build_where, opts).map do |rel|
+            rel.left = to_sql_literal(prefix, rel.left)
+            @inverted ? invert_arel(rel) : rel
+          end
+          @scope.where_values += where_value
+          @scope
+        end
+
+        def invert_arel(rel)
+          case rel
+          when Arel::Nodes::In
+            Arel::Nodes::NotIn.new(rel.left, rel.right)
+          when Arel::Nodes::Equality
+            Arel::Nodes::NotEqual.new(rel.left, rel.right)
+          when String
+            Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new(rel))
+          else
+            Arel::Nodes::Not.new(rel)
+          end
+        end
+      end
+    end
+
+    # Base class for key-value types of stores (hstore, jsonb)
+    class KeyStoreChain < StoreChain
+      # Single key existence
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {a: 1})
+      #   Model.create!(name: 'second', store: {b: 1})
+      #
+      #   # Get all records which have key 'a' in store 'store'
+      #   Model.store(:store).key('a').all #=> [Model(name: 'first', ...)]
+      def key(key)
+        update_scope "#{@store_name} ? :key", key: key.to_s
+      end
+
+      # Several keys existence
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {a: 1, b: 2})
+      #   Model.create!(name: 'second', store: {b: 1, c: 3})
+      #
+      #   Model.store(:store).keys('a','b').all #=> [Model(name: 'first', ...)]
+      def keys(*keys)
+        update_scope(
+          "#{@store_name} ?& ARRAY[:keys]",
+          keys: keys.flatten.map(&:to_s)
+        )
+      end
+
+      # Any of the keys existence
+      #
+      # Example
+      #   Model.create!(name: 'first', store: {a: 1, b: 2})
+      #   Model.create!(name: 'second', store: {b: 1, c: 3})
+      #
+      #   Model.store(:store).keys('a','b').count #=> 2
+      def any(*keys)
+        update_scope(
+          "#{@store_name} ?| ARRAY[:keys]",
+          keys: keys.flatten.map(&:to_s)
+        )
+      end
+
+      protected
+
+      def to_sql_literal(prefix, node)
+        Arel::Nodes::SqlLiteral.new(
+          "#{prefix}'#{node.name}'"
+        )
+      end
+    end
+  end
+end

data/lib/pgrel/active_record.rb

@@ -0,0 +1,2 @@
+require 'active_record'
+require 'pgrel/active_record/query_methods'

data/lib/pgrel/version.rb

@@ -1,3 +1,3 @@
 module Pgrel
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/pgrel.rb

@@ -1,2 +1,2 @@
-module Pgrel
-end
+require 'pgrel/version'
+require 'pgrel/active_record'

data/pgrel.gemspec

@@ -17,12 +17,11 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split($/)
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency "rails", '>= 4.0'
-
-  s.add_development_dependency "pg"
+  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"
-  s.add_development_dependency "rspec-rails", "~> 3.1.0"
 end

data/spec/pgrel/array_spec.rb

@@ -0,0 +1,71 @@
+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