contentful 1.2.2 → 2.0.0

data/lib/contentful/space.rb

@@ -1,14 +1,24 @@
-require_relative 'resource'
+require_relative 'base_resource'
 require_relative 'locale'
 
 module Contentful
   # Resource class for Space.
   # https://www.contentful.com/developers/documentation/content-delivery-api/#spaces
-  class Space
-    include Contentful::Resource
-    include Contentful::Resource::SystemProperties
+  class Space < BaseResource
+    attr_reader :name, :locales
 
-    property :name, :string
-    property :locales, Locale
+    def initialize(item, *)
+      super
+
+      @name = item.fetch('name', nil)
+      @locales = item.fetch('locales', []).map { |locale| Locale.new(locale) }
+    end
+
+    # @private
+    def reload(client = nil)
+      return client.space unless client.nil?
+
+      false
+    end
   end
 end

data/lib/contentful/support.rb

@@ -8,17 +8,55 @@ module Contentful
       #
       # @return [String] snake_case_name
       def snakify(object)
-        snake = String(object).gsub(/(?<!^)[A-Z]/) { "_#{$&}" }
-        snake.downcase
+        String(object)
+          .gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
       end
 
       # Returns true if resource is localized
       #
-      # @return [Boolean]
+      # @return [true, false]
       def localized?(value)
         return false unless value.is_a? ::Hash
         value.keys.any? { |possible_locale| Contentful::Constants::KNOWN_LOCALES.include?(possible_locale) }
       end
+
+      # Checks if value is a link
+      #
+      # @param value
+      #
+      # @return [true, false]
+      def link?(value)
+        value.is_a?(::Hash) &&
+          value.fetch('sys', {}).fetch('type', '') == 'Link'
+      end
+
+      # Checks if value is an array of links
+      #
+      # @param value
+      #
+      # @return [true, false]
+      def link_array?(value)
+        return link?(value[0]) if value.is_a?(::Array) && !value.empty?
+
+        false
+      end
+
+      # Returns the resource that matches the link
+      #
+      # @param [Hash] link
+      # @param [::Array] includes
+      #
+      # @return [Hash]
+      def resource_for_link(link, includes)
+        includes.detect do |i|
+          i['sys']['id'] == link['sys']['id'] &&
+            i['sys']['type'] == link['sys']['linkType']
+        end
+      end
     end
   end
 end

data/lib/contentful/sync_page.rb

@@ -1,18 +1,25 @@
-require_relative 'resource'
-require_relative 'resource/array_like'
+require_relative 'base_resource'
+require_relative 'array_like'
 
 module Contentful
   # Wrapper Class for Sync results
-  class SyncPage
-    attr_reader :sync
+  class SyncPage < BaseResource
+    include Contentful::ArrayLike
 
-    include Contentful::Resource
-    include Contentful::Resource::SystemProperties
-    include Contentful::Resource::ArrayLike
+    attr_reader :sync, :items, :next_sync_url, :next_page_url
 
-    property :items
-    property :nextSyncUrl
-    property :nextPageUrl
+    def initialize(item, default_locale, *)
+      super(item, { default_locale: default_locale }, true)
+
+      @items = item.fetch('items', [])
+      @next_sync_url = item.fetch('nextSyncUrl', nil)
+      @next_page_url = item.fetch('nextPageUrl', nil)
+    end
+
+    # @private
+    def inspect
+      "<#{repr_name} next_sync_url='#{next_sync_url}' last_page=#{last_page?}>"
+    end
 
     # Requests next sync page from API
     #

data/lib/contentful/version.rb

@@ -1,5 +1,5 @@
 # Contentful Namespace
 module Contentful
   # Gem Version
-  VERSION = '1.2.2'
+  VERSION = '2.0.0'
 end

data/spec/array_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe Contentful::Array do
-  let(:array) { vcr('array') { create_client.content_types } }
+  let(:client) { create_client }
+  let(:array) { vcr('array') { client.content_types } }
 
   describe 'SystemProperties' do
     it 'has a #sys getter returning a hash with symbol keys' do
@@ -15,11 +16,6 @@ describe Contentful::Array do
   end
 
   describe 'Properties' do
