lhs 6.2.0 → 6.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: caf31c361c00c17b98b17004fc597f5c89bfece9
-  data.tar.gz: 54d832a896d135a0a5a7e84818cffb2aae0adcae
+  metadata.gz: 3e5f67d6a0394eaf9742357631505c14ecf0d308
+  data.tar.gz: 725d43ea3e43f8374e210b5d29a0e54fde5d4a11
 SHA512:
-  metadata.gz: 416221fb3dc29dd39925000e38cb7a8549712eff5a33cb45a74d1a5f3d54a3060a8d384154d526a82bad2e42b59b8ba92d661c5dffac10cdbce5919669c4f082
-  data.tar.gz: c07cf8c431c91fcb11fd17e852032693547526b1b018a527920d28dddac661ec3e576a034e6441092082a0ec0d0e36dba6658207b46262d70a87fffb6370e32e
+  metadata.gz: 5344e79fe480861ae6fe214f9c5fd7f19fb6bfaa754a99dc9afecb2de9efb636b1f80f3b76c7a6e0a23c1efa20e7264a884d8253a7c5c020c23e2b838cb637e8
+  data.tar.gz: b060a234369822f4dd32b945d576cf089e9e56352bd3ced2ee26aeb62c604f48e9febb72fb226c34ed723039ad012efe469ddabe71319264824b95a074726913

data/README.md

@@ -124,6 +124,22 @@ records = Record.blue.available(true)
 The example would fetch records with the following parameters: `{color: blue, visible: true}`.
 ```
 
+## Error handling with chains
+
+One benefit of chains is lazy evaluation. This means they get resolved when data is accessed. This makes it hard to catch errors with normal `rescue` blocks.
+
+To simplify error handling with chains, you can also chain error handlers to be resolved, as part of the chain.
+
+In case no matchin error handler is found the error gets re-raised.
+
+```ruby
+record = Record.where(color: 'blue')
+  .handle(LHC::BadRequest, ->(error){ show_error })
+  .handle(LHC::Unauthorized, ->(error){ authorize })
+```
+
+[List of possible error classes](https://github.com/local-ch/lhc/tree/master/lib/lhc/errors)
+
 ## Find single records
 
 `find` finds a unique record by uniqe identifier (usualy id).

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

@@ -30,6 +30,10 @@ class LHS::Record
       def limit(argument = nil)
         Chain.new(self, Pagination.new(per: argument))
       end
+
+      def handle(error_class, handler)
+        Chain.new(self, ErrorHandling.new(error_class => handler))
+      end
     end
 
     # Link: A part of a chain
@@ -59,6 +63,19 @@ class LHS::Record
     class Pagination < Link
     end
 
+    # ErrorHandling: Catch and resolve errors when resolving the chain
+    class ErrorHandling < Link
+      delegate :call, to: :handler
+
+      def handler
+        @hash.values.first
+      end
+
+      def class
+        @hash.keys.first
+      end
+    end
+
     # A sequence of links
     class Chain
 
@@ -140,6 +157,10 @@ class LHS::Record
         push Pagination.new(per: argument)
       end
 
+      def handle(error_class, handler)
+        push ErrorHandling.new(error_class => handler)
+      end
+
       def find(args)
         @record_class.find(args, chain_options)
       end
@@ -181,6 +202,7 @@ class LHS::Record
           @record_class.request(
             chain_options
               .merge(params: chain_parameters.merge(chain_pagination))
+              .merge(error_handling: chain_error_handling)
           )
         )
       end
@@ -201,6 +223,10 @@ class LHS::Record
         merge_links _links.select { |link| link.is_a? Option }
       end
 
+      def chain_error_handling
+        _links.select { |link| link.is_a? ErrorHandling }
+      end
+
       def chain_pagination
         resolve_pagination _links.select { |link| link.is_a? Pagination }
       end

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

@@ -243,10 +243,25 @@ class LHS::Record
         options ||= {}
         options = options.dup
         endpoint = find_endpoint(options[:params])
-        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
+        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
       end
 
       def url_option_for(item, key = nil)

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = "6.2.0"
+  VERSION = "6.3.0"
 end

data/spec/record/chain_error_handling_spec.rb

@@ -0,0 +1,38 @@
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:handler) { spy('handler') }
+
+  before(:each) do
+    class Record < LHS::Record
+      endpoint 'http://local.ch/v2/records'
+    end
+    stub_request(:get, "http://local.ch/v2/records?color=blue")
+      .to_return(status: 400)
+  end
+
+  it 'allows to chain error handling' do
+    expect {
+      Record.where(color: 'blue').handle(LHC::Error, ->(_error) { handler.handle }).first
+    }.not_to raise_error
+    expect(handler).to have_received(:handle)
+  end
+
+  it 'reraises in case chained error is not matched' do
+    expect {
+      Record.where(color: 'blue').handle(LHC::Conflict, ->(_error) { handler.handle }).first
+    }.to raise_error(LHC::Error)
+    expect(handler).not_to have_received(:handle)
+  end
+
+  it 'calls all the handlers' do
+    expect {
+      Record.where(color: 'blue')
+        .handle(LHC::Error, ->(_error) { handler.handle_1 })
+        .handle(LHC::Error, ->(_error) { handler.handle_2 })
+        .first
+    }.not_to raise_error
+    expect(handler).to have_received(:handle_1)
+    expect(handler).to have_received(:handle_2)
+  end
+end

data/spec/record/includes_spec.rb

@@ -149,25 +149,20 @@ describe LHS::Record do
           }.to_json)
       end
 
+      let(:interceptor) { spy('interceptor') }
+
       before(:each) do
         class Entry < LHS::Record
           endpoint ':datastore/local-entries/:id'
         end
-        class SomeInterceptor < LHC::Interceptor; end
-        LHC.config.interceptors = [SomeInterceptor]
+        LHC.config.interceptors = [interceptor]
       end
 
       it 'uses interceptors for included links from known services' do
-        # rubocop:disable RSpec/InstanceVariable
         stub_feedback_request
         stub_entry_request
-
-        @called = 0
-        allow_any_instance_of(SomeInterceptor).to receive(:before_request) { @called += 1 }
-
         expect(Feedback.includes(:entry).where.first.entry.name).to eq 'Casa Ferlin'
-        expect(@called).to eq 2
-        # rubocop:enable RSpec/InstanceVariable
+        expect(interceptor).to have_received(:before_request).twice
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 6.2.0
+  version: 6.3.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-03 00:00:00.000000000 Z
+date: 2016-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc
@@ -287,6 +287,7 @@ files:
 - spec/record/all_spec.rb
 - spec/record/build_spec.rb
 - spec/record/cast_nested_data_spec.rb
+- spec/record/chain_error_handling_spec.rb
 - spec/record/create_spec.rb
 - spec/record/creation_failed_spec.rb
 - spec/record/definitions_spec.rb
@@ -431,6 +432,7 @@ test_files:
 - spec/record/all_spec.rb
 - spec/record/build_spec.rb
 - spec/record/cast_nested_data_spec.rb
+- spec/record/chain_error_handling_spec.rb
 - spec/record/create_spec.rb
 - spec/record/creation_failed_spec.rb
 - spec/record/definitions_spec.rb