flexirest 1.11.0 → 1.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3c99c9dcb4b2b2d6b4992a53d138877f251f0810bb94dc11faf9d9e1b89f9cb
-  data.tar.gz: 22554cafc10d12337c1511828ab27471dbadf36de4e211c5383eae96c4fb4c34
+  metadata.gz: '069a842d7b7b6db2e2aa7cff28191a02d70e0ebe3bc6f49aadf569b8006b7cc4'
+  data.tar.gz: 9db8212da8ed8698bc4a1d48137fe2e0e9ce8d75c94366d72fe1f78d986855e0
 SHA512:
-  metadata.gz: 3cf855f9fbc7d4f213a19840e11cfa9b816de9b1a0750726538f288f559ec150c7a05a4ae8b63297e8aedcf8002103e2e4ae275cb497793144c83aebc7f7577e
-  data.tar.gz: e1a5b90ace51f341a340e5ed32f5c8afc30f2784a38cf7281c621157a8b1233da9b81180ed6a5dc0694f4ac72933793b9e47dcf01d9389583b02bdd7dc3aefbd
+  metadata.gz: fb73957659a29bb35ab8f08b9127e32f36e733e9a37830c09e42f221774531c18edbbb4767bccd1fcc4713a938fb9c195daa4863af39c128b312d582b6245fc2
+  data.tar.gz: b9e91c14da366548a6a618eae2d634ad26cf60e1ed20d957b577bb4e1e777c32eea594ebc2a37990f61eeb59c41e34912ed591477f0a80005bfc7435dac7aa3d

data/.github/workflows/build.yml

@@ -24,10 +24,7 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - name: Set up Ruby
-    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
-    # change this to (see https://github.com/ruby/setup-ruby#versioning):
-    # uses: ruby/setup-ruby@v1
-      uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
+      uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby-version }}
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.11.2
+
+Bugfix:
+
+- When a model had multiple lazy loaders specified, they would all have their object class set to the first object class that was found when iterating over them. (thanks to Joshua Samberg for the PR)
+
+## 1.11.1
+
+Enhancement:
+
+- Add automatic expiry of cached responses based on the Expires header if set (thanks to Romain Gisiger for the issue and PR)
+
 ## 1.11.0
 
 Major change:

data/docs/associations.md

@@ -86,37 +86,56 @@ When the `:array` option includes an attribute, it is assumed the values were re
 
 ## Type 2 - Lazy Loading From Other URLs
 
-When mapping the method, passing a list of attributes will cause any requests for those attributes to mapped to the URLs given in their responses. The response for the attribute may be one of the following:
+If the call for an attribute should
 
-```ruby
-"attribute" : "URL"
-"attribute" : ["URL", "URL"]
-"attribute" : { "url" : "URL"}
-"attribute" : { "href" : "URL"}
-"attribute" : { "something" : "URL"}
-```
-
-The difference between the last 3 examples is that a key of `url` or `href` signifies it's a single object that is lazy loaded from the value specified. Any other keys assume that it's a nested set of URLs (like in the array situation, but accessible via the keys - e.g. object.attribute.something in the above example).
++ Use the value held within the specified attribute as a URL(s) from which to load the associated resource(s)
++ **THEN**, create an instance of your API object from the result
++ **THEN**, call subsequent chained methods on that instance
 
-It is required that the URL is a complete URL including a protocol starting with "http". To configure this use code like:
+you can specify this when mapping the method by passing attribtues to the `:lazy` option.
 
 ```ruby
+class Book < Flexirest::Base
+  get :find, "/books/:name"
+end
+
 class Person < Flexirest::Base
-  get :find, "/people/:id", :lazy => [:orders, :refunds]
+  get :find, "/people/:id", :lazy => { books: Book }
 end
 ```
 
-And use it like this:
+Use it like this:
 
 ```ruby
 # Makes a call to /people/1
 @person = Person.find(1)
 
-# Makes a call to the first URL found in the "books":[...] array in the article response
-# only makes the HTTP request when first used though
+# Lazily makes a call to the first URL found in the "books":[...] array in the Person.find response
+# - Only makes the HTTP request when first used
+# - Instantiates a Book object from the response and then accesses its "name" property
 @person.books.first.name
 ```
 
