active_record_extended 0.5.0.beta3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af96e1630626fddb09778e5ff69dc4bf01b06e17e2e462c7e65a2a165cac43dc
-  data.tar.gz: 512da6651d7413301e720414ecddfdca47700ce3bd22adce5957f444c8b34f9f
+  metadata.gz: a9eeb9aca8c378f3cdb7d615c59b9d2c0490f1c208029d8873af2ed44f75685e
+  data.tar.gz: 2964c85f3aef6d185f416965356248b6a4af918e9e30d9bf238e7bd02aab33b1
 SHA512:
-  metadata.gz: d165d1174ccb1f3fe3eb38cd08b399507564116da0a41847600b1dbc170f362b7cc763ef1191564a40c635abb1e07e0ec93bb92675f2283328cab78d032a5eda
-  data.tar.gz: 3b790bf77539c16b30ecb217400601b1d0e1bc7ddae2e01ca11c3886ff054acf062eefceab6f766b4c37e050659a098083197696055cbaa75ea796854a574c9f
+  metadata.gz: 35abb91e76d72d6c49ac746817a5071dbbc1081493f8506e01f16a4caf462664e890ba9dea3e8d69820bcbd2e0461bc556fada21e3a6e6967150596dcaff3cfd
+  data.tar.gz: 4c550088739bda0c8e42ded831a213abdaa86461864d25e9e236b9a2376758bf69a42afbe3e3c084cfda6294075a77a25415ca7907e7ed94503fb8b998b4c8ff

data/.gitignore

@@ -16,3 +16,4 @@
 *.DS_Store
 
 .pryrc
+coverage

data/.travis.yml

@@ -26,9 +26,15 @@ matrix:
 env: DATABASE_URL=postgres://postgres@localhost/active_record_extended_test
 
 before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
   - psql -c 'create database active_record_extended_test;' -U postgres
   - bundle exec rake db:migrate
 
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT
+
 cache:
   - bundler
 

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.5.0 - May 31st 2018
+
+Released non-marked beta version.
+
 # 0.5.0.beta3 - May 28th 2018
 
 Added `inet_contains_or_contained_within/1` method

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_record_extended (0.5.0.beta3)
+    active_record_extended (0.5.0)
       activerecord (>= 5.0, < 6.0)
       ar_outer_joins (~> 0.2)
       pg (~> 0.18)
@@ -29,9 +29,11 @@ GEM
     concurrent-ruby (1.0.5)
     database_cleaner (1.7.0)
     diff-lcs (1.3)
+    docile (1.3.0)
     dotenv (2.4.0)
     i18n (1.0.1)
       concurrent-ruby (~> 1.0)
+    json (2.1.0)
     method_source (0.9.0)
     minitest (5.11.3)
     parallel (1.12.1)
