lhs 11.0.3 → 11.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc9d93456e8c4ad57a3883f582dd868169272980
-  data.tar.gz: d741c6a54fcdbe5c7b72a8f226fd290485d5e218
+  metadata.gz: abf5de2dde8813263d07b049e423c569bf0e187c
+  data.tar.gz: 2bf40b2701cfa58783ce975c260da734a8952b1c
 SHA512:
-  metadata.gz: a1dbba4cf7b6d320d0a16ff0582159a50565d6f5e5ba037e0c0bbebc3c708d3e50403df9846a35b26879dc48f116349ec961cd4c418c3a97ac6302c916280c91
-  data.tar.gz: d6d14efc2d3558dd996aba3bcc9da903e8a19ca118dd8d2b760a3bab415b13807512740ae947524f0894984f1e373c7e9d96cfa49e0cb29de6d95c3fd30b2156
+  metadata.gz: e87e3813fd4afa5c1aa2a9053745e473936ce7262e3bcba83d75032a3261c9ecc045fa70d4a8350428a754baf1dcc3d5c0c5439ab1121ae37da30c447ead8cbd
+  data.tar.gz: 78c83def6fbe617c6d1c5c7bcb91d8ebe3ca3fdd1b092eb8e51166b8fec51699cbbbe6ffdf3297cb7ff7c364fe11191d6e7a02a98ad05f56b6e7819daa7bb217

data/README.md

@@ -707,7 +707,7 @@ unless user.valid?
   fail(user.errors[:email])
 end
 
-user.errors #<LHS::Errors>
+user.errors #<LHS::Errors::Base>
 user.errors.include?(:email) # true
 user.errors[:email] # ['REQUIRED_PROPERTY_VALUE']
 user.errors.messages # {:email=>["REQUIRED_PROPERTY_VALUE"]}