-    it 'has a #properties getter returning a hash with symbol keys' do
-      expect(array.properties).to be_a Hash
-      expect(array.properties.keys.sample).to be_a Symbol
-    end
-
     it 'has #total' do
       expect(array.total).to eq 4
     end
@@ -34,7 +30,7 @@ describe Contentful::Array do
 
     it 'has #items which contain resources' do
       expect(array.items).to be_a Array
-      expect(array.items.sample).to be_a Contentful::Resource
+      expect(array.items.sample).to be_a Contentful::BaseResource
     end
   end
 
@@ -55,7 +51,7 @@ describe Contentful::Array do
   describe '#next_page' do
     it 'requests more of the same content from the server, using its limit and skip values' do
       array_page_1 = vcr('array_page_1') { create_client.content_types(skip: 3, limit: 2) }
-      array_page_2 = vcr('array_page_2') { array_page_1.next_page }
+      array_page_2 = vcr('array_page_2') { array_page_1.next_page(client) }
 
       expect(array_page_2).to be_a Contentful::Array
       expect(array_page_2.limit).to eq 2

data/spec/client_class_spec.rb

@@ -6,50 +6,39 @@ describe Contentful::Client do
     let(:proxy_client) { create_client(proxy_host: '183.207.232.194',
                                        proxy_port: 8080,
                                        secure: false) }
-    let(:request) do
-      Contentful::Request.new(nil, '/content_types', nil, 'cat')
-    end
+    let(:request) { Contentful::Request.new(nil, '/content_types', nil, 'cat') }
 
     it 'uses #base_url' do
-      stub(client).base_url { 'https://cdn.contentful.com/spaces/cfexampleapi' }
-      vcr('content_type') { client.get(request) }
-      expect(client).to have_received.base_url
+      expect(client).to receive(:base_url).and_call_original
+
+      vcr('content_type') {
+        client.get(request)
+      }
     end
 
     it 'uses #request_headers' do
-      stub(client).request_headers do
-        {
-            'User-Agent' => 'RubyContentfulGem/0.1.0',
-            'Authorization' => 'Bearer b4c0n73n7fu1',
-            'Content-Type' => 'application/vnd.contentful.delivery.v1+json',
-        }
-      end
+      expect(client).to receive(:request_headers).and_call_original
       vcr('content_type') { client.get(request) }
-      expect(client).to have_received.request_headers
     end
 
     it 'uses Request#url' do
-      stub(request).url { '/content_types/cat' }
+      expect(request).to receive(:url).and_call_original
       vcr('content_type') { client.get(request) }
-      expect(request).to have_received.url
     end
 
     it 'uses Request#query' do
-      stub(request).query
+      expect(request).to receive(:query).twice.and_call_original
       vcr('content_type') { client.get(request) }
-      expect(request).to have_received.query
     end
 
     it 'calls #get_http' do
-      stub(client.class).get_http { raw_fixture('content_type') }
+      expect(client.class).to receive(:get_http).with(client.base_url + request.url, request.query, client.request_headers, client.proxy_params) { raw_fixture('content_type') }
       client.get(request)
-      expect(client.class).to have_received.get_http(client.base_url + request.url, request.query, client.request_headers, client.proxy_params)
     end
 
     it 'calls #get_http via proxy' do
-      stub(proxy_client.class).get_http { raw_fixture('content_type') }
+      expect(proxy_client.class).to receive(:get_http).with(proxy_client.base_url + request.url, request.query, proxy_client.request_headers, proxy_client.proxy_params) { raw_fixture('content_type') }
       proxy_client.get(request)
-      expect(proxy_client.class).to have_received.get_http(proxy_client.base_url + request.url, request.query, proxy_client.request_headers, proxy_client.proxy_params)
       expect(proxy_client.proxy_params[:host]).to eq '183.207.232.194'
       expect(proxy_client.proxy_params[:port]).to eq 8080
     end
@@ -57,7 +46,7 @@ describe Contentful::Client do
     describe 'build_resources parameter' do
       it 'returns Contentful::Resource object if second parameter is true [default]' do
         res = vcr('content_type') { client.get(request) }
