active_record_extended 0.5.0.beta2 → 0.5.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df4c51db1e23fe823d4f551b4b44eb607133b431f0970286b0e3b3a576c6ad42
-  data.tar.gz: cd2558c39e0224d6fc9719dc7ceb27a45ed0e98da7141ed620287f95ce4a6062
+  metadata.gz: af96e1630626fddb09778e5ff69dc4bf01b06e17e2e462c7e65a2a165cac43dc
+  data.tar.gz: 512da6651d7413301e720414ecddfdca47700ce3bd22adce5957f444c8b34f9f
 SHA512:
-  metadata.gz: 520880c113c258caaa12a3ef2f83b92f1f7d6e71b03beaab5acd03050267071f2025b268f8156eb70206ad84887a13195717d76e328e10832257433a6963421e
-  data.tar.gz: 8ba91e9f95d7f77541d5f956811b4c61e9e04a2e8ecbe8cc12cff6fe79ead72ce7233699f7d89de53fcd67f1aa1a932ea2d31bbc144adc7943cd119e1f8e748b
+  metadata.gz: d165d1174ccb1f3fe3eb38cd08b399507564116da0a41847600b1dbc170f362b7cc763ef1191564a40c635abb1e07e0ec93bb92675f2283328cab78d032a5eda
+  data.tar.gz: 3b790bf77539c16b30ecb217400601b1d0e1bc7ddae2e01ca11c3886ff054acf062eefceab6f766b4c37e050659a098083197696055cbaa75ea796854a574c9f

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+# 0.5.0.beta3 - May 28th 2018
+
+Added `inet_contains_or_contained_within/1` method
+
+# 0.5.0.beta2 - May 27th 2018
+
+Renamed inet functions to hopefully give a clearer understanding to what these methods are used for.
+
+Added support for Postgres Inet functions. View the readme for more details on the following:
+
+- `#inet_contained_within/1`
+- `#inet_contained_within_or_equals/1`
+- `#inet_contains_or_equals/1`
+- `#inet_contains/1`
+
+### Deprecation Warnings
+The following will be dropped upon v1.0 release. In favor of their prefixed counterparts.
+
+- `#contained_within/1`
+- `#contained_within_or_equals/1`
+- `#contains_or_equals/1`
+
 # 0.5.0.beta1 - May 26th 2018
 
 Added support for Rails 5.0.x

data/Gemfile.lock

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

data/README.md