+### URLs in API responses
+To provide a URL(s) for lazy loading an attribute, the API response may contain one of the following for the attribute (**`book`** or **`books`** is the attribute in all examples below):
+
+```ruby
+# all of the following will lazy load a single object from the specified URL
+"book" : "https://example.com/books/1"
+# or
+"book" : { "url" : "https://example.com/books/1"}
+# or
+"book" : { "href" : "https://example.com/books/1"}
+
+# books will be an array whose elements will be lazy loaded one-by-one, from the URL in the corresponding array position, whenever each element is first accessed
+"books" : ["https://example.com/books/1", "https://example.com/books/2"]
+
+# book will be an object where the values will be lazy loaded one-by-one, from the URL in the corresponding key, whenever each key is first accessed (e.g. the first time object.book.author is accessed)
+"book" : { "author" : "https://example.com/author/1"}
+```
+
+It is required that each URL is a complete URL including a protocol starting with `http`.
+
 ## Type 3 - HAL Auto-loaded Resources
 
 You don't need to define lazy attributes if they are defined using [HAL](http://stateless.co/hal_specification.html) (with an optional embedded representation). If your resource has an `_links` item (and optionally an `_embedded` item) then it will automatically treat the linked resources (with the `_embedded` cache) as if they were defined using `:lazy` as per type 2 above.

data/flexirest.gemspec

@@ -36,6 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'faraday-typhoeus'
   spec.add_development_dependency 'activemodel'
   spec.add_development_dependency 'rest-client'
+  spec.add_development_dependency 'timecop'
 
   spec.add_runtime_dependency "mime-types"
   spec.add_runtime_dependency "multi_json"

data/lib/flexirest/caching.rb

@@ -74,7 +74,14 @@ module Flexirest
           cached_response.etag = "#{headers[:etag]}" if headers[:etag]
           cached_response.expires = Time.parse(headers[:expires]) rescue nil if headers[:expires]
           if cached_response.etag.present? || cached_response.expires
-            cache_store.write(key, Marshal.dump(cached_response), {})
+            options = {}
+            if cached_response.expires.present?
+              exp_in_seconds = cached_response.expires.utc - Time.now.utc
+              return unless exp_in_seconds.positive?
+
+              options[:expires_in] = exp_in_seconds
+            end
+            cache_store.write(key, Marshal.dump(cached_response), options)
           end
         end
       end

data/lib/flexirest/request.rb

@@ -713,12 +713,13 @@ module Flexirest
       @method[:options][:has_many] ||= {}
       name = name.to_sym rescue nil
       if @method[:options][:has_many][name]
-        overridden_name = name
+        parent_name = name
         object = @method[:options][:has_many][name].new
       elsif @method[:options][:has_one][name]
-        overridden_name = name
+        parent_name = name
         object = @method[:options][:has_one][name].new
       else
+        parent_name = nil
         object = create_object_instance
       end
 
@@ -735,8 +736,7 @@ module Flexirest
         else
           k = k.to_sym
         end
-        overridden_name = select_name(k, overridden_name)
-        set_corresponding_value(v, k, object, overridden_name)
+        set_corresponding_value(v, k, object, select_name(k, parent_name))
       end
       object.clean! unless object_is_class?
 

data/lib/flexirest/version.rb

@@ -1,3 +1,3 @@
 module Flexirest
-  VERSION = "1.11.0"
+  VERSION = "1.11.2"
 end

data/spec/lib/caching_spec.rb

@@ -72,28 +72,21 @@ describe Flexirest::Caching do
     end
 
     it "should use a custom cache store if a valid one is manually set" do
-      class CachingExampleCacheStore1
-        def read(key) ; end
-        def write(key, value, options={}) ; end
-        def fetch(key, &block) ; end
-      end
+      class CachingExampleCacheStore1 < ActiveSupport::Cache::MemoryStore; end
       cache_store = CachingExampleCacheStore1.new
       Flexirest::Base.cache_store = cache_store
       expect(Flexirest::Base.cache_store).to eq(cache_store)
     end
 
     it "should error if you try to use a custom cache store that doesn't match the required interface" do