-        expect(res).to be_a Contentful::Resource
+        expect(res).to be_a Contentful::BaseResource
       end
 
       it 'returns a Contentful::Response object if second parameter is not true' do

data/spec/client_configuration_spec.rb

@@ -34,7 +34,7 @@ describe 'Client Configuration Options' do
   describe ':raise_errors' do
     it 'will raise response errors if set to true [default]' do
       expect_vcr('not found')do
-        create_client.entry 'not found'
+        create_client.content_type 'not found'
       end.to raise_error Contentful::NotFound
     end
 
@@ -42,16 +42,15 @@ describe 'Client Configuration Options' do
       res = nil
 
       expect_vcr('not found')do
-        res = create_client(raise_errors: false).entry 'not found'
+        res = create_client(raise_errors: false).content_type 'not found'
       end.not_to raise_error
       expect(res).to be_instance_of Contentful::NotFound
     end
   end
 
   describe ':dynamic_entries' do
-    it 'will create static if dynamic_entry_cache is empty' do
-      entry = vcr('nyancat') { create_client(dynamic_entries: :manual).entry('nyancat') }
-      expect(entry).not_to be_a Contentful::DynamicEntry
+    before :each do
+      Contentful::ContentTypeCache.clear!
     end
 
     it 'will create dynamic entries if dynamic_entry_cache is not empty' do
@@ -59,24 +58,22 @@ describe 'Client Configuration Options' do
       vcr('entry_cache') { client.update_dynamic_entry_cache! }
       entry = vcr('nyancat') { client.entry('nyancat') }
 
-      expect(entry).to be_a Contentful::DynamicEntry
+      expect(entry).to be_a Contentful::Entry
     end
 
     context ':auto' do
       it 'will call update dynamic_entry_cache on start-up' do
-        client = vcr('entry_cache')do
+        vcr('entry_cache') do
           create_client(dynamic_entries: :auto)
         end
-        expect(client.dynamic_entry_cache).not_to be_empty
-        expect(client.dynamic_entry_cache.values.first.ancestors).to \
-            include Contentful::DynamicEntry
+        expect(Contentful::ContentTypeCache.cache).not_to be_empty
       end
     end
 
     context ':manual' do
       it 'will not call #update_dynamic_entry_cache! on start-up' do
-        client = create_client(dynamic_entries: :manual)
-        expect(client.dynamic_entry_cache).to be_empty
+        create_client(dynamic_entries: :manual)
+        expect(Contentful::ContentTypeCache.cache).to be_empty
       end
     end
 
@@ -84,18 +81,15 @@ describe 'Client Configuration Options' do
       let(:client) { create_client(dynamic_entries: :manual) }
 
       it 'will fetch all content_types' do
-        stub(client).content_types { {} }
+        expect(client).to receive(:content_types).with(limit: 1000) { {} }
         client.update_dynamic_entry_cache!
-        expect(client).to have_received.content_types(limit: 1000)
       end
 
       it 'will save dynamic entries in @dynamic_entry_cache' do
         vcr('entry_cache')do
           client.update_dynamic_entry_cache!
         end
-        expect(client.dynamic_entry_cache).not_to be_empty
-        expect(client.dynamic_entry_cache.values.first.ancestors).to \
-            include Contentful::DynamicEntry
+        expect(Contentful::ContentTypeCache.cache).not_to be_empty
       end
     end
 
@@ -104,12 +98,9 @@ describe 'Client Configuration Options' do
 
       it 'can be used to register a dynamic entry manually' do
         cat = vcr('content_type') { client.content_type 'cat' }
-        CatEntry = Contentful::DynamicEntry.create(cat)
-        client.register_dynamic_entry 'cat', CatEntry
+        client.register_dynamic_entry 'cat', cat
 
-        entry = vcr('nyancat') { client.entry('nyancat') }
-        expect(entry).to be_a Contentful::DynamicEntry
-        expect(entry).to be_a CatEntry
+        expect(Contentful::ContentTypeCache.cache).not_to be_empty
       end
     end
   end
@@ -197,7 +188,6 @@ describe 'Client Configuration Options' do
   describe ':entry_mapping' do
     it 'lets you register your own entry classes for certain entry types' do
       class Cat < Contentful::Entry
