active_record_extended 0.5.0.beta1 → 0.5.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56c4be1e6e48ce5c2c7430545666c5a972d8355539d9f4eacd606bfb8919eb2c
-  data.tar.gz: d4ceaaaa423fc093cec3fb463ec2e2a54f9eba2f7f8b13ca0f2c55b45b4b38d1
+  metadata.gz: df4c51db1e23fe823d4f551b4b44eb607133b431f0970286b0e3b3a576c6ad42
+  data.tar.gz: cd2558c39e0224d6fc9719dc7ceb27a45ed0e98da7141ed620287f95ce4a6062
 SHA512:
-  metadata.gz: 1d5132209987cef0e73351c8343121998a107fad83d29d0e4b9f44fff72254b8c3f97f8b3ac237eb54f6aeb2b53254f5d93c4b63a0bc3597084e848795be9ce2
-  data.tar.gz: a9f707ddb4b0734e9fa8e62403e8787859e464e2b0d288dc6b51ab15abf235e1420398cbe7292de7987b42463572c96028f28dcd84cde16658df67a809ef65f5
+  metadata.gz: 520880c113c258caaa12a3ef2f83b92f1f7d6e71b03beaab5acd03050267071f2025b268f8156eb70206ad84887a13195717d76e328e10832257433a6963421e
+  data.tar.gz: 8ba91e9f95d7f77541d5f956811b4c61e9e04a2e8ecbe8cc12cff6fe79ead72ce7233699f7d89de53fcd67f1aa1a932ea2d31bbc144adc7943cd119e1f8e748b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_record_extended (0.5.0.beta1)
+    active_record_extended (0.5.0.beta2)
       activerecord (>= 5.0, < 6.0)
       ar_outer_joins (~> 0.2)
       pg (~> 0.18)

data/README.md