-      class CachingExampleCacheStore2
-        def write(key, value, options={}) ; end
-        def fetch(key, &block) ; end
+      class CachingExampleCacheStore2 < ActiveSupport::Cache::MemoryStore
+        undef_method :read
       end
-      class CachingExampleCacheStore3
-        def read(key) ; end
-        def fetch(key, &block) ; end
+      class CachingExampleCacheStore3 < ActiveSupport::Cache::MemoryStore
+        undef_method :write
       end
-      class CachingExampleCacheStore4
-        def read(key) ; end
-        def write(key, value, options={}) ; end
+      class CachingExampleCacheStore4 < ActiveSupport::Cache::MemoryStore
+        undef_method :fetch
       end
 
       expect{ Flexirest::Base.cache_store = CachingExampleCacheStore2.new }.to raise_error(Flexirest::InvalidCacheStoreException)
@@ -109,11 +102,7 @@ describe Flexirest::Caching do
   context "Reading/writing to the cache" do
     before :each do
       Object.send(:remove_const, :CachingExampleCacheStore5) if defined?(CachingExampleCacheStore5)
-      class CachingExampleCacheStore5
-        def read(key) ; end
-        def write(key, value, options={}) ; end
-        def fetch(key, &block) ; end
-      end
+      class CachingExampleCacheStore5 < ActiveSupport::Cache::MemoryStore; end
 
       class Person < Flexirest::Base
         perform_caching true
@@ -122,7 +111,7 @@ describe Flexirest::Caching do
         put :save_all, "/"
       end
 
-      Person.cache_store = CachingExampleCacheStore5.new
+      Person.cache_store = CachingExampleCacheStore5.new({ expires_in: 1.day.to_i }) # default cache expiration
 
       @etag = "6527914a91e0c5769f6de281f25bd891"
       @cached_object = Person.new(first_name:"Johnny")
@@ -173,7 +162,7 @@ describe Flexirest::Caching do
       expect(result.first_name).to eq new_name
     end
 
-    it "should read from the cache store, and not call the server if there's a hard expiry" do
+    it "should read from the cache store, and not call the server if there's a hard expiry not passed yet" do
       cached_response = Flexirest::CachedResponse.new(
         status:200,
         result:@cached_object,
@@ -184,6 +173,18 @@ describe Flexirest::Caching do
       expect(ret.first_name).to eq("Johnny")
     end
 
+    it "should not read from the cache store, and call the server if there's a hard expiry already passed" do
+      cached_response = Flexirest::CachedResponse.new(
+        status:200,
+        result:@cached_object,
+        expires:Time.now + 30)
+      Timecop.travel(Time.now + 60)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
+      expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, body:"{\"result\":true}", response_headers:{})))
+      ret = Person.all
+      Timecop.return
+    end
+
     it "cache read objects shouldn't be marked as changed" do
       cached_response = Flexirest::CachedResponse.new(
         status:200,
@@ -208,7 +209,7 @@ describe Flexirest::Caching do
       expect(ret.first_name).to eq("Johnny")
     end
 
-    it "should restore a result iterator from the cache store, if there's a hard expiry" do
+    it "should restore a result iterator from the cache store, if there's a hard expiry not passed yet" do
       class CachingExample3 < Flexirest::Base ; end
       object = Flexirest::ResultIterator.new(double(status: 200))
       object << CachingExample3.new(first_name:"Johnny")
@@ -226,6 +227,26 @@ describe Flexirest::Caching do
       expect(ret._status).to eq(200)
     end
 
+    it "should not restore a result iterator from the cache store, if there's a hard expiry already passed" do
+      class CachingExample3 < Flexirest::Base ; end
+      object = Flexirest::ResultIterator.new(double(status: 200))
+      object << CachingExample3.new(first_name:"Johnny")
+      object << CachingExample3.new(first_name:"Billy")
+      etag = "6527914a91e0c5769f6de281f25bd891"
+      cached_response = Flexirest::CachedResponse.new(
+        status:200,
+        result:object,
+        etag:etag,
+        expires:Time.now + 30)
+      Timecop.travel(Time.now + 60)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
+      expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, body:"[{\"first_name\":\"Billy\"}]", response_headers:{})))
+      ret = Person.all
+      expect(ret.first.first_name).to eq("Billy")
+      expect(ret._status).to eq(200)
+      Timecop.return
+    end
+
     it "should not write the response to the cache unless it has caching headers" do
       expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
       expect_any_instance_of(CachingExampleCacheStore5).not_to receive(:write)
