lhs 6.3.1 → 6.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9f38d7e7d79b9099b282d29cdd8c126d9ec2a97
-  data.tar.gz: b01e749df675ef68f1a13923a7d73b2317a58614
+  metadata.gz: 8657e6a2962b433061940b5fbed11d69538233b0
+  data.tar.gz: 588206ef328828b3ffa4ad5a33019f1c8e11f3fa
 SHA512:
-  metadata.gz: ac30a7cd582675b6ba8d7b02748563b64ee6c572858102dcccd9be8db7e70213575dc5a35ded169449d738c78d6a79636df1eb35b0ffe48f068814038c59be93
-  data.tar.gz: 8eb224deb70fa275b5ea13722854ee1d4a971f9ffa509c468aafd74dbf7684edc2a0d37551ff876733d87137b82386cd50c41b18cb9797f07217495b43ca5b68
+  metadata.gz: f18c4f116090fbf214ca85552455b79e282f47f72c60f9484f35b927616c036a8ae732850e98cd7484db0d889444082afa94b69d653dd4e0a1b23b747d5012ee
+  data.tar.gz: f241d8737f772951a5549ad847ff2905e190071254c8af57022c4e5d05d0375254d46b27496d4f1964c47e0cb4a0948557861b440120a71b1efeb86e7decfbe2

data/.rubocop.localch.yml

@@ -19,10 +19,7 @@ AllCops:
 
 Rails:
   Enabled: true
-
-require:
-  - rubocop-rspec
-
+  
 Lint/HandleExceptions:
   Exclude:
     - spec/**/*

data/Gemfile

@@ -8,4 +8,4 @@ gemspec
 # Declare any dependencies that are still in development here instead of in
 # your gemspec. These might include edge Rails or gems from your path or
 # Git. Remember to move these dependencies to your gemspec before releasing
-# your gem to rubygems.org.
+# your gem to rubygems.org.

data/README.md