@@ -739,6 +739,38 @@ In case you want to add custom validation errors to an instance of LHS::Record:
 user.errors.add(:name, 'The name you provided is not valid.')
 ```
 
+### Validation errors for nested data
+
+If you work with complex data structures, you sometimes need to have validation errors delegated/scoped to nested data.
+
+This also makes LHS::Records compatible with how Rails or Simpleform renders/builds forms and especially error messages.
+
+```ruby
+# controller.rb
+unless @customer.save
+  @errors = @customer.errors
+end
+
+# view.html
+= form_for @customer, as: :customer do |customer_form|
+  
+  = fields_for 'customer[:address]', @customer.address, do |address_form|
+  
+    = fields_for 'customer[:address][:street]', @customer.address.street, do |street_form|
+
+      = street_form.input :name
+      = street_form.input :house_number
+```
+
+Would render nested forms and would also render nested form errors for nested data structures.
+
+You can also access those nested errors like:
+
+```ruby
+@customer.address.errors
+@customer.address.street.errors
+```
+
 ### 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)
 

data/lib/lhs/collection.rb

@@ -7,6 +7,8 @@ class LHS::Collection < LHS::Proxy
   include InternalCollection
   include Create
 
+  METHOD_NAMES_EXLCUDED_FROM_WRAPPING = %w(to_a map).freeze
+
   delegate :select, :length, :size, to: :_collection
   delegate :_record, :_raw, to: :_data
   delegate :limit, :count, :total, :offset, :current_page, :start,
@@ -48,8 +50,10 @@ class LHS::Collection < LHS::Proxy
   def method_missing(name, *args, &block)
     if _collection.respond_to?(name)
       value = _collection.send(name, *args, &block)
-      return enclose_in_data(value) if value.is_a? Hash
-      value
+      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)
     elsif _data._raw.is_a?(Hash)
       get(name, *args)
     end
@@ -67,7 +71,9 @@ class LHS::Collection < LHS::Proxy
     :items
   end
 
-  def enclose_in_data(value)
+  # Encloses accessed collection item
+  # by wrapping it in an LHS::Item
+  def enclose_item_in_data(value)
     data = LHS::Data.new(value, _data)
     item = LHS::Item.new(data)
     LHS::Data.new(item, _data)

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

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

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

@@ -9,7 +9,7 @@ class LHS::Item < LHS::Proxy
     def update(params, options = nil)
       update!(params, options)
     rescue LHC::Error => e
-      self.errors = LHS::Errors.new(e.response)
+      self.errors = LHS::Errors::Base.new(e.response)
       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.new(e.response)
+      self.errors = LHS::Errors::Base.new(e.response)
       false
     end
     alias validate valid?

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

@@ -18,15 +18,14 @@ class LHS::Proxy
     def get(name, *args)
       name = args.first if name == :[]
       value = _data._raw[name.to_s]
-      if value.nil? && _data._raw.present?
+      if value.nil? && _data._raw.present? && _data._raw.is_a?(Hash)
         value = _data._raw[name.to_sym]
         value = _data._raw[name.to_s.classify.to_sym] if value.nil?
       end
 
       record = LHS::Record.for_url(value[:href]) if value.is_a?(Hash) && value[:href]
-
-      access_item(value, record) ||
-        access_collection(value, record) ||
+      access_item(value, record, name) ||
+        access_collection(value, record, name) ||
         convert(value)
     end
 
@@ -54,24 +53,36 @@ class LHS::Proxy
       end
     end
 
-    def access_item(value, record)
+    def access_item(value, record, name)
       return unless accessing_item?(value, record)
-      wrap_return(value, record)
+      wrap_return(value, record, name)
     end
 
-    def access_collection(value, record)
+    def access_collection(value, record, name)
       return unless accessing_collection?(value, record)
       collection_data = LHS::Data.new(value, _data)
       collection = LHS::Collection.new(collection_data)
-      wrap_return(collection, record)
+      wrap_return(collection, record, name)
     end
 
-    def wrap_return(value, record)
-      data = LHS::Data.new(value, _data)
-      return record.new(data) if record
+    # Wraps with record and adds nested errors to data,
+    # if errors are existing
+    def wrap_return(value, record, 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
+      return record.new(data) if record && !value.is_a?(LHS::Record)
       data
     end
 
+    def worth_wrapping?(value)
+      value.is_a?(LHS::Proxy)     ||
+        value.is_a?(LHS::Data)    ||
+        value.is_a?(LHS::Record)  ||
+        value.is_a?(Hash)         ||
+        value.is_a?(Array)
+    end
+
     def date?(value)
       value[date_time_regex, :date].presence
     end

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

@@ -0,0 +1,21 @@
+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
+    end
+
+    def errors
+      @errors ||= LHS::Errors::Base.new
+    end
+  end
+end

data/lib/lhs/data.rb

@@ -37,7 +37,7 @@ class LHS::Data
 
   def parent
     if _parent && _parent._record
-      _parent._record.new(_parent)
+      _parent._record.new(_parent, false)
     else
       _parent
     end
@@ -112,7 +112,7 @@ class LHS::Data
   end
 
   def raw_from_input(input)
-    if input.is_a?(String) && !input.empty?
+    if json?(input)
       raw_from_json_string(input)
     elsif defined?(input._raw)
       input._raw
@@ -123,6 +123,10 @@ class LHS::Data
     end
   end
 
+  def json?(input)
+    input.is_a?(String) && !input.empty? && !!input.match(/^("|\[|'|\{)/)
+  end
+
   def raw_from_json_string(input)
     json = JSON.parse(input)
     if json.is_a?(Hash)

data/lib/lhs/errors/base.rb

@@ -0,0 +1,126 @@
+# Like ActiveModel::Errors
+module LHS::Errors
+  class Base
+    include Enumerable
+
+    attr_reader :messages, :message, :raw
+
+    def initialize(response = nil)
+      @raw = response.body if response
+      @messages = messages_from_response(response)
+      @message = message_from_response(response)
+    rescue JSON::ParserError
+      @messages = messages || {}
+      @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] << message
+    end
+
+    def get(key)
+      messages[key]
+    end
+
+    def set(key, value)
+      messages[key] = value
+    end
+
+    delegate :delete, to: :messages
+
+    def [](attribute)
+      get(attribute.to_sym) || set(attribute.to_sym, [])
+    end
+
+    def []=(attribute, error)
+      self[attribute] << error
+    end
+
+    def each
+      messages.each_key do |attribute|
+        self[attribute].each { |error| yield attribute, error }
+      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(value)
+    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 unless response
+      json = JSON.parse(response.body)
+      json['message']
+    end
+  end
+end

data/lib/lhs/errors/nested.rb

@@ -0,0 +1,60 @@
+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

data/lib/lhs/item.rb

@@ -11,17 +11,8 @@ class LHS::Item < LHS::Proxy
   include Validation
 
   delegate :present?, :blank?, :empty?, to: :_raw
-
-  # prevent clashing with attributes of underlying data
-  attr_accessor :errors
-
   delegate :_raw, to: :_data
 
-  def initialize(data)
-    self.errors = LHS::Errors.new
-    super(data)
-  end
-
   def collection?
     false
   end

data/lib/lhs/proxy.rb

@@ -3,9 +3,9 @@ Dir[File.dirname(__FILE__) + '/concerns/proxy/*.rb'].each { |file| require file
 # Proxy makes different kind of data accessible
 # If href is present it also alows loading/reloading
 class LHS::Proxy
-
   include Accessors
   include Create
+  include Errors
   include Link
 
   # prevent clashing with attributes of underlying data

data/lib/lhs/record.rb

@@ -21,11 +21,11 @@ class LHS::Record
 
   delegate :_proxy, :_endpoint, :merge_raw!, :select, to: :_data
 
-  def initialize(data = nil)
+  def initialize(data = nil, apply_customer_setters = true)
     data = LHS::Data.new({}, nil, self.class) unless data
     data = LHS::Data.new(data, nil, self.class) unless data.is_a?(LHS::Data)
     define_singleton_method(:_data) { data }
-    apply_custom_setters!
+    apply_custom_setters! if apply_customer_setters
   end
 
   def as_json(options = nil)

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = "11.0.3"
+  VERSION = "11.1.0"
 end

data/spec/collection/to_a_spec.rb

@@ -0,0 +1,32 @@
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:items) { [{ name: 'Steve' }] }
+  let(:extra) { 'extra' }
+  let(:collection) { Record.where }
+
+  context 'to_a' do
+    let(:response_data) do
+      {
+        items: items,
+        extra: extra,
+        total: 1
+      }
+    end
+
+    let(:subject) { collection.to_a }
+
+    before(:each) do
+      class Record < LHS::Record
+        endpoint 'http://datastore/records`'
+      end
+      stub_request(:get, %r{http://datastore/records})
+        .to_return(body: response_data.to_json)
+    end
+
+    it 'returns an array and not LHS::Data' do
+      expect(subject).to be_kind_of Array
+      expect(subject).not_to be_kind_of LHS::Data
+    end
+  end
+end

data/spec/item/errors_spec.rb

@@ -173,4 +173,60 @@ describe LHS::Item do
       expect(record.errors.any?).to eq false
     end
   end
+
+  context 'nested data' do
+    let(:body_with_errors) do
+      {
+        "status" => 400,
+        "message" => "Some data in the request body failed validation. Inspect the field errors for details.",
+        "field_errors" => [{
+          "code" => "UNSUPPORTED_PROPERTY_VALUE",
+          "path" => ["reviews", 0, "name"],
+          "message" => "The property value is unsupported. Supported values are: FEMALE, MALE"
+        }, {
+          "code" => "INCOMPLETE_PROPERTY_VALUE",
+          "path" => ["address", "street", "name"],
+          "message" => "The property value is incomplete. It misses some data"
+        }, {
+          "code" => "REQUIRED_PROPERTY_VALUE",
+          "path" => ["address", "street", "additional_line1"],
+          "message" => "The property value is required"
+        }]
+      }
+    end
+
+    let(:record) do
+      Record.build(
+        reviews: [{ name: 123 }],
+        address: {
+          additional_line1: '',
+          street: {
+            name: 'Förlib'
+          }
+        }
+      )
+    end
+
+    let(:errrors) { record.errors }
+
+    before(:each) do
+      stub_request(:post, "#{datastore}/feedbacks")
+        .to_return(status: 400, body: body_with_errors.to_json)
+    end
+
+    it 'forwards errors to nested data' do
+      record.save
+      expect(record.errors['address.street.name']).to include 'INCOMPLETE_PROPERTY_VALUE'
+      expect(record.errors['reviews.0.name']).to include 'UNSUPPORTED_PROPERTY_VALUE'
+      expect(record.address.errors).to be
+      expect(record.address.errors['street.name']).to be
+      expect(record.address.street.errors).to be
+      expect(record.address.street.errors[:name]).to include 'INCOMPLETE_PROPERTY_VALUE'
+      expect(record.reviews.errors).to be
+      expect(record.reviews.first.errors).to be
+      expect(record.reviews.first.errors[:name]).to include 'UNSUPPORTED_PROPERTY_VALUE'
+      expect(record.reviews.last.errors).to be
+      expect(record.reviews.last.errors[:name]).to include 'UNSUPPORTED_PROPERTY_VALUE'
+    end
+  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
+        expect(feedback.errors).to be_kind_of LHS::Errors::Base
       end
 
       it 'raises an exception when creation failed using create!' do
@@ -107,7 +107,7 @@ describe LHS::Record do
 
       it 'are used by create' do
         feedback = Feedback.create(ratings: ratings)
-        expect(feedback.ratings.raw).to eq(converted_ratings)
+        expect(feedback.ratings._raw).to eq(converted_ratings)
       end
 
       it 'can be used directly to change raw data' do

data/spec/record/new_spec.rb

@@ -56,7 +56,7 @@ describe LHS::Record do
 
       it 'are used by initializer' do
         feedback = Rating.new(ratings: { a: 1, b: 2 })
-        expect(feedback.ratings.raw).to eq([{ name: :a, value: 1 }, { name: :b, value: 2 }])
+        expect(feedback.ratings._raw).to eq([{ name: :a, value: 1 }, { name: :b, value: 2 }])
       end
 
       it 'can be used directly to change raw data' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 11.0.3
+  version: 11.1.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-31 00:00:00.000000000 Z
+date: 2017-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc
@@ -195,6 +195,7 @@ files:
 - lib/lhs/concerns/lhs/configuration.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/record/batch.rb
 - lib/lhs/concerns/record/chainable.rb
@@ -216,7 +217,8 @@ files:
 - lib/lhs/config.rb
 - lib/lhs/data.rb
 - lib/lhs/endpoint.rb
-- lib/lhs/errors.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
@@ -237,6 +239,7 @@ files:
 - spec/collection/href_spec.rb
 - spec/collection/meta_data_spec.rb
 - spec/collection/respond_to_spec.rb
+- spec/collection/to_a_spec.rb
 - spec/collection/without_object_items_spec.rb
 - spec/complex/reduce_spec.rb
 - spec/concerns/record/request_spec.rb
@@ -386,7 +389,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - Ruby >= 2.0.0
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Rails gem providing an easy, active-record-like interface for http json services
@@ -400,6 +403,7 @@ test_files:
 - spec/collection/href_spec.rb
 - spec/collection/meta_data_spec.rb
 - spec/collection/respond_to_spec.rb
+- spec/collection/to_a_spec.rb
 - spec/collection/without_object_items_spec.rb
 - spec/complex/reduce_spec.rb
 - spec/concerns/record/request_spec.rb

data/lib/lhs/errors.rb

@@ -1,124 +0,0 @@
-# Like ActiveModel::Errors
-class LHS::Errors
-  include Enumerable
-
-  attr_reader :messages, :message, :raw
-
-  def initialize(response = nil)
-    @raw = response.body if response
-    @messages = messages_from_response(response)
-    @message = message_from_response(response)
-  rescue JSON::ParserError
-    @messages = messages || {}
-    @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] << message
-  end
-
-  def get(key)
-    messages[key]
-  end
-
-  def set(key, value)
-    messages[key] = value
-  end
-
-  delegate :delete, to: :messages
-
-  def [](attribute)
-    get(attribute.to_sym) || set(attribute.to_sym, [])
-  end
-
-  def []=(attribute, error)
-    self[attribute] << error
-  end
-
-  def each
-    messages.each_key do |attribute|
-      self[attribute].each { |error| yield attribute, error }
-    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(value)
-  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 unless response
-    json = JSON.parse(response.body)
-    json['message']
-  end
-end