Introduce ActiveResource::WhereClause

Closes [#408][]

Introduce a simple chainable `WhereClause` class inspired by [Active
Record][].

All methods (including those that integrate with [Enumerable][]) are
delegated to `WhereClause#all`, which itself delegates to `Base.find`.

By merging parameters through `.where`-chaining, this commit supports
deferred fetching:

```ruby
people = Person.where(id: 2).where(name: "david")
  # => GET /people.json?id=2&name=david

people = Person.where(id: 2).all(params: { name: "david" })
  # => GET /people.json?id=2&name=david

people = Person.all(from: "/records.json").where(id: 2)
  # => GET /records.json?id=2
```

[#408]: #408
[Active Record]: https://github.com/rails/rails/blob/main/activerecord/lib/active_record/relation/where_clause.rb
[Enumerable]: https://ruby-doc.org/3.4.1/Enumerable.html

Author: seanpdoyle

lib/active_resource.rb

@@ -49,6 +49,9 @@ module ActiveResource
   autoload :InheritingHash
   autoload :Validations
   autoload :Collection
+  eager_autoload do
+    autoload :WhereClause
+  end
 
   if ActiveSupport::VERSION::STRING >= "7.1"
     def self.deprecator

lib/active_resource/base.rb

@@ -1062,13 +1062,13 @@ def last(*args)
       # This is an alias for find(:all). You can pass in all the same
       # arguments to this method as you can to <tt>find(:all)</tt>
       def all(*args)
-        find(:all, *args)
+        WhereClause.new(self, *args)
       end
 
       def where(clauses = {})
         clauses = sanitize_forbidden_attributes(clauses)
         raise ArgumentError, "expected a clauses Hash, got #{clauses.inspect}" unless clauses.is_a? Hash
-        find(:all, params: clauses)
+        all(params: clauses)
       end
 
 

lib/active_resource/railtie.rb

@@ -5,6 +5,8 @@
 
 module ActiveResource
   class Railtie < Rails::Railtie
+    config.eager_load_namespaces << ActiveResource
+
     config.active_resource = ActiveSupport::OrderedOptions.new
 
     initializer "active_resource.set_configs" do |app|

lib/active_resource/where_clause.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveResource
+  class WhereClause < BasicObject # :nodoc:
+    delegate_missing_to :resources
+
+    def initialize(resource_class, options = {})
+      @resource_class = resource_class
+      @options = options
+      @resources = nil
+      @loaded = false
+    end
+
+    def where(clauses = {})
+      all(params: clauses)
+    end
+
+    def all(options = {})
+      WhereClause.new(@resource_class, @options.deep_merge(options))
+    end
+
+    def load
+      unless @loaded
+        @resources = @resource_class.find(:all, @options)
+        @loaded = true
+      end
+
+      self
+    end
+
+    def reload
+      reset
+      load
+    end
+
+    private
+      def resources
+        load
+        @resources
+      end
+
+      def reset
+        @resources = nil
+        @loaded = false
+      end
+  end
+end

test/cases/finder_test.rb

@@ -63,6 +63,66 @@ def test_where_with_clauses
     assert_kind_of StreetAddress, addresses.first
   end
 
+  def test_where_with_multiple_where_clauses
+    ActiveResource::HttpMock.respond_to.get "/people.json?id=2&name=david", {}, @people_david
+
+    people = Person.where(id: 2).where(name: "david")
+    assert_equal 1, people.size
+    assert_kind_of Person, people.first
+    assert_equal 2, people.first.id
+    assert_equal "David", people.first.name
+  end
+
+  def test_where_chained_from_all
+    ActiveResource::HttpMock.respond_to.get "/records.json?id=2", {}, @people_david
+
+    people = Person.all(from: "/records.json").where(id: 2)
+    assert_equal 1, people.size
+    assert_kind_of Person, people.first
+    assert_equal 2, people.first.id
+    assert_equal "David", people.first.name
+  end
+
+  def test_where_with_chained_into_all
+    ActiveResource::HttpMock.respond_to.get "/records.json?id=2&name=david", {}, @people_david
+
+    people = Person.where(id: 2).all(from: "/records.json", params: { name: "david" })
+    assert_equal 1, people.size
+    assert_kind_of Person, people.first
+    assert_equal 2, people.first.id
+    assert_equal "David", people.first.name
+  end
+
+  def test_where_loading
+    ActiveResource::HttpMock.respond_to.get "/people.json?id=2", {}, @people_david
+    people = Person.where(id: 2)
+
+    assert_changes -> { ActiveResource::HttpMock.requests.count }, from: 0, to: 1 do
+      people.load
+    end
+    assert_no_changes -> { ActiveResource::HttpMock.requests.count }, from: 1 do
+      10.times { people.load }
+    end
+  end
+
+  def test_where_reloading
+    ActiveResource::HttpMock.respond_to.get "/people.json?id=2", {}, @people_david
+    people = Person.where(id: 2)
+
+    assert_changes -> { ActiveResource::HttpMock.requests.count }, from: 0, to: 1 do
+      assert_equal 1, people.size
+    end
+    assert_no_changes -> { ActiveResource::HttpMock.requests.count }, from: 1 do
+      assert_equal 1, people.size
+    end
+    assert_changes -> { ActiveResource::HttpMock.requests.count }, from: 1, to: 2 do
+      people.reload
+    end
+    assert_no_changes -> { ActiveResource::HttpMock.requests.count }, from: 2 do
+      assert_equal 1, people.size
+    end
+  end
+
   def test_where_clause_with_unpermitted_params
     params = StrongParameters.new(person_id: "1")
     assert_raises(ActiveModel::ForbiddenAttributesError) { StreetAddress.where(params) }

test/cases/notifications_test.rb

@@ -15,7 +15,7 @@ def setup
   end
 
   def test_get_request_with_params
-    payload = capture_notifications { Person.where(name: "Matz") }
+    payload = capture_notifications { Person.where(name: "Matz").load }
 
     assert_equal :get, payload[:method]
     assert_equal "http://37s.sunrise.i:3000/people.json?name=Matz", payload[:request_uri]