@@ -14,6 +14,7 @@
       - [Inet Contains or Equals](#inet-contains-or-equals)
       - [Inet Contained Within](#inet-contained-within)
       - [Inet Contained Within or Equals](#inet-contained-within-or-equals)
+      - [Inet Contains or Contained Within](#inet-contains-or-contained-within)
   - [Conditional Methods](#conditional-methods)
     - [Any_of / None_of](#any_of--none_of)
     - [Either Join](#either-join)
@@ -140,7 +141,7 @@ 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)
+[Postgres << (contained by) 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.
 
@@ -154,7 +155,7 @@ 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)
+[Postgres <<= (contained by 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.
 
@@ -168,6 +169,21 @@ 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]
 ```
 
+##### Inet Contains or Contained Within
+[Postgres && (contains or is contained by) Network Expression](https://www.postgresql.org/docs/current/static/functions-net.html)
+
+The `inet_contains_or_contained_within` method is a combination of [Inet Contains](#inet-contains) and [Inet Contained Within](#inet-contained-within).
+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")
+
+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]
+```
 
 ### Conditional Methods
 #### Any_of / None_of

data/lib/active_record_extended/arel/nodes.rb

@@ -52,6 +52,12 @@ module Arel
           :"<<="
         end
       end
+
+      class ContainsOrContainedWithin < Arel::Nodes::Binary
+        def operator
+          :"&&"
+        end
+      end
     end
 
     class Node

data/lib/active_record_extended/arel/predications.rb

@@ -27,6 +27,10 @@ module Arel
       Nodes::ContainedInArray.new self, Nodes.build_quoted(other, self)
     end
 
+    def inet_contains_or_is_contained_within(other)
+      Nodes::Inet::ContainsOrContainedWithin.new self, Nodes.build_quoted(other, self)
+    end
+
     def inet_contained_within(other)
       Nodes::Inet::ContainedWithin.new self, Nodes.build_quoted(other, self)
     end

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

@@ -55,6 +55,10 @@ module ActiveRecordExtended
         infix_value object, collector, " >>= "
       end
 
+      def visit_Arel_Nodes_Inet_ContainsOrContainedWithin(object, collector)
+        infix_value object, collector, " && "
+      end
+
       def matchable_column?(col, object)
         col.name == object.left.name.to_s || col.name == object.left.relation.name.to_s
       end

data/lib/active_record_extended/query_methods/inet.rb

@@ -77,6 +77,24 @@ module ActiveRecordExtended
       def inet_contains(opts, *rest)
         substitute_comparisons(opts, rest, Arel::Nodes::Contains, "inet_contains")
       end
+
+      # This method is a combination of `inet_contains` and `inet_contained_within`
+      #
+      # Finds records that are contained within a given submask. And will also find records where their submask is also
+      # contains a given IP or IP submask.
+      #
+      # Column(inet) && "127.0.0.1/28"
+      #
+      # User.where.inet_contains_or_is_contained_by(ip: "127.0.255.255/28")
+      #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" && '127.0.255.255/28'"
+      #
+      # User.where.inet_contains_or_is_contained_by(ip: IPAddr.new("127.0.0.255"))
+      #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" && '127.0.0.255/32'"
+      #
+      def inet_contains_or_is_contained_within(opts, *rest)
+        substitute_comparisons(opts, rest, Arel::Nodes::Inet::ContainsOrContainedWithin,
+                               "inet_contains_or_is_contained_within")
+      end
     end
   end
 end

data/lib/active_record_extended/version.rb

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

data/spec/query_methods/inet_query_spec.rb

@@ -33,7 +33,7 @@ RSpec.describe "Active Record Inet Query Methods" do
     end
   end
 
-  describe "contained_within_or_equals" do
+  describe "inet_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") }
@@ -94,4 +94,28 @@ RSpec.describe "Active Record Inet Query Methods" do
       expect(query).to be_empty
     end
   end
+
+  describe "#inet_contains_or_is_contained_within" do
+    let!(:local_1)    { Person.create!(ip: "127.0.0.1/24") }
+    let!(:local_44)   { Person.create!(ip: "127.0.22.44/8") }
+    let!(:local_99_1) { Person.create!(ip: "127.0.99.1") }
+
+    it "should find records where the records contain the given IP" do
+      query = Person.where.inet_contains_or_is_contained_within(ip: "127.0.255.80")
+      expect(query).to include(local_44)
+      expect(query).to_not include(local_1, local_99_1)
+
+      query = Person.where.inet_contains_or_is_contained_within(ip: "127.0.0.80")
+      expect(query).to include(local_1, local_44)
+      expect(query).to_not include(local_99_1)
+    end
+
+    it "Should find records that the where query contains a valid range" do
+      query = Person.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/8")
+      expect(query).to include(local_1, local_44, local_99_1)
+
+      query = Person.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/16")
+      expect(query).to include(local_1, local_44, local_99_1)
+    end
+  end
 end

data/spec/sql_inspections/arel/inet_spec.rb

@@ -48,4 +48,19 @@ RSpec.describe "Inet Column Predicates" do
       expect(Person.where(arel_table[:ip].inet_contains("127.0.0.1")).count).to eq(0)
     end
   end
+
+  describe "#inet_contains_or_is_contained_within" do
+    it "converts Arel inet contained within statement" do
+      query = arel_table.where(arel_table[:ip].inet_contains_or_is_contained_within("127.0.0.1")).to_sql
+      expect(query).to match_regex(/&& '127\.0\.0\.1'/)
+
+      query = arel_table.where(arel_table[:ip].inet_contains_or_is_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_contains_or_is_contained_within("127.0.0.1")).count).to eq(0)
+      expect(Person.where(arel_table[:ip].inet_contains_or_is_contained_within(IPAddr.new("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.beta2
+  version: 0.5.0.beta3
 platform: ruby
 authors:
 - George Protacio-Karaszi