@@ -68,6 +70,11 @@ GEM
       ruby-progressbar (~> 1.7)
       unicode-display_width (~> 1.0, >= 1.0.1)
     ruby-progressbar (1.9.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
     thread_safe (0.3.6)
     tzinfo (1.2.5)
       thread_safe (~> 0.1)
@@ -87,6 +94,7 @@ DEPENDENCIES
   rake (~> 10.0)
   rspec (~> 3.0)
   rubocop (~> 0.52)
+  simplecov (~> 0.16)
 
 BUNDLED WITH
    1.16.1

data/README.md

@@ -1,5 +1,6 @@
-[![Build Status](https://travis-ci.com/GeorgeKaraszi/ActiveRecordExtended.svg?branch=master)](https://travis-ci.com/GeorgeKaraszi/ActiveRecordExtended) [![Maintainability](https://api.codeclimate.com/v1/badges/98ecffc0239417098cbc/maintainability)](https://codeclimate.com/github/GeorgeKaraszi/active_record_extended/maintainability)
-
+[![Build Status](https://travis-ci.com/GeorgeKaraszi/ActiveRecordExtended.svg?branch=master)](https://travis-ci.com/GeorgeKaraszi/ActiveRecordExtended) 
+[![Maintainability](https://api.codeclimate.com/v1/badges/98ecffc0239417098cbc/maintainability)](https://codeclimate.com/github/GeorgeKaraszi/active_record_extended/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/f22154211bb3a8feb89f/test_coverage)](https://codeclimate.com/github/GeorgeKaraszi/ActiveRecordExtended/test_coverage)
 ## Index
 - [Description and history](#description-and-history)
 - [Installation](#installation)
@@ -40,11 +41,11 @@ Active Record Extended is intended to be a supporting community that will mainta
 In Postgres the `ANY` expression is used for gather record's that have an Array column type that contain a single matchable value within its array. 
 
 ```ruby
-alice = Person.create!(tags: [1])
-bob   = Person.create!(tags: [1, 2])
-randy = Person.create!(tags: [3])
+alice = User.create!(tags: [1])
+bob   = User.create!(tags: [1, 2])
+randy = User.create!(tags: [3])
 
-Person.where.any(tags: 1) #=> [alice, bob] 
+User.where.any(tags: 1) #=> [alice, bob] 
 
 ```
 
@@ -57,11 +58,11 @@ This only accepts a single value. So querying for example multiple tag numbers `
 In Postgres the `ALL` expression is used for gather record's that have an Array column type that contains only a **single** and matchable element. 
 
 ```ruby
-alice = Person.create!(tags: [1])
-bob   = Person.create!(tags: [1, 2])
-randy = Person.create!(tags: [3])
+alice = User.create!(tags: [1])
+bob   = User.create!(tags: [1, 2])
+randy = User.create!(tags: [3])
 
-Person.where.all(tags: 1) #=> [alice] 
+User.where.all(tags: 1) #=> [alice] 
 
 ```
 
@@ -78,20 +79,20 @@ That contains all of the provided values.
 
 Array Type:
 ```ruby
-alice = Person.create!(tags: [1, 4])
-bob   = Person.create!(tags: [3, 1])
-randy = Person.create!(tags: [4, 1])
+alice = User.create!(tags: [1, 4])
+bob   = User.create!(tags: [3, 1])
+randy = User.create!(tags: [4, 1])
 
-Person.where.contains(tags: [1, 4]) #=> [alice, randy]
+User.where.contains(tags: [1, 4]) #=> [alice, randy]
 ```
 
 HSTORE / JSONB Type:
 ```ruby
-alice = Person.create!(data: { nickname: "ARExtend" })
-bob   = Person.create!(data: { nickname: "ARExtended" })
-randy = Person.create!(data: { nickname: "ARExtended" })
+alice = User.create!(data: { nickname: "ARExtend" })
+bob   = User.create!(data: { nickname: "ARExtended" })
+randy = User.create!(data: { nickname: "ARExtended" })
 
-Person.where.contains(data: { nickname: "ARExtended" }) #=> [bob, randy]
+User.where.contains(data: { nickname: "ARExtended" }) #=> [bob, randy]
 ```
 
 #### Overlap
@@ -100,13 +101,13 @@ Person.where.contains(data: { nickname: "ARExtended" }) #=> [bob, randy]
 The `overlap/1` method will match an Array column type that contains any of the provided values within its column.
 
 ```ruby
-alice = Person.create!(tags: [1, 4])
-bob   = Person.create!(tags: [3, 4])
-randy = Person.create!(tags: [4, 8])
+alice = User.create!(tags: [1, 4])
+bob   = User.create!(tags: [3, 4])
+randy = User.create!(tags: [4, 8])
 
-Person.where.overlap(tags: [4]) #=> [alice, bob, randy]
-Person.where.overlap(tags: [1, 8]) #=> [alice, randy]
-Person.where.overlap(tags: [1, 3, 8]) #=> [alice, bob, randy]
+User.where.overlap(tags: [4]) #=> [alice, bob, randy]
+User.where.overlap(tags: [1, 8]) #=> [alice, randy]
+User.where.overlap(tags: [1, 3, 8]) #=> [alice, bob, randy]
 
 ```
 
@@ -118,12 +119,12 @@ The `inet_contains` method works by taking a column(inet type) that has a submas
 And tries to find related records that fall within a given IP's range.
 
 ```ruby
-alice = Person.create!(ip: "127.0.0.1/16")
-bob   = Person.create!(ip: "192.168.0.1/16")
+alice = User.create!(ip: "127.0.0.1/16")
+bob   = User.create!(ip: "192.168.0.1/16")
 
-Person.where.inet_contains(ip: "127.0.0.254") #=> [alice]
-Person.where.inet_contains(ip: "192.168.20.44") #=> [bob]
-Person.where.inet_contains(ip: "192.255.1.1") #=> []
+User.where.inet_contains(ip: "127.0.0.254") #=> [alice]
+User.where.inet_contains(ip: "192.168.20.44") #=> [bob]
+User.where.inet_contains(ip: "192.255.1.1") #=> []
 ```
 
 ##### Inet Contains or Equals
@@ -132,12 +133,12 @@ Person.where.inet_contains(ip: "192.255.1.1") #=> []
 The `inet_contains_or_equals` method works much like the [Inet Contains](#inet-contains) method, but will also accept a submask range.
 
 ```ruby
-alice = Person.create!(ip: "127.0.0.1/10")
-bob   = Person.create!(ip: "127.0.0.44/24")
+alice = User.create!(ip: "127.0.0.1/10")
+bob   = User.create!(ip: "127.0.0.44/24")
 
-Person.where.inet_contains_or_equals(ip: "127.0.0.1/16") #=> [alice]
-Person.where.inet_contains_or_equals(ip: "127.0.0.1/10") #=> [alice]
-Person.where.inet_contains_or_equals(ip: "127.0.0.1/32") #=> [alice, bob]
+User.where.inet_contains_or_equals(ip: "127.0.0.1/16") #=> [alice]
+User.where.inet_contains_or_equals(ip: "127.0.0.1/10") #=> [alice]
+User.where.inet_contains_or_equals(ip: "127.0.0.1/32") #=> [alice, bob]
 ```
 
 ##### Inet Contained Within
@@ -146,12 +147,12 @@ Person.where.inet_contains_or_equals(ip: "127.0.0.1/32") #=> [alice, bob]
 For the `inet_contained_within` method, we try to find IP's that fall within a submasking range we provide.
 
 ```ruby
-alice = Person.create!(ip: "127.0.0.1")
-bob   = Person.create!(ip: "127.0.0.44") 
-randy = Person.create!(ip: "127.0.55.20")
+alice = User.create!(ip: "127.0.0.1")
+bob   = User.create!(ip: "127.0.0.44") 
+randy = User.create!(ip: "127.0.55.20")
 
-Person.where.inet_contained_within(ip: "127.0.0.1/24") #=> [alice, bob]
-Person.where.inet_contained_within(ip: "127.0.0.1/16") #=> [alice, bob, randy]
+User.where.inet_contained_within(ip: "127.0.0.1/24") #=> [alice, bob]
+User.where.inet_contained_within(ip: "127.0.0.1/16") #=> [alice, bob, randy]
 ```
 
 ##### Inet Contained Within or Equals
@@ -160,13 +161,13 @@ Person.where.inet_contained_within(ip: "127.0.0.1/16") #=> [alice, bob, randy]
 The `inet_contained_within_or_equals` method works much like the [Inet Contained Within](#inet-contained-within) method, but will also accept a submask range.
 
 ```ruby
-alice = Person.create!(ip: "127.0.0.1/10")
-bob   = Person.create!(ip: "127.0.0.44/32")
-randy = Person.create!(ip: "127.0.99.1")
+alice = User.create!(ip: "127.0.0.1/10")
+bob   = User.create!(ip: "127.0.0.44/32")
+randy = User.create!(ip: "127.0.99.1")
 
-Person.where.inet_contained_within_or_equals(ip: "127.0.0.44/32") #=> [bob]
-Person.where.inet_contained_within_or_equals(ip: "127.0.0.1/16") #=> [bob, randy]
-Person.where.inet_contained_within_or_equals(ip: "127.0.0.44/8") #=> [alice, bob, randy]
+User.where.inet_contained_within_or_equals(ip: "127.0.0.44/32") #=> [bob]
+User.where.inet_contained_within_or_equals(ip: "127.0.0.1/16") #=> [bob, randy]
+User.where.inet_contained_within_or_equals(ip: "127.0.0.44/8") #=> [alice, bob, randy]
 ```
 
 ##### Inet Contains or Contained Within
@@ -176,13 +177,13 @@ The `inet_contains_or_contained_within` method is a combination of [Inet Contain
 It essentially (the database) tries to use both methods to find as many records as possible that match either condition on both sides.
 
 ```ruby
-alice = Person.create!(ip: "127.0.0.1/24")
-bob   = Person.create!(ip: "127.0.22.44/8")
-randy = Person.create!(ip: "127.0.99.1")
+alice = User.create!(ip: "127.0.0.1/24")
+bob   = User.create!(ip: "127.0.22.44/8")
+randy = User.create!(ip: "127.0.99.1")
 
-Person.where.inet_contains_or_is_contained_within(ip: "127.0.255.80") #=> [bob]
-Person.where.inet_contains_or_is_contained_within(ip: "127.0.0.80") #=> [alice, bob]
-Person.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/8") #=> [alice, bob, randy]
+User.where.inet_contains_or_is_contained_within(ip: "127.0.255.80") #=> [bob]
+User.where.inet_contains_or_is_contained_within(ip: "127.0.0.80") #=> [alice, bob]
+User.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/8") #=> [alice, bob, randy]
 ```
 
 ### Conditional Methods
@@ -195,43 +196,82 @@ Person.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/8") #=> [alice
  
  Querying With Attributes:
  ```ruby
-alice = Person.create!(uid: 1)
-bob   = Person.create!(uid: 2)
-randy = Person.create!(uid: 3)
+alice = User.create!(uid: 1)
+bob   = User.create!(uid: 2)
+randy = User.create!(uid: 3)
 
-Person.where.any_of({ uid: 1 }, { uid: 2 }) #=> [alice, bob]
+User.where.any_of({ uid: 1 }, { uid: 2 }) #=> [alice, bob]
 ```
 
 Querying With ActiveRecord Objects:
 ```ruby
-alice = Person.create!(uid: 1)
-bob   = Person.create!(uid: 2)
-randy = Person.create!(uid: 3)
+alice = User.create!(uid: 1)
+bob   = User.create!(uid: 2)
+randy = User.create!(uid: 3)
 
-uid_one = Person.where(uid: 1)
-uid_two = Person.where(uid: 2)
+uid_one = User.where(uid: 1)
+uid_two = User.where(uid: 2)
 
-Person.where.any_of(uid_one, uid_two) #=> [alice, bob]
+User.where.any_of(uid_one, uid_two) #=> [alice, bob]
 ```
 
 Querying with Joined Relationships:
 ```ruby
-alice     = Person.create!(uid: 1)
-bob       = Person.create!(uid: 2)
-randy     = Person.create!(uid: 3)
-tag_alice = Tag.create!(person_id: alice.id)
-tag_bob   = Tag.create!(person_id: person_two.id)
-tag_randy = Tag.create!(person_id: person_three.id)
+alice     = User.create!(uid: 1)
+bob       = User.create!(uid: 2)
+randy     = User.create!(uid: 3)
+tag_alice = Tag.create!(user_id: alice.id)
+tag_bob   = Tag.create!(user_id: bob.id)
+tag_randy = Tag.create!(user_id: randy.id)
 
-bob_tag_query   = Tag.where(people: { id: two.id }).includes(:person)
-randy_tag_query = Tag.where(people: { id: three.id }).joins(:person)
+bob_tag_query   = Tag.where(users: { id: bob.id }).includes(:user)
+randy_tag_query = Tag.where(users: { id: randy.id }).joins(:user)
 
-Tag.joins(:person).where.any_of(bob_tag_query, randy_tag_query) #=> [tag_bob, tag_randy] (with person table joined)
+Tag.joins(:user).where.any_of(bob_tag_query, randy_tag_query) #=> [tag_bob, tag_randy] (with users table joined)
 ```
 
 #### Either Join
+
+The `#either_join/2` method is a base ActiveRecord querying method that will joins records based on a set of conditionally joinable tables.
+
+```ruby
+class User < ActiveRecord::Base
+  has_one :profile_l, class: "ProfileL"
+  has_one :profile_r, class: "ProfileR"
+  
+  scope :completed_profile, -> { either_joins(:profile_l, :profile_r) }
+end
+
+alice = User.create!
+bob   = User.create!
+randy = User.create! # Does not have a single completed profile type
+ProfileL.create!(user_id: alice.id)
+ProfileR.create!(user_id: bob.id)
+
+User.completed_profile #=> [alice, bob]
+# alternatively
+User.either_joins(:profile_l, :profile_r) #=> [alice, bob]
+```
+
 #### Either Order
 
+The `#either_order/3` method is a base ActiveRecord querying method that will order a set of columns that may or may not exist for each record.
+This works similar to how [Either Join](#either-join) works. This does not however exclude records that do not have relationships.
+
+```ruby
+alice = User.create!
+bob   = User.create!
+ProfileL.create!(user_id: alice.id, left_turns: 100)
+ProfileR.create!(user_id: bob.id, right_turns: 50)
+
+User.either_order(:asc, profile_l: :left_turns, profile_r: :right_turns) #=> [bob, alice]
+User.either_order(:desc, profile_l: :left_turns, profile_r: :right_turns) #=> [alice, bob]
+
+randy = User.create!
+User.either_order(:asc, profile_l: :left_turns, profile_r: :right_turns) #=> [bob, alice, randy]
+User.either_order(:desc, profile_l: :left_turns, profile_r: :right_turns) #=> [randy, alice, bob]
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/active_record_extended.gemspec

@@ -29,4 +29,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "database_cleaner", "~> 1.6"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov", "~> 0.16"
 end

data/lib/active_record_extended/arel/nodes.rb

@@ -5,64 +5,31 @@ require "arel/nodes/binary"
 module Arel
   module Nodes
     class Overlap < Arel::Nodes::Binary
-      def operator
-        :"&&"
-      end
     end
 
     class Contains < Arel::Nodes::Binary
-      def operator
-        :>>
-      end
     end
 
     class ContainsHStore < Arel::Nodes::Binary
-      def operator
-        :"@>"
-      end
     end
 
     class ContainsArray < Arel::Nodes::Binary
-      def operator
-        :"@>"
-      end
     end
 
     class ContainedInArray < Arel::Nodes::Binary
-      def operator
-        :"<@"
-      end
     end
 
     module Inet
       class ContainsEquals < Arel::Nodes::Binary
-        def operator
-          :">>="
-        end
       end
 
       class ContainedWithin < Arel::Nodes::Binary
-        def operator
-          :<<
-        end
       end
 
       class ContainedWithinEquals < Arel::Nodes::Binary
-        def operator
-          :"<<="
-        end
       end
 
       class ContainsOrContainedWithin < Arel::Nodes::Binary
-        def operator
-          :"&&"
-        end
-      end
-    end
-
-    class Node
-      def group_or(right)
-        Arel::Nodes::Or.new self, Arel::Nodes::Grouping.new(right)
       end
     end
   end

data/lib/active_record_extended/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordExtended
-  VERSION = "0.5.0.beta3"
+  VERSION = "0.5.0"
 end

data/spec/query_methods/either_spec.rb

@@ -28,23 +28,31 @@ RSpec.describe "Active Record Either Methods" do
   describe ".either_order/2" do
     it "Should not exclude anyone who does not have a relationship" do
       query = Person.either_order(:asc, profile_l: :likes, profile_r: :dislikes)
-      expect(query).to include(one, two, three)
+      expect(query.count).to eq(3)
+      expect(query[0]).to eq(two)
+      expect(query[1]).to eq(one)
+      expect(query[2]).to eq(three)
     end
 
     it "Should order people based on their likes and dislikes in ascended order" do
       query = Person.either_order(:asc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
-      expect(query).to match_array([two, one])
+      expect(query.count).to eq(2)
+      expect(query.first).to eq(two)
+      expect(query.last).to eq(one)
     end
 
     it "Should order people based on their likes and dislikes in descending order" do
       query = Person.either_order(:desc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
-      expect(query).to match_array([one, two])
+      expect(query.first).to eq(one)
+      expect(query.last).to eq(two)
     end
 
     context "Alias .either_order/2" do
       it "Should order people based on their likes and dislikes in ascended order" do
         query = Person.either_orders(:asc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
-        expect(query).to match_array([two, one])
+        expect(query.count).to eq(2)
+        expect(query.first).to eq(two)
+        expect(query.last).to eq(one)
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "simplecov"
+SimpleCov.start
+
 require "active_record_extended"
 
 unless ENV["DATABASE_URL"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_extended
 version: !ruby/object:Gem::Version
-  version: 0.5.0.beta3
+  version: 0.5.0
 platform: ruby
 authors:
 - George Protacio-Karaszi
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-27 00:00:00.000000000 Z
+date: 2018-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -116,6 +116,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
 description: Adds extended functionality to Activerecord Postgres implementation
 email:
 - georgekaraszi@gmail.com
@@ -192,9 +206,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.6