lhs 14.1.1 → 14.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 410e4fb105669f81e2f5d2597bfce8e70067ce22
-  data.tar.gz: 242bab7a1495a4b232b1ef25f99eef6f307c657d
+  metadata.gz: e02a2c879954de6557dc437da50cddf53fbcb054
+  data.tar.gz: cf5c0881ae67770796703f483d3cdd3939a47425
 SHA512:
-  metadata.gz: b36a19677807863f4dafee0c9bc939b89ba922f76b1493610746b0c54a06dc8aa29e3fbed82c4992e1c72591e605c36fc9640680e316294cb733a2b578940ab6
-  data.tar.gz: 410dbbf82a0172b9604dc2c5ca91a5352a8b095f715a8c9347aff46e51a5699d761d316c0e4c89887924d1d27ef6ad820593b16ca095b780ed4ad8eae66a5efc
+  metadata.gz: 5309110a6cc3d2a6afae3562c1297cc25a85959c5bdc3b4b3b28742c0d515aca862dcbf5572691631318818ad7b1cae1c1e7db9b2f8eb9e92c50e1a364c8ff4d
+  data.tar.gz: 8bae589cb78ec9f43df90df959aa113e81c9000814ae5d8157e96311e1912fbd169a475dd75a80431145769ca8fe961f1dc447beca8797d1b812fe905da7fd6c

data/README.md

@@ -755,7 +755,7 @@ unless user.valid?
   fail(user.errors[:email])
 end
 
-user.errors #<LHS::Errors::Base>
+user.errors #<LHS::Problems::Errors>
 user.errors.include?(:email) # true
 user.errors[:email] # ['REQUIRED_PROPERTY_VALUE']
 user.errors.messages # {:email=>["REQUIRED_PROPERTY_VALUE"]}