@@ -1,6 +1,25 @@
 [![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)
 
-# Active Record Extended
+## Index
+- [Description and history](#description-and-history)
+- [Installation](#installation)
+- [Useage](#usage)
+  - [Query Methods](#query-methods)
+    - [Any](#any)
+    - [All](#all)
+    - [Contains](#contains)
+    - [Overlap](#overlap)
+    - [Inet / IP Address](#inet--ip-address)
+      - [Inet Contains](#inet-contains)
+      - [Inet Contains or Equals](#inet-contains-or-equals)
+      - [Inet Contained Within](#inet-contained-within)
+      - [Inet Contained Within or Equals](#inet-contained-within-or-equals)
+  - [Conditional Methods](#conditional-methods)
+    - [Any_of / None_of](#any_of--none_of)
+    - [Either Join](#either-join)
+    - [Either Order](#either-order)
+
+## Description and History
 
 Active Record Extended is the continuation of maintaining and improving the work done by **Dan McClain**, the original author of [postgres_ext](https://github.com/DavyJonesLocker/postgres_ext).
 
@@ -9,6 +28,194 @@ The only problem is that this has created a wild west of environments of sorts.
 
 Active Record Extended is intended to be a supporting community that will maintain compatibility for the foreseeable future.
 
+
+## Usage
+
+### Query Methods
+
+#### Any
+[Postgres 'ANY' expression](https://www.postgresql.org/docs/10/static/functions-comparisons.html#id-1.5.8.28.16)
+
+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])
+
+Person.where.any(tags: 1) #=> [alice, bob] 
+
+```
+
+This only accepts a single value. So querying for example multiple tag numbers `[1,2]` will return nothing.
+
+
+#### All
+[Postgres 'ALL' expression](https://www.postgresql.org/docs/10/static/functions-comparisons.html#id-1.5.8.28.17)
+
+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])
+
+Person.where.all(tags: 1) #=> [alice] 
+
+```
+
+This only accepts a single value to a given attribute. So querying for example multiple tag numbers `[1,2]` will return nothing.
+
+#### Contains
+[Postgres '@>' (Array type) Contains expression](https://www.postgresql.org/docs/10/static/functions-array.html)
+
+[Postgres '@>' (JSONB/HSTORE type) Contains expression](https://www.postgresql.org/docs/10/static/functions-json.html#FUNCTIONS-JSONB-OP-TABLE)
+
+
+The `contains/1` method is used for finding any elements in an `Array`, `JSONB`, or `HSTORE` column type. 
+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])
+
+Person.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" })
+
+Person.where.contains(data: { nickname: "ARExtended" }) #=> [bob, randy]
+```
+
+#### Overlap
+[Postgres && (overlap) Expression](https://www.postgresql.org/docs/10/static/functions-array.html)
+
+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])
+
+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]
+
+```
+
+#### Inet / IP Address
+##### Inet Contains
+[Postgres >> (contains) Network Expression](https://www.postgresql.org/docs/current/static/functions-net.html)
+
+The `inet_contains` method works by taking a column(inet type) that has a submask prepended to it. 
+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")
+
+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") #=> []
+```
+
+##### Inet Contains or Equals
+[Postgres >>= (contains or equals) Network Expression](https://www.postgresql.org/docs/current/static/functions-net.html)
+
+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")
+
+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]
+```
+
+##### Inet Contained Within
+[Postgres << (contained within) Network Expression](https://www.postgresql.org/docs/current/static/functions-net.html)
+
+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")
+
+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]
+```
+
+##### Inet Contained Within or Equals
+[Postgres <<= (contained within or equals) Network Expression](https://www.postgresql.org/docs/current/static/functions-net.html)
+
+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")
+
+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]
+```
+
+
+### Conditional Methods
+#### Any_of / None_of
+ `any_of/1` simplifies the process of finding records that require multiple `or` conditions.
+ 
+ `none_of/1` is the inverse of `any_of/1`. It'll find records where none of the contains are matched.
+ 
+ Both accepts An array of: ActiveRecord Objects, Query Strings, and basic attribute names.
+ 
+ Querying With Attributes:
+ ```ruby
+alice = Person.create!(uid: 1)
+bob   = Person.create!(uid: 2)
+randy = Person.create!(uid: 3)
+
+Person.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)
+
+uid_one = Person.where(uid: 1)
+uid_two = Person.where(uid: 2)
+
+Person.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)
+
+bob_tag_query   = Tag.where(people: { id: two.id }).includes(:person)
+randy_tag_query = Tag.where(people: { id: three.id }).joins(:person)
+
+Tag.joins(:person).where.any_of(bob_tag_query, randy_tag_query) #=> [tag_bob, tag_randy] (with person table joined)
+```
+
+#### Either Join
+#### Either Order
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/Rakefile

@@ -61,6 +61,8 @@ namespace :db do
         t.integer  "personal_id"
         t.hstore   "data"
         t.jsonb    "jsonb_data"
+        t.inet     "ip"
+        t.cidr     "subnet"
         t.datetime "created_at"
         t.datetime "updated_at"
       end

data/lib/active_record_extended/arel/nodes.rb

@@ -34,21 +34,23 @@ module Arel
       end
     end
 
-    class ContainsEquals < Arel::Nodes::Binary
-      def operator
-        :">>="
+    module Inet
+      class ContainsEquals < Arel::Nodes::Binary
+        def operator
+          :">>="
+        end
       end
-    end
 
-    class ContainedWithin < Arel::Nodes::Binary
-      def operator
-        :<<
+      class ContainedWithin < Arel::Nodes::Binary
+        def operator
+          :<<
+        end
       end
-    end
 
-    class ContainedWithinEquals < Arel::Nodes::Binary
-      def operator
-        :"<<="
+      class ContainedWithinEquals < Arel::Nodes::Binary
+        def operator
+          :"<<="
+        end
       end
     end
 

data/lib/active_record_extended/arel/predications.rb

@@ -4,38 +4,39 @@ require "arel/predications"
 
 module Arel
   module Predications
-    def overlap(other)
-      Nodes::Overlap.new(self, Nodes.build_quoted(other, self))
+    def any(other)
+      any_tags_function = Arel::Nodes::NamedFunction.new("ANY", [self])
+      Arel::Nodes::Equality.new(Nodes.build_quoted(other, self), any_tags_function)
     end
 
-    def contains(other)
-      Nodes::Contains.new self, Nodes.build_quoted(other, self)
+    def all(other)
+      all_tags_function = Arel::Nodes::NamedFunction.new("ALL", [self])
+      Arel::Nodes::Equality.new(Nodes.build_quoted(other, self), all_tags_function)
     end
 
-    def contained_within(other)
-      Nodes::ContainedWithin.new self, Nodes.build_quoted(other, self)
+    def overlap(other)
+      Nodes::Overlap.new(self, Nodes.build_quoted(other, self))
     end
 
-    def contained_within_or_equals(other)
-      Nodes::ContainedWithinEquals.new self, Nodes.build_quoted(other, self)
+    def contains(other)
+      Nodes::Contains.new self, Nodes.build_quoted(other, self)
     end
+    alias inet_contains contains
 
     def contained_in_array(other)
       Nodes::ContainedInArray.new self, Nodes.build_quoted(other, self)
     end
 
-    def contains_or_equals(other)
-      Nodes::ContainsEquals.new self, Nodes.build_quoted(other, self)
+    def inet_contained_within(other)
+      Nodes::Inet::ContainedWithin.new self, Nodes.build_quoted(other, self)
     end
 
-    def any(other)
-      any_tags_function = Arel::Nodes::NamedFunction.new("ANY", [self])
-      Arel::Nodes::Equality.new(Nodes.build_quoted(other, self), any_tags_function)
+    def inet_contained_within_or_equals(other)
+      Nodes::Inet::ContainedWithinEquals.new self, Nodes.build_quoted(other, self)
     end
 
-    def all(other)
-      any_tags_function = Arel::Nodes::NamedFunction.new("ALL", [self])
-      Arel::Nodes::Equality.new(Nodes.build_quoted(other, self), any_tags_function)
+    def inet_contains_or_equals(other)
+      Nodes::Inet::ContainsEquals.new self, Nodes.build_quoted(other, self)
     end
   end
 end

data/lib/active_record_extended/arel/visitors/postgresql_decorator.rb

@@ -35,14 +35,6 @@ module ActiveRecordExtended
         infix_value object, collector, " @> "
       end
 
-      def visit_Arel_Nodes_ContainedWithin(object, collector)
-        infix_value object, collector, " << "
-      end
-
-      def visit_Arel_Nodes_ContainedWithinEquals(object, collector)
-        infix_value object, collector, " <<= "
-      end
-
       def visit_Arel_Nodes_ContainedInHStore(object, collector)
         infix_value object, collector, " <@ "
       end
@@ -51,7 +43,15 @@ module ActiveRecordExtended
         infix_value object, collector, " <@ "
       end
 
-      def visit_Arel_Nodes_ContainsEquals(object, collector)
+      def visit_Arel_Nodes_Inet_ContainedWithin(object, collector)
+        infix_value object, collector, " << "
+      end
+
+      def visit_Arel_Nodes_Inet_ContainedWithinEquals(object, collector)
+        infix_value object, collector, " <<= "
+      end
+
+      def visit_Arel_Nodes_Inet_ContainsEquals(object, collector)
         infix_value object, collector, " >>= "
       end
 

data/lib/active_record_extended/query_methods/inet.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module QueryMethods
+    module Inet
+      def contained_within(opts, *rest)
+        ActiveSupport::Deprecation.warn("#contained_within will soon be deprecated for version 1.0 release. "\
+                                        "Please use #inet_contained_within instead.", caller(1))
+        inet_contained_within(opts, *rest)
+      end
+
+      # Finds matching inet column records that fall within a given submasked IP range
+      #
+      # Column(inet) << "127.0.0.1/24"
+      #
+      # User.where.inet_contained_within(ip: "127.0.0.1/16")
+      #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" << '127.0.0.1/16'"
+      #
+      # User.where.inet_contained_within(ip: IPAddr.new("192.168.2.0/24"))
+      #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" << '192.168.2.0/24'"
+      #
+      def inet_contained_within(opts, *rest)
+        substitute_comparisons(opts, rest, Arel::Nodes::Inet::ContainedWithin, "inet_contained_within")
+      end
+
+      def contained_within_or_equals(opts, *rest)
+        ActiveSupport::Deprecation.warn("#contained_within_or_equals will soon be deprecated for version 1.0 release. "\
+                                        "Please use #inet_contained_within_or_equals instead.", caller(1))
+        inet_contained_within_or_equals(opts, *rest)
+      end
+
+      # Finds matching inet column records that fall within a given submasked IP range and also finds records that also
+      # contain a submasking field that fall within range too.
+      #
+      # Column(inet) <<= "127.0.0.1/24"
+      #
+      # User.where.inet_contained_within_or_equals(ip: "127.0.0.1/16")
+      #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" <<= '127.0.0.44/32'"
+      #
+      # User.where.inet_contained_within_or_equals(ip: IPAddr.new("192.168.2.0/24"))
+      #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" <<= '192.168.2.0/24'"
+      #
+      def inet_contained_within_or_equals(opts, *rest)
+        substitute_comparisons(opts, rest, Arel::Nodes::Inet::ContainedWithinEquals, "inet_contained_within_or_equals")
+      end
+
+      def contains_or_equals(opts, *rest)
+        ActiveSupport::Deprecation.warn("#contains_or_equals will soon be deprecated for version 1.0 release. "\
+                                        "Please use #inet_contains_or_equals instead.", caller(1))
+        inet_contains_or_equals(opts, *rest)
+      end
+
+      # Finds records that contain a submask and the supplied IP address falls within its range.
+      #
+      # Column(inet) >>= "127.0.0.1/24"
+      #
+      # User.where.inet_contained_within_or_equals(ip: "127.0.255.255")
+      #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" >>= '127.0.255.255'"
+      #
+      # User.where.inet_contained_within_or_equals(ip: IPAddr.new("127.0.0.255"))
+      #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" >>= '127.0.0.255/32'"
+      #
+      def inet_contains_or_equals(opts, *rest)
+        substitute_comparisons(opts, rest, Arel::Nodes::Inet::ContainsEquals, "inet_contains_or_equals")
+      end
+
+      # Strictly finds records that contain a submask and the supplied IP address falls within its range.
+      #
+      # Column(inet) >>= "127.0.0.1"
+      #
+      # User.where.inet_contained_within_or_equals(ip: "127.0.255.255")
+      #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" >> '127.0.255.255'"
+      #
+      # User.where.inet_contained_within_or_equals(ip: IPAddr.new("127.0.0.255"))
+      #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" >> '127.0.0.255/32'"
+      #
+      def inet_contains(opts, *rest)
+        substitute_comparisons(opts, rest, Arel::Nodes::Contains, "inet_contains")
+      end
+    end
+  end
+end
+
+ActiveRecord::QueryMethods::WhereChain.prepend(ActiveRecordExtended::QueryMethods::Inet)

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -9,18 +9,6 @@ module ActiveRecordExtended
       substitute_comparisons(opts, rest, Arel::Nodes::Overlap, "overlap")
     end
 
-    def contained_within(opts, *rest)
-      substitute_comparisons(opts, rest, Arel::Nodes::ContainedWithin, "contained_within")
-    end
-
-    def contained_within_or_equals(opts, *rest)
-      substitute_comparisons(opts, rest, Arel::Nodes::ContainedWithinEquals, "contained_within_or_equals")
-    end
-
-    def contains_or_equals(opts, *rest)
-      substitute_comparisons(opts, rest, Arel::Nodes::ContainsEquals, "contains_or_equals")
-    end
-
     # Finds Records that contain an element in an array column
     # User.where.any(tags: 3)
     #   # SELECT user.* FROM user WHERE 3 = ANY(user.tags)

data/lib/active_record_extended/version.rb

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

data/spec/query_methods/array_query_spec.rb

@@ -24,9 +24,9 @@ RSpec.describe "Active Record Array Query Methods" do
       expect(query).to include(one, two)
       expect(query).to_not include(three)
 
-      query = Person.where.overlap(tags: [8, 2])
-      expect(query).to include(one, three)
-      expect(query).to_not include(two)
+      query = Person.where.contains(tags: [8, 2])
+      expect(query).to include(three)
+      expect(query).to_not include(one, two)
     end
   end
 

data/spec/query_methods/inet_query_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record Inet Query Methods" do
+  describe "Deprecation Notices" do
+    %i[contained_within contained_within_or_equals contains_or_equals].each do |method|
+      it "Should display a deprecation warning for #{method}" do
+        new_method  = "inet_#{method}".to_sym
+        warning_msg = "##{method} will soon be deprecated for version 1.0 release. Please use ##{new_method} instead."
+        expect_any_instance_of(ActiveRecordExtended::QueryMethods::Inet).to receive(new_method)
+        expect { Person.where.send(method, nil) }.to output(Regexp.new(warning_msg)).to_stderr
+      end
+    end
+  end
+
+  describe "#inet_contained_within" do
+    let!(:local_1)     { Person.create!(ip: "127.0.0.1") }
+    let!(:local_44)    { Person.create!(ip: "127.0.0.44") }
+    let!(:local_99_1)  { Person.create!(ip: "127.0.99.1") }
+    let!(:local_range) { Person.create!(ip: "127.0.0.1/10") }
+
+    it "Should return people who have an IP within the 127.0.0.1/24 range" do
+      query = Person.where.inet_contained_within(ip: "127.0.0.1/24")
+      expect(query).to include(local_1, local_44)
+      expect(query).to_not include(local_99_1, local_range)
+    end
+
+    it "Should return all users who have an IP within the 127.0.0.1/16 range" do
+      query = Person.where.inet_contained_within(ip: "127.0.0.1/16")
+      expect(query).to include(local_1, local_44, local_99_1)
+      expect(query).to_not include(local_range)
+    end
+  end
+
+  describe "contained_within_or_equals" do
+    let!(:local_1)    { Person.create!(ip: "127.0.0.1/10") }
+    let!(:local_44)   { Person.create!(ip: "127.0.0.44/32") }
+    let!(:local_99_1) { Person.create!(ip: "127.0.99.1") }
+
+    it "Should find records that contain a matching submask" do
+      query = Person.where.inet_contained_within_or_equals(ip: "127.0.0.44/32")
+      expect(query).to include(local_44)
+      expect(query).to_not include(local_1, local_99_1)
+    end
+
+    it "Should find records that are within range of a given submask" do
+      query = Person.where.inet_contained_within_or_equals(ip: "127.0.0.1/16")
+      expect(query).to include(local_44, local_99_1)
+      expect(query).to_not include(local_1)
+
+      query = Person.where.inet_contained_within_or_equals(ip: "127.0.0.1/8")
+      expect(query).to include(local_1, local_44, local_99_1)
+    end
+  end
+
+  describe "#inet_contains_or_equals" do
+    let!(:local_1)    { Person.create!(ip: "127.0.0.1/10") }
+    let!(:local_44)   { Person.create!(ip: "127.0.0.44/24") }
+    let!(:local_99_1) { Person.create!(ip: "127.0.99.1") }
+
+    it "Should find records with submask ranges that contain a given IP" do
+      query = Person.where.inet_contains_or_equals(ip: "127.0.255.255")
+      expect(query).to include(local_1)
+      expect(query).to_not include(local_44, local_99_1)
+
+      query = Person.where.inet_contains_or_equals(ip: "127.0.0.255")
+      expect(query).to include(local_1, local_44)
+      expect(query).to_not include(local_99_1)
+    end
+
+    it "Finds records when querying with a submasked value" do
+      query = Person.where.inet_contains_or_equals(ip: "127.0.0.1/10")
+      expect(query).to include(local_1)
+      expect(query).to_not include(local_44, local_99_1)
+
+      query = Person.where.inet_contains_or_equals(ip: "127.0.0.1/32")
+      expect(query).to include(local_1, local_44)
+      expect(query).to_not include(local_99_1)
+    end
+  end
+
+  describe "#inet_contains" do
+    let!(:local_1)    { Person.create!(ip: "127.0.0.1/10") }
+    let!(:local_44)   { Person.create!(ip: "127.0.0.44/24") }
+
+    it "Should find records that the given IP falls within" do
+      query = Person.where.inet_contains(ip: "127.0.0.1")
+      expect(query).to include(local_1, local_44)
+    end
+
+    it "Should not find records when querying with a submasked value" do
+      query = Person.where.inet_contains(ip: "127.0.0.0/8")
+      expect(query).to be_empty
+    end
+  end
+end

data/spec/sql_inspections/arel/inet_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Inet Column Predicates" do
+  let(:arel_table) { Person.arel_table }
+
+  describe "#inet_contained_within" do
+    it "converts Arel inet contained within statement" do
+      query = arel_table.where(arel_table[:ip].inet_contained_within(IPAddr.new("127.0.0.1"))).to_sql
+      expect(query).to match_regex(%r{<< '127\.0\.0\.1/32'})
+    end
+
+    it "works with count" do
+      expect(Person.where(arel_table[:ip].inet_contained_within(IPAddr.new("127.0.0.1"))).count).to eq(0)
+    end
+  end
+
+  describe "#inet_contained_within_or_equals" do
+    it "converts Arel inet contained within statement" do
+      query = arel_table.where(arel_table[:ip].inet_contained_within_or_equals(IPAddr.new("127.0.0.1"))).to_sql
+      expect(query).to match_regex(%r{<<= '127\.0\.0\.1/32'})
+    end
+
+    it "works with count" do
+      expect(Person.where(arel_table[:ip].inet_contained_within_or_equals(IPAddr.new("127.0.0.1"))).count).to eq(0)
+    end
+  end
+
+  describe "#inet_contains_or_equals" do
+    it "converts Arel inet contained within statement" do
+      query = arel_table.where(arel_table[:ip].inet_contains_or_equals(IPAddr.new("127.0.0.1"))).to_sql
+      expect(query).to match_regex(%r{>>= '127\.0\.0\.1/32'})
+    end
+
+    it "works with count" do
+      expect(Person.where(arel_table[:ip].inet_contains_or_equals(IPAddr.new("127.0.0.1"))).count).to eq(0)
+    end
+  end
+
+  describe "#inet_contains" do
+    it "converts Arel inet contained within statement" do
+      query = arel_table.where(arel_table[:ip].inet_contains("127.0.0.1")).to_sql
+      expect(query).to match_regex(/>> '127\.0\.0\.1'/)
+    end
+
+    it "works with count" do
+      expect(Person.where(arel_table[:ip].inet_contains("127.0.0.1")).count).to eq(0)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_extended
 version: !ruby/object:Gem::Version
-  version: 0.5.0.beta1
+  version: 0.5.0.beta2
 platform: ruby
 authors:
 - George Protacio-Karaszi
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-26 00:00:00.000000000 Z
+date: 2018-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -160,6 +160,7 @@ files:
 - lib/active_record_extended/predicate_builder/array_handler_decorator.rb
 - lib/active_record_extended/query_methods/any_of.rb
 - lib/active_record_extended/query_methods/either.rb
+- lib/active_record_extended/query_methods/inet.rb
 - lib/active_record_extended/query_methods/where_chain.rb
 - lib/active_record_extended/version.rb
 - spec/active_record_extended_spec.rb
@@ -167,9 +168,11 @@ files:
 - spec/query_methods/array_query_spec.rb
 - spec/query_methods/either_spec.rb
 - spec/query_methods/hash_query_spec.rb
+- spec/query_methods/inet_query_spec.rb
 - spec/spec_helper.rb
 - spec/sql_inspections/any_of_sql_spec.rb
 - spec/sql_inspections/arel/array_spec.rb
+- spec/sql_inspections/arel/inet_spec.rb
 - spec/sql_inspections/contains_sql_queries_spec.rb
 - spec/sql_inspections/either_sql_spec.rb
 - spec/support/database_cleaner.rb
@@ -204,9 +207,11 @@ test_files:
 - spec/query_methods/array_query_spec.rb
 - spec/query_methods/either_spec.rb
 - spec/query_methods/hash_query_spec.rb
+- spec/query_methods/inet_query_spec.rb
 - spec/spec_helper.rb
 - spec/sql_inspections/any_of_sql_spec.rb
 - spec/sql_inspections/arel/array_spec.rb
+- spec/sql_inspections/arel/inet_spec.rb
 - spec/sql_inspections/contains_sql_queries_spec.rb
 - spec/sql_inspections/either_sql_spec.rb
 - spec/support/database_cleaner.rb