@@ -8,15 +8,15 @@ LHS uses [LHC](//github.com/local-ch/LHC) for http requests.
 Access data that is provided by an http json service with ease using a LHS::Record.
 
 ```ruby
-class Feedback < LHS::Record
+class Record < LHS::Record
 
-  endpoint ':datastore/v2/content-ads/:campaign_id/feedbacks'
-  endpoint ':datastore/v2/feedbacks'
+  endpoint ':service/v2/records'
+  endpoint ':service/v2/association/:association_id/records'
 
 end
 
-feedback = Feedback.find_by(email: 'somebody@mail.com') #<Feedback>
-feedback.review # "Lunch was great"
+record = Record.find_by(email: 'somebody@mail.com') #<Record>
+record.review # "Lunch was great"
 ```
 
 ## Where to store LHS::Records
@@ -28,12 +28,12 @@ Please store all defined LHS::Records in `app/models` as they are not autoloaded
 You setup a LHS::Record by configuring one or multiple endpoints. You can also add request options for an endpoint (see following example).
 
 ```ruby
-class Feedback < LHS::Record
+class Record < LHS::Record
 
-  endpoint ':datastore/v2/content-ads/:campaign_id/feedbacks'
-  endpoint ':datastore/v2/content-ads/:campaign_id/feedbacks/:id'
-  endpoint ':datastore/v2/feedbacks', cache: true, cache_expires_in: 1.day
-  endpoint ':datastore/v2/feedbacks/:id', cache: true, cache_expires_in: 1.day
+  endpoint ':service/v2/association/:association_id/records'
+  endpoint ':service/v2/association/:association_id/records/:id'
+  endpoint ':service/v2/records', cache: true, cache_expires_in: 1.day
+  endpoint ':service/v2/records/:id', cache: true, cache_expires_in: 1.day
 
 end
 ```
@@ -44,10 +44,10 @@ Please use placeholders when configuring endpoints also for hosts. Otherwise LHS
 If you try to setup a LHS::Record with clashing endpoints it will immediately raise an exception.
 
 ```ruby
-class Feedback < LHS::Record
+class Record < LHS::Record
 
-  endpoint ':datastore/v2/reviews'
-  endpoint ':datastore/v2/feedbacks'
+  endpoint ':service/v2/records'
+  endpoint ':service/v2/something_else'
 
 end
 # raises: Clashing endpoints.
@@ -58,16 +58,16 @@ end
 You can query a service for records by using `where`.
 
 ```ruby
-  Feedback.where(has_reviews: true)
+  Record.where(color: 'blue')
 ```
 
-This uses the `:datastore/v2/feedbacks` endpoint, cause `:campaign_id` was not provided. In addition it would add `?has_reviews=true` to the get parameters.
+This uses the `:service/v2/records` endpoint, cause `:association_id` was not provided. In addition it would add `?color=blue` to the get parameters.
 
 ```ruby
-  Feedback.where(campaign_id: 'fq-a81ngsl1d')
+  Record.where(association_id: 'fq-a81ngsl1d')
 ```
 
-Uses the `:datastore/v2/content-ads/:campaign_id/feedbacks` endpoint.
+Uses the `:service/v2/association/:association_id/records` endpoint.
 
 ## Chaining where statements
 
@@ -149,7 +149,7 @@ If no record is found an error is raised.
 `find` can also be used to find a single uniqe record with parameters:
 
 ```ruby
-  Feedback.find(campaign_id: 123, id: 456)
+  Record.find(association_id: 123, id: 456)
 ```
 
 `find_by` finds the first record matching the specified conditions.
@@ -159,20 +159,37 @@ If no record is found, `nil` is returned.
 `find_by!` raises LHC::NotFound if nothing was found.
 
 ```ruby
-  Feedback.find_by(id: 'z12f-3asm3ngals')
-  Feedback.find_by(id: 'doesntexist') # nil
+  Record.find_by(id: 'z12f-3asm3ngals')
+  Record.find_by(id: 'doesntexist') # nil
 ```
 
 `first` is an alias for finding the first record without parameters.
 
 ```ruby
-  Feedback.first
+  Record.first
 ```
 
 If no record is found, `nil` is returned.
 
 `first!` raises LHC::NotFound if nothing was found.
 
+# Find multiple single records in parallel
+
+In case you want to fetch multiple records by id in parallel, you can also do this with `find`:
+
+```ruby
+Record.find(1, 2, 3)
+```
+
+If you want to inject values for the failing records, that might not have been found, you can inject values for them with error handlers:
+
+```ruby
+data = Record
+  .handle(LHC::Unauthorized, ->(response) { Record.new(name: 'unknown') })
+  .find(1, 2, 3)
+data[1].name # 'unknown'
+```
+
 ## Navigate data
 
 After fetching [single](#find-single-records) or [multiple](#find-multiple-records) records you can navigate the received data with ease.
@@ -219,7 +236,7 @@ You can apply options to the request chain. Those options will be forwarded to t
 `all` fetches all records from the service by doing multiple requests if necessary.
 
 ```ruby
-data = Feedback.all
+data = Record.all
 data.count # 998
 data.length # 998
 ```
@@ -229,26 +246,26 @@ data.length # 998
 `find_each` is a more fine grained way to process single records that are fetched in batches.
 
 ```ruby
-Feedback.find_each(start: 50, batch_size: 20, params: { has_reviews: true }) do |feedback|
+Record.find_each(start: 50, batch_size: 20, params: { has_reviews: true }) do |record|
   # Iterates over each record. Starts with record nr. 50 and fetches 20 records each batch.
-  feedback
-  break if feedback.some_attribute == some_value
+  record
+  break if record.some_attribute == some_value
 end
 ```
 
 `find_in_batches` is used by `find_each` and processes batches.
 ```ruby
-Feedback.find_in_batches(start: 50, batch_size: 20, params: { has_reviews: true }) do |feedbacks|
+Record.find_in_batches(start: 50, batch_size: 20, params: { has_reviews: true }) do |records|
   # Iterates over multiple records (batch size is 20). Starts with record nr. 50 and fetches 20 records each batch.
-  feedbacks
-  break if feedback.some_attribute == some_value
+  records
+  break if records.first.name == some_value
 end
 ```
 
 ## Create records
 
 ```ruby
-  feedback = Feedback.create(
+  record = Record.create(
     recommended: true,
     source_id: 'aaa',
     content_ad_id: '1z-5r1fkaj'
@@ -258,9 +275,9 @@ end
 When creation fails, the object contains errors. It provides them through the `errors` attribute:
 
 ```ruby
-  feedback.errors #<LHS::Errors>
-  feedback.errors.include?(:ratings) # true
-  feedback.errors[:ratings] # ['REQUIRED_PROPERTY_VALUE']
+  record.errors #<LHS::Errors>
+  record.errors.include?(:ratings) # true
+  record.errors[:ratings] # ['REQUIRED_PROPERTY_VALUE']
   record.errors.messages # {:ratings=>["REQUIRED_PROPERTY_VALUE"], :recommended=>["REQUIRED_PROPERTY_VALUE"]}
   record.errors.message # ratings must be set when review or name or review_title is set | The property value is required; it cannot be null, empty, or blank."
 ```
@@ -270,8 +287,8 @@ When creation fails, the object contains errors. It provides them through the `e
 Build and persist new items from scratch are done either with `new` or it's alias `build`.
 
 ```ruby
-  feedback = Feedback.new(recommended: true)
-  feedback.save
+  record = Record.new(recommended: true)
+  record.save
 ```
 
 ## Custom setters and getters
@@ -280,21 +297,21 @@ Sometimes it is the case that you want to have your custom getters and setters a
 The initializer will now use custom setter if one is defined:
 
 ```ruby
-class Feedback < LHS::Record
+class Record < LHS::Record
   def ratings=(ratings)
     _raw[:ratings] = ratings.map { |k, v| { name: k, value: v } }
   end
 end
 
-feedback = Feedback.new(ratings: { quality: 3 }) # <Feedback{:ratings=>[{:name=>:quality, :value=>3}]}>
-feedback.ratings # #<LHS::Data:0x007fc8fa6d4050 ... @_raw=[{:name=>:quality, :value=>3}]>
+record = Record.new(ratings: { quality: 3 }) # <Record{:ratings=>[{:name=>:quality, :value=>3}]}>
+record.ratings # #<LHS::Data:0x007fc8fa6d4050 ... @_raw=[{:name=>:quality, :value=>3}]>
 
 ```
 
 If you have an accompanying getter the whole data manipulation would be internal only.
 
 ```ruby
-class Feedback < LHS::Record
+class Record < LHS::Record
   def ratings=(ratings)
     _raw[:ratings] = ratings.map { |k, v| { name: k, value: v } }
   end
@@ -304,8 +321,8 @@ class Feedback < LHS::Record
   end
 end
 
-feedback = Feedback.new(ratings: { quality: 3 }) # <Feedback{:ratings=>[{:name=>:quality, :value=>3}]}>
-feedback.ratings # {:quality=>3}
+record = Record.new(ratings: { quality: 3 }) # <Record{:ratings=>[{:name=>:quality, :value=>3}]}>
+record.ratings # {:quality=>3}
 
 ```
 
@@ -360,9 +377,9 @@ After include:
 ### Two-Level `includes`
 
 ```ruby
-  # a feedback has a campaign, which has an entry
-  feedbacks = Feedback.includes(campaign: :entry).where(has_reviews: true)
-  feedbacks.first.campaign.entry.name # 'Casa Ferlin'
+  # a record has a association, which has an entry
+  records = Record.includes(association: :entry).where(has_reviews: true)
+  records.first.association.entry.name # 'Casa Ferlin'
 ```
 
 ### Multiple `includes`
@@ -375,7 +392,7 @@ After include:
   claims = Claims.includes([:localch_account, :entry]).where(place_id: 'huU90mB_6vAfUdVz_uDoyA')
 
   # Two-level with array of includes
-  feedbacks = Feedback.includes(campaign: [:entry, :user]).where(has_reviews: true)
+  records = Record.includes(campaign: [:entry, :user]).where(has_reviews: true)
 ```
 
 ### Known LHS::Records are used to request linked resources
@@ -389,15 +406,15 @@ The [Auth Inteceptor](https://github.com/local-ch/lhc-core-interceptors#auth-int
 ```ruby
 class Favorite < LHS::Record
 
-  endpoint ':datastore/:user_id/favorites', auth: { basic: { username: 'steve', password: 'can' } }
-  endpoint ':datastore/:user_id/favorites/:id', auth: { basic: { username: 'steve', password: 'can' } }
+  endpoint ':service/:user_id/favorites', auth: { basic: { username: 'steve', password: 'can' } }
+  endpoint ':service/:user_id/favorites/:id', auth: { basic: { username: 'steve', password: 'can' } }
 
 end
 
 class Place < LHS::Record
 
-  endpoint ':datastore/v2/places', auth: { basic: { username: 'steve', password: 'can' } }
-  endpoint ':datastore/v2/places/:id', auth: { basic: { username: 'steve', password: 'can' } }
+  endpoint ':service/v2/places', auth: { basic: { username: 'steve', password: 'can' } }
+  endpoint ':service/v2/places/:id', auth: { basic: { username: 'steve', password: 'can' } }
 
 end
 
@@ -421,7 +438,7 @@ To influence how data is accessed/provied, you can use mappings to either map de
 
 ```ruby
 class LocalEntry < LHS::Record
-  endpoint ':datastore/v2/local-entries'
+  endpoint ':service/v2/local-entries'
 
   def name
     addresses.first.business.identities.first.name
@@ -436,7 +453,7 @@ Nested records (in nested data) are automaticaly casted when the href matches an
 
 ```ruby
 class Place < LHS::Record
-  endpoint ':datastore/v2/places'
+  endpoint ':service/v2/places'
 
   def name
     addresses.first.business.identities.first.name
@@ -444,7 +461,7 @@ class Place < LHS::Record
 end
 
 class Favorite < LHS::Record
-  endpoint ':datastore/v2/favorites'
+  endpoint ':service/v2/favorites'
 end
 
 favorite = Favorite.includes(:place).find(1)
@@ -458,7 +475,7 @@ If automatic-detection of nested records does not work, make sure your LHS::Reco
 You can change attributes of LHS::Records:
 
 ```ruby
-  record = Feedback.find(id: 'z12f-3asm3ngals')
+  record = Record.find(id: 'z12f-3asm3ngals')
   rcord.recommended = false
 ```
 
@@ -467,9 +484,9 @@ You can change attributes of LHS::Records:
 You can persist changes with `save`. `save` will return `false` if persisting fails. `save!` instead will raise an exception.
 
 ```ruby
-  feedback = Feedback.find('1z-5r1fkaj')
-  feedback.recommended = false
-  feedback.save
+  record = Record.find('1z-5r1fkaj')
+  record.recommended = false
+  record.save
 ```
 
 ## Update
@@ -479,8 +496,8 @@ You can persist changes with `save`. `save` will return `false` if persisting fa
 `update` always updates the data of the local object first, before it tries to sync with an endpoint. So even if persisting fails, the local object is updated.
 
 ```ruby
-feedback = Feedback.find('1z-5r1fkaj')
-feedback.update(recommended: false)
+record = Record.find('1z-5r1fkaj')
+record.update(recommended: false)
 ```
 
 ## Destroy
@@ -488,8 +505,8 @@ feedback.update(recommended: false)
 You can delete records remotely by calling `destroy` on an LHS::Record.
 
 ```ruby
-  feedback = Feedback.find('1z-5r1fkaj')
-  feedback.destroy
+  record = Record.find('1z-5r1fkaj')
+  record.destroy
 ```
 
 ## Validation
@@ -500,7 +517,7 @@ The specific endpoint has to support validations with the `persist=false` parame
 
 ```ruby
 class User < LHS::Record
-  endpoint ':datastore/v2/users', validates: true
+  endpoint ':service/v2/users', validates: true
 end
 
 user = User.build(email: 'im not an email address')
@@ -513,7 +530,7 @@ In case endpoints define other parameter names for validation like `publish` you
 
 ```ruby
 class User < LHS::Record
-  endpoint ':datastore/v2/users', validates: 'publish'
+  endpoint ':service/v2/users', validates: 'publish'
 end
 ```
 
@@ -595,7 +612,7 @@ You can use chainable pagination in combination with query chains:
 
 ```ruby
   class Record < LHS::Record
-    endpoint ':datastore/records'
+    endpoint ':service/records'
   end
   Record.page(3).per(20).where(color: 'blue')
   # /records?offset=40&limit=20&color=blue
@@ -605,7 +622,7 @@ The applied pagination strategy depends on the actual configured pagination, so
 
 ```ruby
   class Record < LHS::Record
-    endpoint ':datastore/records'
+    endpoint ':service/records'
     configuration pagination_strategy: 'page'
   end
   Record.page(3).per(20).where(color: 'blue')
@@ -614,7 +631,7 @@ The applied pagination strategy depends on the actual configured pagination, so
 
 ```ruby
   class Record < LHS::Record
-    endpoint ':datastore/records'
+    endpoint ':service/records'
     configuration pagination_strategy: 'start'
   end
   Record.page(3).per(20).where(color: 'blue')

data/lhs.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
   s.requirements << 'Ruby >= 2.0.0'
   s.required_ruby_version = '>= 2.0.0'
 
-  s.add_dependency 'lhc', '>= 3.5.2'
+  s.add_dependency 'lhc', '>= 3.6.0'
   s.add_dependency 'lhc-core-interceptors', '>= 2.0.1'
 
   s.add_development_dependency 'rspec-rails', '>= 3.0.0'

data/lib/lhs/concerns/record/chainable.rb

@@ -161,8 +161,10 @@ class LHS::Record
         push ErrorHandling.new(error_class => handler)
       end
 
-      def find(args)
-        @record_class.find(args, chain_options)
+      def find(*args)
+        options = chain_options
+        options = options.merge(error_handler: chain_error_handler) if chain_error_handler.any?
+        @record_class.find(*args.push(options))
       end
 
       def find_by(params = {})
@@ -198,12 +200,11 @@ class LHS::Record
       end
 
       def resolve
+        options = chain_options
+        options = options.merge(params: chain_parameters.merge(chain_pagination))
+        options = options.merge(error_handler: chain_error_handler) if chain_error_handler.any?
         @resolved ||= @record_class.new(
-          @record_class.request(
-            chain_options
-              .merge(params: chain_parameters.merge(chain_pagination))
-              .merge(error_handling: chain_error_handling)
-          )
+          @record_class.request(options)
         )
       end
 
@@ -223,7 +224,7 @@ class LHS::Record
         merge_links _links.select { |link| link.is_a? Option }
       end
 
-      def chain_error_handling
+      def chain_error_handler
         _links.select { |link| link.is_a? ErrorHandling }
       end
 

data/lib/lhs/concerns/record/find.rb

@@ -7,22 +7,36 @@ class LHS::Record
 
     module ClassMethods
       # Find a single uniqe record
-      def find(args, options = nil)
+      def find(*args)
+        args, options = process_args(args)
         data =
-          if args.is_a? Hash
+          if args.is_a? Array
+            find_in_parallel(args, options)
+          elsif args.is_a? Hash
             find_with_parameters(args, options)
           else
             find_by_id(args, options)
           end
-        return data unless data._record
+        return data if data.is_a?(Array) || !data._record
         data._record.new(data)
       end
 
       private
 
-      def find_with_parameters(params, options = {})
-        options ||= {}
-        data = request(options.merge(params: params))
+      def process_args(args)
+        if args.length == 1
+          args = args.first
+        elsif args.length == 2 && args.last.is_a?(Hash)
+          options = args.pop if args.last.is_a?(Hash)
+          args = args.first
+        elsif args.last.is_a?(Hash)
+          options = args.pop
+        end
+        options ||= nil
+        [args, options]
+      end
+
+      def get_unique_item!(data)
         if data._proxy.is_a?(LHS::Collection)
           fail LHC::NotFound.new('Requested unique item. Multiple were found.', data._request.response) if data.length > 1
           data.first || fail(LHC::NotFound.new('No item was found.', data._request.response))
@@ -31,9 +45,26 @@ class LHS::Record
         end
       end
 
-      def find_by_id(id, options = {})
-        options ||= {}
-        request(options.merge(params: { id: id }))
+      def find_with_parameters(args, options = {})
+        data = request(request_options(args, options))
+        get_unique_item!(data)
+      end
+
+      def find_by_id(args, options = {})
+        request(request_options(args, options))
+      end
+
+      def find_in_parallel(args, options)
+        options = args.map { |argument| request_options(argument, options) }
+        request(options)
+      end
+
+      def request_options(args, options)
+        if args.is_a? Hash
+          (options || {}).merge(params: args)
+        else
+          (options || {}).merge(params: { id: args })
+        end
       end
     end
   end

data/lib/lhs/concerns/record/request.rb

@@ -7,6 +7,7 @@ class LHS::Record
 
     module ClassMethods
       def request(options)
+        options ||= {}
         if options.is_a? Array
           multiple_requests(options)
         else
@@ -181,12 +182,12 @@ class LHS::Record
           next unless option.present?
           process_options(option, find_endpoint(option[:params]))
         end
-        data = LHC.request(options.compact).map { |response| LHS::Data.new(response.body, nil, self, response.request) }
-        data = restore_with_nils(data, locate_nils(options)) # nil objects in data provide location information for mapping
-        unless data.empty?
-          data = LHS::Data.new(data, nil, self)
-          handle_includes(including, data, referencing) if including
+        data = LHC.request(options.compact).map do |response|
+          LHS::Data.new(response.body, nil, self, response.request)
         end
+        data = restore_with_nils(data, locate_nils(options)) # nil objects in data provide location information for mapping
+        data = LHS::Data.new(data, nil, self)
+        handle_includes(including, data, referencing) if including && !data.empty?
         data
       end
 
@@ -217,6 +218,7 @@ class LHS::Record
       # Merge explicit params and take configured endpoints options as base
       def process_options(options, endpoint)
         options[:params].deep_symbolize_keys! if options[:params]
+        options[:error_handler] = merge_error_handlers(options[:error_handler]) if options[:error_handler]
         options = (endpoint.options || {}).merge(options)
         options[:url] = compute_url!(options[:params]) unless options.key?(:url)
         merge_explicit_params!(options[:params])
@@ -224,6 +226,23 @@ class LHS::Record
         options
       end
 
+      # LHC supports only one error handler, merge all error handlers to one
+      # and reraise
+      def merge_error_handlers(handlers)
+        lambda do |response|
+          return_data = nil
+          error_class = LHC::Error.find(response)
+          error = error_class.new(error_class, response)
+          handlers = handlers.to_a.select { |error_handler| error.is_a? error_handler.class }
+          fail(error) unless handlers.any?
+          handlers.each do |handler|
+            handlers_return = handler.call(response)
+            return_data = handlers_return if handlers_return.present?
+          end
+          return return_data
+        end
+      end
+
       def record_for_options(options)
         records = []
         if options.is_a?(Array)
@@ -243,25 +262,10 @@ class LHS::Record
         options ||= {}
         options = options.dup
         endpoint = find_endpoint(options[:params])
-        error_handling = options.delete(:error_handling)
-        begin
-          response = LHC.request(process_options(options, endpoint))
-          data = LHS::Data.new(response.body, nil, self, response.request, endpoint)
-          handle_includes(including, data, referencing) if including
-          data
-        rescue => error
-          handle_error(error, error_handling)
-          nil
-        end
-      end
-
-      def handle_error(error, error_handling)
-        error_handlers = (error_handling || []).select { |error_handler| error.is_a? error_handler.class }
-        if error_handlers.any?
-          error_handlers.each { |handler| handler.call(error) }
-        else
-          fail error
-        end
+        response = LHC.request(process_options(options, endpoint))
+        data = LHS::Data.new(response.body, nil, self, response.request, endpoint)
+        handle_includes(including, data, referencing) if including
+        data
       end
 
       def url_option_for(item, key = nil)

data/lib/lhs/item.rb

@@ -26,8 +26,10 @@ class LHS::Item < LHS::Proxy
     return set(name, args.try(&:first)) if name.to_s[/=$/]
     name = args.first if name == :[]
     value = _data._raw[name.to_s]
-    value = _data._raw[name.to_sym] if value.nil?
-    value = _data._raw[name.to_s.classify.to_sym] if value.nil?
+    if value.nil? && _data._raw.present?
+      value = _data._raw[name.to_sym]
+      value ||= _data._raw[name.to_s.classify.to_sym]
+    end
     if value.is_a?(Hash)
       handle_hash(value)
     elsif value.is_a?(Array)

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = "6.3.1"
+  VERSION = "6.4.0"
 end

data/spec/record/find_in_parallel_spec.rb

@@ -0,0 +1,39 @@
+require 'rails_helper'
+
+describe LHS::Record do
+  before(:each) do
+    class Record < LHS::Record
+      endpoint 'http://datastore/records/:id'
+    end
+  end
+
+  context 'find in parallel' do
+    before(:each) do
+      stub_request(:get, "http://datastore/records/1").to_return(status: 200, body: { id: 1 }.to_json)
+      stub_request(:get, "http://datastore/records/3").to_return(status: 200, body: { id: 3 }.to_json)
+    end
+
+    it 'finds records in parallel' do
+      stub_request(:get, "http://datastore/records/2").to_return(status: 200, body: { id: 2 }.to_json)
+      allow(Record).to receive(:request).and_call_original
+      data = Record.find([1, 2, 3])
+      expect(Record).to have_received(:request).once
+      expect(data[0].id).to eq 1
+      expect(data[1].id).to eq 2
+      expect(data[2].id).to eq 3
+    end
+
+    it 'raises an exeption if one of the parallel request fails' do
+      stub_request(:get, "http://datastore/records/2").to_return(status: 401)
+      expect(-> { Record.find([1, 2, 3]) }).to raise_error(LHC::Unauthorized)
+    end
+
+    it 'applies error handlers from the chain and returns whatever the error handler returns' do
+      stub_request(:get, "http://datastore/records/2").to_return(status: 401)
+      data = Record
+        .handle(LHC::Unauthorized, ->(_response) { Record.new(name: 'unknown') })
+        .find(1, 2, 3)
+      expect(data[1].name).to eq 'unknown'
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 6.3.1
+  version: 6.4.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-11 00:00:00.000000000 Z
+date: 2016-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.2
+        version: 3.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.2
+        version: 3.6.0
 - !ruby/object:Gem::Dependency
   name: lhc-core-interceptors
   requirement: !ruby/object:Gem::Requirement
@@ -298,6 +298,7 @@ files:
 - spec/record/find_by_spec.rb
 - spec/record/find_each_spec.rb
 - spec/record/find_in_batches_spec.rb
+- spec/record/find_in_parallel_spec.rb
 - spec/record/find_spec.rb
 - spec/record/first_spec.rb
 - spec/record/immutable_chains_spec.rb
@@ -351,7 +352,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - Ruby >= 2.0.0
 rubyforge_project: 
-rubygems_version: 2.6.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Rails gem providing an easy, active-record-like interface for http json services
@@ -443,6 +444,7 @@ test_files:
 - spec/record/find_by_spec.rb
 - spec/record/find_each_spec.rb
 - spec/record/find_in_batches_spec.rb
+- spec/record/find_in_parallel_spec.rb
 - spec/record/find_spec.rb
 - spec/record/first_spec.rb
 - spec/record/immutable_chains_spec.rb