@@ -233,9 +254,9 @@ describe Flexirest::Caching do
       Person.all
     end
 
-    it "should write the response to the cache if there's an etag" do
+    it "should write the response to the cache without expires_in option if there's an etag" do
       expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
-      expect_any_instance_of(CachingExampleCacheStore5).to receive(:write).once.with("Person:/", an_instance_of(String), {})
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:write).once.with("Person:/", an_instance_of(String), hash_excluding(:expires_in))
       expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, body:"{\"result\":true}", response_headers:{etag:"1234567890"})))
       Person.perform_caching true
       Person.all
@@ -264,14 +285,22 @@ describe Flexirest::Caching do
       end
     end
 
-    it "should write the response to the cache if there's a hard expiry" do
+    it "should write the response to the cache with expires_in option if there's a hard expiry in the future" do
       expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
-      expect_any_instance_of(CachingExampleCacheStore5).to receive(:write).once.with("Person:/", an_instance_of(String), an_instance_of(Hash))
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:write).once.with("Person:/", an_instance_of(String), hash_including(:expires_in))
       expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, body:"{\"result\":true}", response_headers:{expires:(Time.now + 30).rfc822})))
       Person.perform_caching = true
       Person.all
     end
 
+    it "should not write the response to the cache if there's a hard expiry in the past" do
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
+      expect_any_instance_of(CachingExampleCacheStore5).not_to receive(:write)
+      expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, body:"{\"result\":true}", response_headers:{expires:(Time.now - 10).rfc822})))
+      Person.perform_caching = true
+      Person.all
+    end
+
     it "should not write the response to the cache if there's an invalid expiry" do
       expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
       expect_any_instance_of(CachingExampleCacheStore5).to_not receive(:write).once.with("Person:/", an_instance_of(String), an_instance_of(Hash))

data/spec/lib/lazy_association_loader_spec.rb

@@ -12,6 +12,24 @@ class YearExample < Flexirest::Base
   get :find, "/year/:id", lazy: { months: MonthExample }, fake: "{\"months\": [\"http://www.example.com/months/1\"] }"
 end
 
+class CenturyExample < Flexirest::Base
+  base_url "http://www.example.com"
+
+  get :find, "century/:id"
+end
+
+class DecadeExample < Flexirest::Base
+  base_url "http://www.example.com"
+
+  get :find, "/decade/:id", lazy: { years: YearExample, century: CenturyExample }, fake: %Q{
+    {
+      "years": ["http://www.example.com/years/1"],
+      "century": "http://www.example.com/century/1"
+    }
+  }
+end
+
+
 describe Flexirest::LazyAssociationLoader do
   let(:url1) { "http://www.example.com/some/url" }
   let(:url2) { "http://www.example.com/some/other" }
@@ -132,4 +150,13 @@ describe Flexirest::LazyAssociationLoader do
     association = YearExample.find(1)
     expect(association.months.instance_variable_get('@request').instance_variable_get('@object').class).to eq(MonthExample)
   end
+
+  context "has multiple associations" do
+    it "should correctly map each association name to the class specified for that association in the 'lazy' declaration " do
+      association = DecadeExample.find(1)
+      expect(association.years.instance_variable_get('@request').instance_variable_get('@object').class).to eq(YearExample)
+      expect(association.century.instance_variable_get('@request').instance_variable_get('@object').class).to eq(CenturyExample)
+    end
+  end
+
 end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ require 'simplecov'
 require 'flexirest'
 require "ostruct"
 require 'webmock/rspec'
+require 'timecop'
 
 if ENV["JENKINS"]
   require 'simplecov-rcov'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flexirest
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.11.2
 platform: ruby
 authors:
 - Andy Jeffries
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-03 00:00:00.000000000 Z
+date: 2023-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -178,6 +178,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mime-types
   requirement: !ruby/object:Gem::Requirement
@@ -393,7 +407,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: This gem is for accessing REST services in a flexible way.  ActiveResource