@@ -844,6 +844,35 @@ lhs.errors.fallback_message
 ### Know issue with `ActiveModel::Validations`
 If you are using `ActiveModel::Validations` and add errors to the LHS::Record instance - as described above - then those errors will be overwritten by the errors from `ActiveModel::Validations` when using `save`  or `valid?`. [Open issue](https://github.com/local-ch/lhs/issues/159)
 
+### Non blocking validation errors, so called warnings
+
+In some cases, you need non blocking meta information about potential problems with the created record, so called warnings.
+
+If the API endpoint implements warnings:
+
+```
+  {
+    field_warnings: [{
+      code: 'WILL_BE_RESIZED',
+      path: ['place', 'photos', 0],
+      message: 'The image will be resized.'
+    }
+  }
+```
+
+LHS makes those warnings available:
+
+```ruby
+  presence = Presence.options(params: { synchronize: false }).create(
+    place: { href: 'http://storage/places/1' }
+  )
+
+  presence.warnings.any? # true
+  presence.place.photos[0].warnings.messages.first # 'The photos will be resized'
+```
+
+Warnings behave like [Validation Errors](#Validation) and implements the same interfaces and methods.
+
 ## Pagination
 
 LHS supports paginated APIs and it also supports various pagination strategies and by providing configuration possibilities.

data/lib/lhs.rb

@@ -15,12 +15,6 @@ module LHS
     'lhs/data'
   autoload :Endpoint,
     'lhs/endpoint'
-  autoload :Errors,
-    'lhs/errors/base'
-  module Errors
-    autoload :Nested,
-      'lhs/errors/nested'
-  end
   autoload :Inspect,
     'lhs/concerns/inspect'
   autoload :Item,
@@ -35,6 +29,26 @@ module LHS
     autoload :Start,
       'lhs/pagination/start'
   end
+  autoload :Problems,
+    'lhs/problems/base'
+  module Problems
+    autoload :Base,
+      'lhs/problems/base'
+    autoload :Errors,
+      'lhs/problems/errors'
+    autoload :Nested,
+      'lhs/problems/nested/base'
+    module Nested
+      autoload :Base,
+      'lhs/problems/nested/base'
+      autoload :Errors,
+      'lhs/problems/nested/errors'
+      autoload :Warnings,
+      'lhs/problems/nested/warnings'
+    end
+    autoload :Warnings,
+      'lhs/problems/warnings'
+  end
   autoload :Proxy,
     'lhs/proxy'
   autoload :Record,

data/lib/lhs/collection.rb

@@ -56,7 +56,7 @@ class LHS::Collection < LHS::Proxy
       record = LHS::Record.for_url(value[:href]) if value.is_a?(Hash) && value[:href]
       value = enclose_item_in_data(value) if value.is_a?(Hash)
       return value if METHOD_NAMES_EXLCUDED_FROM_WRAPPING.include?(name.to_s)
-      wrap_return(value, record, name)
+      wrap_return(value, record, name, args)
     elsif _data._raw.is_a?(Hash)
       get(name, *args)
     end

data/lib/lhs/concerns/item/save.rb

@@ -19,7 +19,7 @@ class LHS::Item < LHS::Proxy
         apply_default_creation_options(options, url, data)
       )
     rescue LHC::Error => e
-      self.errors = LHS::Errors::Base.new(e.response, record)
+      self.errors = LHS::Problems::Errors.new(e.response, record)
       raise e
     end
 

data/lib/lhs/concerns/item/update.rb

@@ -8,7 +8,7 @@ class LHS::Item < LHS::Proxy
     def update(params, options = nil)
       update!(params, options)
     rescue LHC::Error => e
-      self.errors = LHS::Errors::Base.new(e.response, record)
+      self.errors = LHS::Problems::Errors.new(e.response, record)
       false
     end
 

data/lib/lhs/concerns/item/validation.rb

@@ -16,7 +16,7 @@ class LHS::Item < LHS::Proxy
       run_validation!(record, options, url, params)
       true
     rescue LHC::Error => e
-      self.errors = LHS::Errors::Base.new(e.response, record)
+      self.errors = LHS::Problems::Errors.new(e.response, record)
       false
     end
     alias validate valid?

data/lib/lhs/concerns/proxy/accessors.rb

@@ -67,12 +67,14 @@ class LHS::Proxy
       wrap_return(collection, record, name)
     end
 
-    # Wraps with record and adds nested errors to data,
+    # Wraps with record and adds nested errors/warnings to data,
     # if errors are existing
-    def wrap_return(value, record, name)
+    def wrap_return(value, record, name, args = nil)
+      name = args.first if name == :[]
       return value unless worth_wrapping?(value)
       data = value.is_a?(LHS::Data) || value.is_a?(LHS::Record) ? value : LHS::Data.new(value, _data)
-      data.errors = LHS::Errors::Nested.new(errors, name) if errors
+      data.errors = LHS::Problems::Nested::Errors.new(errors, name) if errors.any?
+      data.warnings = LHS::Problems::Nested::Warnings.new(warnings, name) if warnings.any?
       return record.new(data) if record && !value.is_a?(LHS::Record)
       data
     end

data/lib/lhs/concerns/proxy/problems.rb

@@ -0,0 +1,24 @@
+require 'active_support'
+
+class LHS::Proxy
+
+  module Problems
+    extend ActiveSupport::Concern
+
+    included do
+      attr_writer :errors, :warnings
+    end
+
+    def initialize(data)
+      super(data)
+    end
+
+    def errors
+      @errors ||= LHS::Problems::Errors.new(nil, record)
+    end
+
+    def warnings
+      @warnings ||= LHS::Problems::Warnings.new(_raw, record)
+    end
+  end
+end

data/lib/lhs/problems/base.rb

@@ -0,0 +1,108 @@
+require 'active_support/core_ext/module'
+require 'active_support/core_ext/hash'
+
+# Like ActiveModel::Errors
+module LHS::Problems
+  class Base
+    include Enumerable
+
+    attr_reader :raw, :messages, :record
+
+    def include?(attribute)
+      messages[attribute].present?
+    end
+    alias has_key? include?
+    alias key? include?
+
+    def add(attribute, message = :invalid, options = {})
+      self[attribute]
+      messages[attribute] << generate_message(attribute, message, options)
+    end
+
+    def get(key)
+      messages[key]
+    end
+
+    def set(key, message)
+      return if message.blank?
+      messages[key] = [generate_message(key, message)]
+    end
+
+    delegate :delete, to: :messages
+
+    def [](attribute)
+      get(attribute.to_sym) || messages[attribute] = []
+    end
+
+    def []=(attribute, message)
+      self[attribute] << generate_message(attribute, message)
+    end
+
+    def each
+      if messages.is_a?(Hash)
+        messages.each_key do |attribute|
+          self[attribute].each { |message| yield attribute, message }
+        end
+      elsif messages.is_a?(Array)
+        messages.each { |message| yield message }
+      end
+    end
+
+    def size
+      values.flatten.size
+    end
+
+    def clear
+      @raw = nil
+      @messages.clear
+    end
+
+    delegate :values, to: :messages
+
+    delegate :keys, to: :messages
+
+    def count
+      to_a.size
+    end
+
+    def empty?
+      all? { |_k, v| v && v.empty? && !v.is_a?(String) }
+    end
+
+    private
+
+    def add_error(messages, key, value)
+      key = key.to_sym
+      messages[key] ||= []
+      messages[key].push(generate_message(key, value))
+    end
+
+    def generate_message(attribute, message, _options = {})
+      problem_type = self.class.name.demodulize.downcase
+      find_translated_message(attribute, message, problem_type) || message
+    end
+
+    def find_translated_message(attribute, message, problem_type)
+      normalized_attribute = attribute.to_s.underscore
+      normalized_message = message.to_s.underscore
+      messages = []
+      messages = messages_for_record(normalized_attribute, normalized_message, problem_type) if record
+      messages.concat([
+        ['lhs', problem_type, 'messages', normalized_message],
+        ['lhs', problem_type, 'attributes', normalized_attribute, normalized_message],
+        ['lhs', problem_type, 'fallback_message']
+      ]).detect do |path|
+        key = path.join('.')
+        return I18n.translate(key) if I18n.exists?(key)
+      end
+    end
+
+    def messages_for_record(normalized_attribute, normalized_message, problem_type)
+      record_name = record.model_name.name.underscore
+      [
+        ['lhs', problem_type, 'records', record_name, 'attributes', normalized_attribute, normalized_message],
+        ['lhs', problem_type, 'records', record_name, normalized_message]
+      ]
+    end
+  end
+end

data/lib/lhs/problems/errors.rb

@@ -0,0 +1,65 @@
+module LHS::Problems
+  class Errors < Base
+
+    attr_reader :status_code, :message
+
+    def initialize(response = nil, record = nil)
+      @raw = response.body if response
+      @record = record
+      @messages = messages_from_response(response).with_indifferent_access
+      @message = message_from_response(response)
+      @status_code = response.code if response
+    rescue JSON::ParserError
+      @messages = (messages || {}).with_indifferent_access
+      @message = 'parse error'
+      add_error(@messages, 'body', 'parse error')
+    end
+
+    private
+
+    def parse_messages(json)
+      messages = {}
+      fields_to_errors(json, messages) if json['fields']
+      field_errors_to_errors(json, messages) if json['field_errors']
+      fallback_errors(json, messages) if messages.empty?
+      messages
+    end
+
+    def fallback_errors(json, messages)
+      if json.present?
+        json.each do |key, value|
+          add_error(messages, key, value)
+        end
+      else
+        add_error(messages, 'unknown', 'error')
+      end
+    end
+
+    def field_errors_to_errors(json, messages)
+      json['field_errors'].each do |field_error|
+        add_error(messages, field_error['path'].join('.').to_sym, field_error['code'])
+      end
+    end
+
+    def fields_to_errors(json, messages)
+      json['fields'].each do |field|
+        field['details'].each do |detail|
+          add_error(messages, field['name'].to_sym, detail['code'])
+        end
+      end
+    end
+
+    def messages_from_response(response = nil)
+      return {} if !response || !response.body.is_a?(String) || response.body.length.zero?
+      json = JSON.parse(response.body)
+      parse_messages(json)
+    end
+
+    def message_from_response(response = nil)
+      return if response.blank?
+      raise JSON::ParserError if response.body.blank?
+      json = JSON.parse(response.body)
+      json['message']
+    end
+  end
+end

data/lib/lhs/problems/nested/base.rb

@@ -0,0 +1,52 @@
+module LHS::Problems
+  module Nested
+    module Base
+      # Filters base errors by scope
+      # and reduces key by given scope name;
+      # returns plain array if end of tree is reached
+      def nest(messages, scope = nil)
+        scope = translate_rails_to_api_scope(scope)
+        return messages unless scope
+        messages = messages.select do |key, _|
+          key.match(/^#{scope}/)
+        end
+        # if only one key and this key has no dots, exit with plain
+        if reached_leaf?(messages)
+          messages.first[1]
+        else
+          remove_scope(messages, scope)
+        end
+      end
+
+      # Identifies if the end of nested errors tree is reached
+      def reached_leaf?(messages)
+        messages.keys.length == 1 &&
+          !messages.first[0].match(/\./)
+      end
+
+      # Removes scope from given messages' key
+      def remove_scope(messages, scope)
+        messages.each_with_object({}) do |element, hash|
+          key = element[0].to_s.gsub(/^#{scope}\./, '')
+          hash[key.to_sym] = element[1]
+        end
+      end
+
+      # Translates rails like accessors for collections
+      # like first, second, last to api error paths
+      def translate_rails_to_api_scope(scope)
+        case scope
+        when :first
+          0
+        when :second
+          1
+        when :last
+          return values.length - 1 if messages.present?
+          0
+        else
+          scope
+        end
+      end
+    end
+  end
+end

data/lib/lhs/problems/nested/errors.rb

@@ -0,0 +1,14 @@
+module LHS::Problems
+  module Nested
+    class Errors < LHS::Problems::Errors
+      include LHS::Problems::Nested::Base
+
+      def initialize(errors, scope)
+        @raw = errors
+        @messages = nest(errors.messages, scope)
+        @message = errors.message
+        @scope = scope
+      end
+    end
+  end
+end

data/lib/lhs/problems/nested/warnings.rb

@@ -0,0 +1,13 @@
+module LHS::Problems
+  module Nested
+    class Warnings < LHS::Problems::Warnings
+      include LHS::Problems::Nested::Base
+
+      def initialize(warnings, scope)
+        @raw = warnings.raw
+        @messages = nest(warnings.messages, scope)
+        @scope = scope
+      end
+    end
+  end
+end

data/lib/lhs/problems/warnings.rb

@@ -0,0 +1,21 @@
+module LHS::Problems
+  class Warnings < Base
+
+    def initialize(raw, record = nil)
+      @raw = raw
+      @record = record
+      @messages = warnings_from_raw
+    end
+
+    private
+
+    def warnings_from_raw
+      messages = {}
+      return messages if !raw.is_a?(Hash) || raw[:field_warnings].blank?
+      raw[:field_warnings].each do |field_warning|
+        add_error(messages, field_warning[:path].join('.').to_sym, field_warning[:code])
+      end
+      messages.with_indifferent_access
+    end
+  end
+end

data/lib/lhs/proxy.rb

@@ -5,15 +5,15 @@ class LHS::Proxy
     'lhs/concerns/proxy/accessors'
   autoload :Create,
     'lhs/concerns/proxy/create'
-  autoload :Errors,
-    'lhs/concerns/proxy/errors'
+  autoload :Problems,
+    'lhs/concerns/proxy/problems'
   autoload :Link,
     'lhs/concerns/proxy/link'
 
   include Accessors
   include Create
-  include Errors
   include Link
+  include Problems
 
   # prevent clashing with attributes of underlying data
   attr_accessor :_data, :_loaded

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = '14.1.1'
+  VERSION = '14.2.0'
 end

data/spec/item/warnings_spec.rb

@@ -0,0 +1,52 @@
+require 'rails_helper'
+
+describe LHS::Item do
+
+  before(:each) do
+    class Presence < LHS::Record
+      endpoint 'http://opm/presence'
+    end
+  end
+
+  before(:each) do
+    I18n.reload!
+    I18n.backend.store_translations(:en, YAML.safe_load(%q{
+      lhs:
+        warnings:
+          records:
+            presence:
+              will_be_resized: 'The photos will be resized'
+    }))
+  end
+
+  it 'provides warnings together with validation errors' do
+    stub_request(:post, "http://opm/presence?synchronize=false")
+      .to_return(
+        body: {
+          field_warnings: [{
+            code: 'WILL_BE_RESIZED',
+            path: ['place', 'photos', 0],
+            message: 'The image will be resized.'
+          }],
+          place: {
+            href: 'http://storage/places/1',
+            photos: [{
+              href: 'http://bin.staticlocal.ch/123',
+              width: 10,
+              height: 10
+            }]
+          }
+        }.to_json
+      )
+    presence = Presence.options(params: { synchronize: false }).create(
+      place: { href: 'http://storage/places/1' }
+    )
+    expect(presence.warnings.any?).to eq true
+    expect(presence.place.warnings.any?).to eq true
+    expect(presence.place.photos.warnings.any?).to eq true
+    expect(presence.place.photos[0].warnings.any?).to eq true
+    expect(presence.place.photos[0].warnings.messages.first).to eq(
+      'The photos will be resized'
+    )
+  end
+end

data/spec/record/create_spec.rb

@@ -66,7 +66,7 @@ describe LHS::Record do
         stub_request(:post, "#{datastore}/content-ads/12345/feedbacks")
           .to_return(status: 400, body: creation_error.to_json)
         feedback = Feedback.create(object.merge(campaign_id: '12345'))
-        expect(feedback.errors).to be_kind_of LHS::Errors::Base
+        expect(feedback.errors).to be_kind_of LHS::Problems::Errors
       end
 
       it 'raises an exception when creation failed using create!' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 14.1.1
+  version: 14.2.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-20 00:00:00.000000000 Z
+date: 2017-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc
@@ -212,8 +212,8 @@ files:
 - lib/lhs/concerns/item/validation.rb
 - lib/lhs/concerns/proxy/accessors.rb
 - lib/lhs/concerns/proxy/create.rb
-- lib/lhs/concerns/proxy/errors.rb
 - lib/lhs/concerns/proxy/link.rb
+- lib/lhs/concerns/proxy/problems.rb
 - lib/lhs/concerns/record/batch.rb
 - lib/lhs/concerns/record/chainable.rb
 - lib/lhs/concerns/record/configuration.rb
@@ -234,13 +234,17 @@ files:
 - lib/lhs/config.rb
 - lib/lhs/data.rb
 - lib/lhs/endpoint.rb
-- lib/lhs/errors/base.rb
-- lib/lhs/errors/nested.rb
 - lib/lhs/item.rb
 - lib/lhs/pagination/base.rb
 - lib/lhs/pagination/offset.rb
 - lib/lhs/pagination/page.rb
 - lib/lhs/pagination/start.rb
+- lib/lhs/problems/base.rb
+- lib/lhs/problems/errors.rb
+- lib/lhs/problems/nested/base.rb
+- lib/lhs/problems/nested/errors.rb
+- lib/lhs/problems/nested/warnings.rb
+- lib/lhs/problems/warnings.rb
 - lib/lhs/proxy.rb
 - lib/lhs/railtie.rb
 - lib/lhs/record.rb
@@ -333,6 +337,7 @@ files:
 - spec/item/translate_errors_spec.rb
 - spec/item/update_spec.rb
 - spec/item/validation_spec.rb
+- spec/item/warnings_spec.rb
 - spec/pagination/pages_left_spec.rb
 - spec/proxy/create_sub_resource_spec.rb
 - spec/proxy/load_spec.rb
@@ -420,7 +425,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - Ruby >= 2.3.0
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Rails gem providing an easy, active-record-like interface for http json services
@@ -509,6 +514,7 @@ test_files:
 - spec/item/translate_errors_spec.rb
 - spec/item/update_spec.rb
 - spec/item/validation_spec.rb
+- spec/item/warnings_spec.rb
 - spec/pagination/pages_left_spec.rb
 - spec/proxy/create_sub_resource_spec.rb
 - spec/proxy/load_spec.rb

data/lib/lhs/concerns/proxy/errors.rb

@@ -1,21 +0,0 @@
-require 'active_support'
-
-class LHS::Proxy
-
-  module Errors
-    extend ActiveSupport::Concern
-
-    included do
-      attr_writer :errors
-    end
-
-    def initialize(data)
-      super(data)
-      self.errors = LHS::Errors::Base.new(nil, record)
-    end
-
-    def errors
-      @errors ||= LHS::Errors::Base.new(nil, record)
-    end
-  end
-end

data/lib/lhs/errors/base.rb

@@ -1,160 +0,0 @@
-require 'active_support/core_ext/module'
-require 'active_support/core_ext/hash'
-
-# Like ActiveModel::Errors
-module LHS::Errors
-  class Base
-    include Enumerable
-
-    attr_reader :messages, :message, :raw, :record, :status_code
-
-    def initialize(response = nil, record = nil)
-      @raw = response.body if response
-      @record = record
-      @messages = messages_from_response(response).with_indifferent_access
-      @message = message_from_response(response)
-      @status_code = response.code if response
-    rescue JSON::ParserError
-      @messages = (messages || {}).with_indifferent_access
-      @message = 'parse error'
-      add_error(@messages, 'body', 'parse error')
-    end
-
-    def include?(attribute)
-      messages[attribute].present?
-    end
-    alias has_key? include?
-    alias key? include?
-
-    def add(attribute, message = :invalid, options = {})
-      self[attribute]
-      messages[attribute] << generate_message(attribute, message, options)
-    end
-
-    def get(key)
-      messages[key]
-    end
-
-    def set(key, message)
-      return if message.blank?
-      messages[key] = [generate_message(key, message)]
-    end
-
-    delegate :delete, to: :messages
-
-    def [](attribute)
-      get(attribute.to_sym) || messages[attribute] = []
-    end
-
-    def []=(attribute, message)
-      self[attribute] << generate_message(attribute, message)
-    end
-
-    def each
-      messages.each_key do |attribute|
-        self[attribute].each { |message| yield attribute, message }
-      end
-    end
-
-    def size
-      values.flatten.size
-    end
-
-    def clear
-      @raw = nil
-      @messages.clear
-    end
-
-    delegate :values, to: :messages
-
-    delegate :keys, to: :messages
-
-    def count
-      to_a.size
-    end
-
-    def empty?
-      all? { |_k, v| v && v.empty? && !v.is_a?(String) }
-    end
-
-    private
-
-    def add_error(messages, key, value)
-      key = key.to_sym
-      messages[key] ||= []
-      messages[key].push(generate_message(key, value))
-    end
-
-    def generate_message(attribute, message, _options = {})
-      find_translated_error_message(attribute, message) || message
-    end
-
-    def find_translated_error_message(attribute, message)
-      normalized_attribute = attribute.to_s.underscore
-      normalized_message = message.to_s.underscore
-      messages = []
-      messages = messages_for_record(normalized_attribute, normalized_message) if record
-      messages.concat([
-        ['lhs', 'errors', 'messages', normalized_message],
-        ['lhs', 'errors', 'attributes', normalized_attribute, normalized_message],
-        ['lhs', 'errors', 'fallback_message']
-      ]).detect do |path|
-        key = path.join('.')
-        return I18n.translate(key) if I18n.exists?(key)
-      end
-    end
-
-    def messages_for_record(normalized_attribute, normalized_message)
-      record_name = record.model_name.name.underscore
-      [
-        ['lhs', 'errors', 'records', record_name, 'attributes', normalized_attribute, normalized_message],
-        ['lhs', 'errors', 'records', record_name, normalized_message]
-      ]
-    end
-
-    def parse_messages(json)
-      messages = {}
-      fields_to_errors(json, messages) if json['fields']
-      field_errors_to_errors(json, messages) if json['field_errors']
-      fallback_errors(json, messages) if messages.empty?
-      messages
-    end
-
-    def fallback_errors(json, messages)
-      if json.present?
-        json.each do |key, value|
-          add_error(messages, key, value)
-        end
-      else
-        add_error(messages, 'unknown', 'error')
-      end
-    end
-
-    def field_errors_to_errors(json, messages)
-      json['field_errors'].each do |field_error|
-        add_error(messages, field_error['path'].join('.').to_sym, field_error['code'])
-      end
-    end
-
-    def fields_to_errors(json, messages)
-      json['fields'].each do |field|
-        field['details'].each do |detail|
-          add_error(messages, field['name'].to_sym, detail['code'])
-        end
-      end
-    end
-
-    def messages_from_response(response = nil)
-      return {} if !response || !response.body.is_a?(String) || response.body.length.zero?
-      json = JSON.parse(response.body)
-      parse_messages(json)
-    end
-
-    def message_from_response(response = nil)
-      return if response.blank?
-      raise JSON::ParserError if response.body.blank?
-      json = JSON.parse(response.body)
-      json['message']
-    end
-  end
-end

data/lib/lhs/errors/nested.rb

@@ -1,60 +0,0 @@
-module LHS::Errors
-  class Nested < Base
-
-    def initialize(errors, scope)
-      @raw = errors
-      @messages = nest(errors.messages, scope)
-      @message = errors.message
-      @scope = scope
-    end
-
-    private
-
-    # Filters base errors by scope
-    # and reduces key by given scope name;
-    # returns plain array if end of tree is reached
-    def nest(messages, scope = nil)
-      scope = translate_rails_to_api_scope(scope)
-      return messages unless scope
-      messages = messages.select do |key, _|
-        key.match(/^#{scope}/)
-      end
-      # if only one key and this key has no dots, exit with plain
-      if reached_leaf?(messages)
-        messages.first[1]
-      else
-        remove_scope(messages, scope)
-      end
-    end
-
-    # Identifies if the end of nested errors tree is reached
-    def reached_leaf?(messages)
-      messages.keys.length == 1 &&
-        !messages.first[0].match(/\./)
-    end
-
-    # Removes scope from given messages' key
-    def remove_scope(messages, scope)
-      messages.each_with_object({}) do |element, hash|
-        key = element[0].to_s.gsub(/^#{scope}\./, '')
-        hash[key.to_sym] = element[1]
-      end
-    end
-
-    # Translates rails like accessors for collections
-    # like first, second, last to api error paths
-    def translate_rails_to_api_scope(scope)
-      case scope
-      when :first
-        0
-      when :second
-        1
-      when :last
-        return values.length - 1 if messages.present?
-        0
-      else
-        scope
-      end
-    end
-  end
-end