-        # define methods based on :fields, etc
       end
 
       client = create_client(

data/spec/content_type_spec.rb

@@ -19,11 +19,6 @@ describe Contentful::ContentType do
   end
 
   describe 'Properties' do
-    it 'has a #properties getter returning a hash with symbol keys' do
-      expect(content_type.properties).to be_a Hash
-      expect(content_type.properties.keys.sample).to be_a Symbol
-    end
-
     it 'has #name' do
       expect(content_type.name).to eq 'Cat'
     end

data/spec/entry_spec.rb

@@ -46,20 +46,20 @@ describe Contentful::Entry do
 
     it "contains the entry's fields" do
       expect(entry.fields[:color]).to eq 'rainbow'
-      expect(entry.fields[:bestFriend]).to be_a Contentful::Link
+      expect(entry.fields[:best_friend]).to be_a Contentful::Entry
     end
   end
 
   describe 'multiple locales' do
     it 'can handle multiple locales' do
       vcr('entry_locales') {
-        cat = create_client.entries(locale: "*").items.first
-        expect(cat.fields('en-US')[:name]).to eq "Nyan Cat"
-        expect(cat.fields('es')[:name]).to eq "Gato Nyan"
+        nyancat = create_client.entries(locale: "*", 'sys.id' => 'nyancat').items.first
+        expect(nyancat.fields('en-US')[:name]).to eq "Nyan Cat"
+        expect(nyancat.fields('tlh')[:name]).to eq "Nyan vIghro'"
 
 
-        expect(cat.fields(:'en-US')[:name]).to eq "Nyan Cat"
-        expect(cat.fields(:es)[:name]).to eq "Gato Nyan"
+        expect(nyancat.fields(:'en-US')[:name]).to eq "Nyan Cat"
+        expect(nyancat.fields(:tlh)[:name]).to eq "Nyan vIghro'"
       }
     end
 
@@ -74,10 +74,10 @@ describe Contentful::Entry do
 
       it 'can handle entries with multiple locales' do
         vcr('entry_locales') {
-          nyancat = create_client.entries(locale: "*").items.first
+          nyancat = create_client.entries(locale: "*", 'sys.id' => 'nyancat').items.first
           expect(nyancat.fields_with_locales[:name].size).to eq(2)
           expect(nyancat.fields_with_locales[:name][:'en-US']).to eq("Nyan Cat")
-          expect(nyancat.fields_with_locales[:name][:es]).to eq("Gato Nyan")
+          expect(nyancat.fields_with_locales[:name][:tlh]).to eq("Nyan vIghro'")
         }
       end
 
@@ -128,133 +128,51 @@ describe Contentful::Entry do
   it '#raw' do
     vcr('entry/raw') {
       nyancat = create_client.entry('nyancat')
-      expect(nyancat.raw).to eq(create_client(raw_mode: true).entry('nyancat').object)
+      expect(nyancat.raw).to eq(create_client(raw_mode: true).entry('nyancat').object['items'].first)
     }
   end
 
-  describe 'custom resources' do
-    class Kategorie < Contentful::Entry
-      include ::Contentful::Resource::CustomResource
-
-      property :title
-      property :slug
-      property :image
-      property :top
-      property :subcategories
-      property :featuredArticles
-      property :catIntroHead
-      property :catIntroduction
-      property :seoText
-      property :metaKeywords
-      property :metaDescription
-      property :metaRobots
-    end
-
-    it 'maps fields properly' do
-      vcr('entry/custom_resource') {
-        entry = create_client(
-          space: 'g2b4ltw00meh',
-          dynamic_entries: :auto,
-          entry_mapping: {
-            'kategorie' => Kategorie
-          }
-        ).entries.first
-
-        expect(entry).to be_a Kategorie
-        expect(entry.title).to eq "Some Title"
-        expect(entry.slug).to eq "/asda.html"
-        expect(entry.featured_articles.first.is_a?(Contentful::Entry)).to be_truthy
-        expect(entry.top).to be_truthy
-      }
-    end
-
-    describe 'can be marshalled' do
-      class Cat < Contentful::Entry
-        include ::Contentful::Resource::CustomResource
-
-        property :name
-        property :lives
-        property :bestFriend, Cat
-        property :catPack
-        property :image, Contentful::Asset
-      end
-
-      def test_dump(nyancat)
-        dump = Marshal.dump(nyancat)
-        new_cat = Marshal.load(dump)
-
-        # Attributes
-        expect(new_cat).to be_a Cat
-        expect(new_cat.name).to eq "Nyan Cat"
-        expect(new_cat.lives).to eq 1337
-
-        # Single linked objects
-        expect(new_cat.best_friend).to be_a Cat
-        expect(new_cat.best_friend.name).to eq "Happy Cat"
+  describe 'can be marshalled' do
+    def test_dump(nyancat)
+      dump = Marshal.dump(nyancat)
+      new_cat = Marshal.load(dump)
 
-        # Array of linked objects
-        expect(new_cat.cat_pack.count).to eq 2
-        expect(new_cat.cat_pack[0].name).to eq "Happy Cat"
-        expect(new_cat.cat_pack[1].name).to eq "Worried Cat"
+      # Attributes
+      expect(new_cat).to be_a Contentful::Entry
+      expect(new_cat.name).to eq "Nyan Cat"
+      expect(new_cat.lives).to eq 1337
 
-        # Nested Links
-        expect(new_cat.best_friend.best_friend).to be_a Cat
-        expect(new_cat.best_friend.best_friend.name).to eq "Worried Cat"
+      # Single linked objects
+      expect(new_cat.best_friend).to be_a Contentful::Entry
+      expect(new_cat.best_friend.name).to eq "Happy Cat"
 
-        # Nested array of linked objects
-        expect(new_cat.best_friend.cat_pack.count).to eq 2
-        expect(new_cat.best_friend.cat_pack[0].name).to eq "Nyan Cat"
-        expect(new_cat.best_friend.cat_pack[1].name).to eq "Worried Cat"
+      # Array of linked objects
+      expect(new_cat.cat_pack.count).to eq 2
+      expect(new_cat.cat_pack[0].name).to eq "Happy Cat"
+      expect(new_cat.cat_pack[1].name).to eq "Worried Cat"
 
-        # Array of linked objects in a nested array of linked objects
-        expect(new_cat.cat_pack.first.name).to eq "Happy Cat"
-        expect(new_cat.cat_pack.first.cat_pack[0].name).to eq "Nyan Cat"
-        expect(new_cat.cat_pack.first.cat_pack[1].name).to eq "Worried Cat"
+      # Nested Links
+      expect(new_cat.best_friend.best_friend).to be_a Contentful::Entry
+      expect(new_cat.best_friend.best_friend.name).to eq "Nyan Cat"
 
-        expect(new_cat.image.file.url).to eq "//images.contentful.com/cfexampleapi/4gp6taAwW4CmSgumq2ekUm/9da0cd1936871b8d72343e895a00d611/Nyan_cat_250px_frame.png"
-      end
-
-      it 'using entry_mapping' do
-        vcr('entry/marshall') {
-          nyancat = create_client(entry_mapping: {'cat' => Cat}).entries(include: 2, 'sys.id' => 'nyancat').first
-          test_dump(nyancat)
-        }
-      end
-
-      it 'using resource_mapping' do
-        vcr('entry/marshall') {
-          nyancat = create_client(resource_mapping: {
-            'Entry' => ->(_json_object) do
-              return Cat if _json_object.fetch('sys', {}).fetch('contentType', {}).fetch('sys', {}).fetch('id', nil) == 'cat'
-              Contentful::Entry
-            end
-          }).entries(include: 2, 'sys.id' => 'nyancat').first
-          test_dump(nyancat)
-        }
-      end
+      # Asset
+      expect(new_cat.image.file.url).to eq "//images.contentful.com/cfexampleapi/4gp6taAwW4CmSgumq2ekUm/9da0cd1936871b8d72343e895a00d611/Nyan_cat_250px_frame.png"
+    end
 
-      it 'can remarshall an unmarshalled object' do
-        vcr('entry/marshall') {
-          nyancat = create_client(resource_mapping: {
-            'Entry' => ->(_json_object) do
-              return Cat if _json_object.fetch('sys', {}).fetch('contentType', {}).fetch('sys', {}).fetch('id', nil) == 'cat'
-              Contentful::Entry
-            end
-          }).entries(include: 2, 'sys.id' => 'nyancat').first
-
-          # The double load/dump is on purpose
-          test_dump(Marshal.load(Marshal.dump(nyancat)))
-        }
-      end
+    it 'marshals properly' do
+      vcr('entry/marshall') {
+        nyancat = create_client(gzip_encoded: false, max_include_resolution_depth: 2).entries(include: 2, 'sys.id' => 'nyancat').first
+        test_dump(nyancat)
+      }
+    end
 
-      it 'newly created custom resources have property mappings' do
-        entry = Cat.new
+    it 'can remarshall an unmarshalled object' do
+      vcr('entry/marshall') {
+        nyancat = create_client(max_include_resolution_depth: 2).entries(include: 2, 'sys.id' => 'nyancat').first
 
-        expect(entry).to respond_to :name
-        expect(entry).to respond_to :lives
-        expect(entry).to respond_to :best_friend
-        expect(entry).to respond_to :cat_pack
-      end
+        # The double load/dump is on purpose
+        test_dump(Marshal.load(Marshal.dump(nyancat)))
+      }
     end
   end
 
@@ -314,15 +232,102 @@ describe Contentful::Entry do
     end
   end
 
+  describe 'include resolution' do
+    it 'defaults to 20 depth' do
+      vcr('entry/include_resolution') {
+        entry = create_client.entry('nyancat', include: 2)
+
+        expect(entry.best_friend.name).to eq 'Happy Cat'
+        expect(entry
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend.name).to eq 'Nyan Cat'
+
+        expect(entry
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend.best_friend
+               .best_friend).to be_a ::Contentful::Link
+      }
+    end
+
+    it 'can be configured arbitrarily' do
+      vcr('entry/include_resolution') {
+        entry = create_client(max_include_resolution_depth: 3).entry('nyancat', include: 2)
+
+        expect(entry.best_friend.name).to eq 'Happy Cat'
+        expect(entry
+               .best_friend.best_friend
+               .best_friend.name).to eq 'Happy Cat'
+        expect(entry
+               .best_friend.best_friend
+               .best_friend.best_friend).to be_a ::Contentful::Link
+      }
+    end
+  end
+
   describe 'issues' do
     it 'Symbol/Text field with null values should be serialized as nil - #117' do
       vcr('entries/issue_117') {
-        client = create_client(space: '8jbbayggj9gj', access_token: '4ce0108f04e55c76476ba84ab0e6149734db73d67cd1b429323ef67f00977e07', dynamic_entries: :auto)
+        client = create_client(space: '8jbbayggj9gj', access_token: '4ce0108f04e55c76476ba84ab0e6149734db73d67cd1b429323ef67f00977e07')
         entry = client.entries.first
 
         expect(entry.nil).to be_nil
         expect(entry.nil).not_to eq ''
       }
     end
+
+    describe 'JSON Fields should not be treated as locale data - #96' do
+      before do
+        vcr('entry/json_objects_client') {
+          @client = create_client(
+            space: 'h425t6gef30p',
+            access_token: '278f7aa72f2eb90c0e002d60f85bf2144c925acd2d37dd990d3ca274f25076cf',
+            dynamic_entries: :auto
+          )
+
+        }
+        vcr('entry/json_objects') {
+          @entry = @client.entries.first
+        }
+      end
+
+      it 'only has default locale' do
+        expect(@entry.locales).to eq ['en-US']
+      end
+
+      it 'can obtain all values properly' do
+        expect(@entry.name).to eq('Test')
+        expect(@entry.object_test).to eq({
+          null: nil,
+          text: 'some text',
+          array: [1, 2, 3],
+          number: 123,
+          boolean: true,
+          object: {
+            null: nil,
+            text: 'bar',
+            array: [1, 2, 3],
+            number: 123,
+            boolean: false,
+            object: {foo: 'bar'}
+          }
+        })
+      end
+    end
   end
 end