kontent-delivery-sdk-ruby 2.0.21 → 2.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a50d5e5d2aeccb6c3c46776716ecada32555b335f60bffa29fa71e50e67ac13
-  data.tar.gz: c7f7ee90d20ffc94c82ec6696f2b3d041d9d9582634baaa83e57355151361498
+  metadata.gz: b93d8bae053c876e19256fc6695fa2dd593dc9479f89da1ede61ec166316a0cb
+  data.tar.gz: 21721f7c4105cc9c07e62009b01b5d380f485082d807a1337002d44eaebc52fc
 SHA512:
-  metadata.gz: b622ce5287519b7cea0b7a93f27c66f80a677711c71a74ccc988fb901bdfb95348f8fedc1b5fa94b1c46992a82ffd16e72bf15dce75480ae6b7e8c65d7994e3a
-  data.tar.gz: 197b327d60da93856f53330ebf43488ea3f59087db90c52c7385dbbb293d57758689b214296943b9d924d2c2ddf1944a2c8a26475bd8790488bf15fa1b481d56
+  metadata.gz: 8df410c1f68405b40824f82fe7ac866de358e8df90042419bc52406807bd89610adabdbd5dcaf8c4a9bf751bc56882ff670c2d4c704bd1bc5e21ee49bea8927a
+  data.tar.gz: 15b2ebbe2e3a98b5a4f5e66e6d7af39c04c6db4d8652cd061f9bf9c0824c4dda87e522f4e7d4b812d2e84a378e9348e2a62c132018ad8032fb6b01b1801be750

data/README.md

@@ -18,22 +18,24 @@ See [How to setup a development environment on Windows](https://github.com/Kenti
   - [Previewing unpublished content](#previewing-unpublished-content)
   - [Making secure requests](#making-secure-requests)
   - [Retry policy](#retry-policy)
+  - [Custom URLs](#custom-urls)
 - [Listing items](#listing-items)
   - [Filtering](#filtering)
   - [Parameters](#parameters)
   - [Responses](#responses)
   - [Requesting the latest content](#requesting-the-latest-content)
   - [Providing custom headers](#providing-custom-headers)
-  - [Custom URLs](#custom-urls)
-- [Assets](#assets)
-- [Linked items](#linked-items)
-- [Pagination](#pagination)
+  - [Pagination](#pagination)
+- [Working with content items](#working-with-content-items)
+  - [Assets](#assets)
+  - [Linked items](#linked-items)
+  - [Resolving inline content](#resolving-inline-content)
+  - [Resolving links](#resolving-links)
 - [Items feed](#items-feed)
 - [Retrieving content types](#retrieving-content-types)
-- [Taxonomy](#taxonomy)
+- [Retrieving taxonomy](#retrieving-taxonomy)
 - [Retrieving content type elements](#retrieving-content-type-elements)
-- [Resolving links](#resolving-links)
-- [Resolving inline content](#resolving-inline-content)
+- [Retrieving languages](#retrieving-languages)
 - [Image transformation](#image-transformation)
 
 ## Installation
@@ -120,6 +122,18 @@ Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>',
                                            with_retry_policy: false
 ```
 
+### Custom URLs
+
+When you have a URL (i.e. `next_page` for paging, for testing purposes, or if you prefer to build it on your own) and still want to leverage SDK functionality such as rich text resolving, use the .url method:
+
+```ruby
+delivery_client.items
+  .url('https://deliver.kontent.ai/<your-project-id>/items?system.type=grinder')
+  .execute do |response|
+    # Do something
+  end
+```
+
 ## Listing items
 
 
@@ -264,19 +278,33 @@ delivery_client.items
   .execute
 ```
 
-### Custom URLs
+### Pagination
 
-When you have a URL (i.e. `next_page` for paging, for testing purposes, or if you prefer to build it on your own) and still want to leverage SDK functionality such as rich text resolving, use the .url method:
+Most responses also contain a `pagination` attribute to access the [paging](https://docs.kontent.ai/reference/delivery-api#operation/list-content-items "paging") data for the Delivery query. This object contains the following attributes:
+
+- **skip**
+- **limit**
+- **count**
+- **next_page**
+- **total_count** (only if `include_total_count` is called)
+
+For example, to access the next page URL you can use:
 
 ```ruby
 delivery_client.items
-  .url('https://deliver.kontent.ai/<your-project-id>/items?system.type=grinder')
-  .execute do |response|
-    # Do something
-  end
+    .skip(0)
+    .limit(5)
+    .include_total_count
+    .execute do |response|
+      next_page_url = response.pagination.next_page
+    end
 ```
 
-## Assets
+:warning: Note that using the `include_total_count` method may increase the response time and should only be used if necessary.
+
+## Working with content items
+
+### Assets
 
 You can use `.get_assets(code_name)` to get one or more assets from the specified element. This method will always return an array, so use `.first` to get the first asset:
 
@@ -284,7 +312,7 @@ You can use `.get_assets(code_name)` to get one or more assets from the specifie
 url = response.item.get_assets('teaser_image').first.url
 ```
 
-## Linked items
+### Linked items
 
 You can get a simple array of code names by accessing the element's value:
 
@@ -299,30 +327,120 @@ response.item.get_links('facts').each do |link|
   title = link.elements.title.value
 end
 ```
+### Resolving inline content
 
-## Pagination
+Existing content items can be inserted into a rich text element, or you can create new content items as components. You need to resolve these in your application just as with content links. You can register a resolver when you instantiate the client by passing it with the hash key `inline_content_item_resolver`:
 
-The `DeliveryItemListingResponse` also contains a `pagination` attribute to access the [paging](https://docs.kontent.ai/reference/delivery-api#operation/list-content-items "paging") data for the Delivery query. This object contains the following attributes:
+```ruby
+item_resolver = Kentico::Kontent::Delivery::Resolvers::InlineContentItemResolver.new(lambda do |item|
+      return "<h1>#{item.elements.zip_code.value}</h1>" if item.system.type.eql? 'cafe'
+      return "<div>$#{item.elements.price.value}</div>" if item.system.type.eql? 'brewer'
+    end)
+delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>',
+                                                             inline_content_item_resolver: item_resolver
+```
 
-- **skip**
-- **limit**
-- **count**
-- **next_page**
-- **total_count** (only if `include_total_count` is called)
+The object passed to the resolving method is a complete ContentItem. Similar to content link resolvers, you can create your own class which extends `Kentico::Kontent::Delivery::Resolvers::InlineContentItemResolver` and implements the `resolve_item` method:
 
-For example, to access the next page URL you can use:
+```ruby
+class MyItemResolver < Kentico::Kontent::Delivery::Resolvers::InlineContentItemResolver
+  def resolve_item(item)
+    return "<h1>#{item.elements.zip_code.value}</h1>" if item.system.type.eql? 'cafe'
+    return "<div>$#{item.elements.price.value}</div>" if item.system.type.eql? 'brewer'
+  end
+end
+```
+
+You can also set the inline content resolver per-query:
 
 ```ruby
+delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>'
+# Client doesn't use InlineContentItemResolver, but query below will
 delivery_client.items
-    .skip(0)
-    .limit(5)
-    .include_total_count
-    .execute do |response|
-      next_page_url = response.pagination.next_page
-    end
+               .with_inline_content_item_resolver MyItemResolver.new
 ```
 
-:warning: Note that using the `include_total_count` method may increase the response time and should only be used if necessary.
+To resolve inline content in elements, you must call `get_string` similar to content item links:
+
+```ruby
+item_resolver = Kentico::Kontent::Delivery::Resolvers::InlineContentItemResolver.new(lambda do |item|
+  return "<div>$#{item.elements.price.value}</div>" if item.system.type.eql? 'brewer'
+end)
+delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: PROJECT_ID,
+                                                    inline_content_item_resolver: item_resolver
+delivery_client.item('our_brewers').execute do |response|
+  text = response.item.get_string 'body_copy'
+end
+```
+
+### Resolving links
+
+If a rich text element contains links to other content items, you will need to generate the URLs to those items. You can do this by registering a `Kentico::Kontent::Delivery::Resolvers::ContentLinkResolver` when you instantiate the DeliveryClient. When you create a ContentLinkResolver, you must pass a method that will return the URL, and you may pass another method that will be called if the content contains a link, but the content item is not present in the response:
+
+```ruby
+link_resolver = Kentico::Kontent::Delivery::Resolvers::ContentLinkResolver.new(lambda do |link|
+        # Link valid
+        return "/coffees/#{link.url_slug}" if link.type.eql? 'coffee'
+        return "/brewers/#{link.url_slug}" if link.type.eql? 'brewer'
+      end, lambda do |id|
+        # Link broken
+        return "/notfound?id=#{id}"
+      end)
+delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>',
+                                                             content_link_url_resolver: link_resolver
+```
+
+You can also build the logic for your resolver in a separate class and register an instance of that class in the DeliveryClient. The class must extend `Kentico::Kontent::Delivery::Resolvers::ContentLinkResolver` and contain a `resolve_link(link)` method, as well as the `resolve_404(id)` method for broken links. For example, you can create `MyLinkResolver.rb`:
+
+```ruby
+class MyLinkResolver < Kentico::Kontent::Delivery::Resolvers::ContentLinkResolver
+  def resolve_link(link)
+    return "/coffees/#{link.url_slug}" if link.type.eql? 'coffee'
+    return "/brewers/#{link.url_slug}" if link.type.eql? 'brewer'
+  end
+
+  def resolve_404(id)
+    "/notfound?id=#{id}"
+  end
+end
+```
+
+Then create an object of this class when instantiating the DeliveryClient:
+
+```ruby
+delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>',
+                                                             content_link_url_resolver: MyLinkResolver.new
+```
+
+You can pass a `ContentLinkResolver` to the DeliveryQuery instead of the client if you only want to resolve links for that query, or they should be resolved differently:
+
+```ruby
+delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>'
+# Client doesn't use ContentLinkResolver, but query below will
+delivery_client.items
+               .with_link_resolver MyLinkResolver.new
+```
+
+The `ContentLink` object that is passed to your resolver contains the following attributes:
+
+- **id**: the system.id of the linked content item
+- **code_name**: the system.codename of the linked content item
+- **type**: the content type of the linked content item
+- **url_slug**: the URL slug of the linked content item, or nil if there is none
+
+To resolve links in rich text elements, you must retrieve the text using `get_string`:
+
+```ruby
+item_resolver = Kentico::Kontent::Delivery::Resolvers::ContentLinkResolver.new(lambda do |link|
+  return "/coffees/#{link.url_slug}" if link.type.eql? 'coffee'
+  return "/brewers/#{link.url_slug}" if link.type.eql? 'brewer'
+end)
+delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>',
+                                                             content_link_url_resolver: item_resolver
+delivery_client.item('coffee_processing_techniques').execute do |response|
+  text = response.item.get_string 'body_copy'
+end
+```
 
 ## Items feed
 
@@ -357,8 +475,6 @@ delivery_client.type('coffee').execute do |response|
 end
 ```
 
-### Responses
-
 As with content item queries, all content type queries will return a `Kentico::Kontent::Delivery::Responses::ResponseBase` of the class `DeliveryTypeResponse` or `DeliveryTypeListingResponse` for single and multiple type queries, respectively.
 
 For multiple type queries, you can access the array of `ContentType` objects at `.types`, and at `.type` for singe type queries. You can access information about the type(s) dynamically:
@@ -370,7 +486,7 @@ end
 ```
 The DeliveryTypeListingResponse also contains pagination data, similar to DeliveryItemListingResponse.
 
-## Taxonomy
+## Retrieving taxonomy
 
 Use the `.taxonomies` and `.taxonomy(code_name)` endpoints to get information about the taxonomy in your project:
 
@@ -427,118 +543,21 @@ This returns a `Kentico::Kontent::Delivery::Responses::DeliveryElementResponse`
 
 The element will always contain __codename__, __type__, and __name__, but multiple choice elements will also contain __options__ and taxonomy elements will contain __taxonomy_group__. The Ruby SDK fully supports obtaining [custom elements](https://docs.kontent.ai/reference/custom-elements-js-api) using this approach and any other methods.
 
-## Resolving links
-
-If a rich text element contains links to other content items, you will need to generate the URLs to those items. You can do this by registering a `Kentico::Kontent::Delivery::Resolvers::ContentLinkResolver` when you instantiate the DeliveryClient. When you create a ContentLinkResolver, you must pass a method that will return the URL, and you may pass another method that will be called if the content contains a link, but the content item is not present in the response:
-
-```ruby
-link_resolver = Kentico::Kontent::Delivery::Resolvers::ContentLinkResolver.new(lambda do |link|
-        # Link valid
-        return "/coffees/#{link.url_slug}" if link.type.eql? 'coffee'
-        return "/brewers/#{link.url_slug}" if link.type.eql? 'brewer'
-      end, lambda do |id|
-        # Link broken
-        return "/notfound?id=#{id}"
-      end)
-delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>',
-                                                             content_link_url_resolver: link_resolver
-```
-
-You can also build the logic for your resolver in a separate class and register an instance of that class in the DeliveryClient. The class must extend `Kentico::Kontent::Delivery::Resolvers::ContentLinkResolver` and contain a `resolve_link(link)` method, as well as the `resolve_404(id)` method for broken links. For example, you can create `MyLinkResolver.rb`:
-
-```ruby
-class MyLinkResolver < Kentico::Kontent::Delivery::Resolvers::ContentLinkResolver
-  def resolve_link(link)
-    return "/coffees/#{link.url_slug}" if link.type.eql? 'coffee'
-    return "/brewers/#{link.url_slug}" if link.type.eql? 'brewer'
-  end
-
-  def resolve_404(id)
-    "/notfound?id=#{id}"
-  end
-end
-```
-
-Then create an object of this class when instantiating the DeliveryClient:
-
-```ruby
-delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>',
-                                                             content_link_url_resolver: MyLinkResolver.new
-```
-
-You can pass a `ContentLinkResolver` to the DeliveryQuery instead of the client if you only want to resolve links for that query, or they should be resolved differently:
-
-```ruby
-delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>'
-# Client doesn't use ContentLinkResolver, but query below will
-delivery_client.items
-               .with_link_resolver MyLinkResolver.new
-```
-
-The `ContentLink` object that is passed to your resolver contains the following attributes:
-
-- **id**: the system.id of the linked content item
-- **code_name**: the system.codename of the linked content item
-- **type**: the content type of the linked content item
-- **url_slug**: the URL slug of the linked content item, or nil if there is none
-
-To resolve links in rich text elements, you must retrieve the text using `get_string`:
-
-```ruby
-item_resolver = Kentico::Kontent::Delivery::Resolvers::ContentLinkResolver.new(lambda do |link|
-  return "/coffees/#{link.url_slug}" if link.type.eql? 'coffee'
-  return "/brewers/#{link.url_slug}" if link.type.eql? 'brewer'
-end)
-delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>',
-                                                             content_link_url_resolver: item_resolver
-delivery_client.item('coffee_processing_techniques').execute do |response|
-  text = response.item.get_string 'body_copy'
-end
-```
-
-## Resolving inline content
-
-Existing content items can be inserted into a rich text element, or you can create new content items as components. You need to resolve these in your application just as with content links. You can register a resolver when you instantiate the client by passing it with the hash key `inline_content_item_resolver`:
+## Retrieving languages
 
-```ruby
-item_resolver = Kentico::Kontent::Delivery::Resolvers::InlineContentItemResolver.new(lambda do |item|
-      return "<h1>#{item.elements.zip_code.value}</h1>" if item.system.type.eql? 'cafe'
-      return "<div>$#{item.elements.price.value}</div>" if item.system.type.eql? 'brewer'
-    end)
-delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>',
-                                                             inline_content_item_resolver: item_resolver
-```
-
-The object passed to the resolving method is a complete ContentItem. Similar to content link resolvers, you can create your own class which extends `Kentico::Kontent::Delivery::Resolvers::InlineContentItemResolver` and implements the `resolve_item` method:
+Use the `.languages` method to list all of the languages in the project:
 
 ```ruby
-class MyItemResolver < Kentico::Kontent::Delivery::Resolvers::InlineContentItemResolver
-  def resolve_item(item)
-    return "<h1>#{item.elements.zip_code.value}</h1>" if item.system.type.eql? 'cafe'
-    return "<div>$#{item.elements.price.value}</div>" if item.system.type.eql? 'brewer'
-  end
+delivery_client.languages.execute do |response|
+  puts response.languages.length # number of languages
 end
 ```
 
-You can also set the inline content resolver per-query:
-
-```ruby
-delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: '<your-project-id>'
-# Client doesn't use InlineContentItemResolver, but query below will
-delivery_client.items
-               .with_inline_content_item_resolver MyItemResolver.new
-```
-
-To resolve inline content in elements, you must call `get_string` similar to content item links:
+The response is a `Kentico::Kontent::Delivery::Responses::DeliveryLanguageListingResponse` where `languages` is an array of all langauges. You can access the system properties of each language as they are returned by Kontent:
 
 ```ruby
-item_resolver = Kentico::Kontent::Delivery::Resolvers::InlineContentItemResolver.new(lambda do |item|
-  return "<div>$#{item.elements.price.value}</div>" if item.system.type.eql? 'brewer'
-end)
-delivery_client = Kentico::Kontent::Delivery::DeliveryClient.new project_id: PROJECT_ID,
-                                                    inline_content_item_resolver: item_resolver
-delivery_client.item('our_brewers').execute do |response|
-  text = response.item.get_string 'body_copy'
+delivery_client.languages.execute do |response|
+  puts response.languages[0].system.codename # en-us
 end
 ```
 

data/lib/delivery/builders/image_transformation_builder.rb

@@ -128,6 +128,7 @@ module Kentico
             @query_string.remove_param 'fp-x'
             @query_string.remove_param 'fp-y'
             @query_string.remove_param 'fp-z'
+            @query_string.remove_param 'fit'
             @query_string.remove_param 'crop'
             @query_string.set_param 'rect', "#{x},#{y},#{width},#{height}"
             self

data/lib/delivery/builders/url_builder.rb

@@ -14,6 +14,7 @@ module Kentico
           URL_TEMPLATE_TAXONOMY = '/taxonomies/%s'.freeze
           URL_TEMPLATE_TAXONOMIES = '/taxonomies'.freeze
           URL_TEMPLATE_ITEMS_FEED = '/items-feed'.freeze
+          URL_TEMPLATE_LANGUAGES = '/languages'.freeze
 
           URL_MAX_LENGTH = 65_519
           MSG_LONG_QUERY = 'The request url is too long. Split your query into multiple calls.'.freeze
@@ -66,6 +67,8 @@ module Kentico
                 provide_type query
               when Kentico::Kontent::Delivery::QUERY_TYPE_TAXONOMIES
                 provide_taxonomy query
+              when Kentico::Kontent::Delivery::QUERY_TYPE_LANGUAGES
+                URL_TEMPLATE_LANGUAGES
               when Kentico::Kontent::Delivery::QUERY_TYPE_ELEMENT
                 format(URL_TEMPLATE_ELEMENTS, query.content_type, query.code_name)
               when Kentico::Kontent::Delivery::QUERY_TYPE_ITEMS_FEED

data/lib/delivery/client/delivery_client.rb

@@ -11,6 +11,7 @@ module Kentico
       QUERY_TYPE_TAXONOMIES = 'QUERY_TYPE_TAXONOMIES'.freeze
       QUERY_TYPE_ELEMENT = 'QUERY_TYPE_ELEMENT'.freeze
       QUERY_TYPE_ITEMS_FEED = 'QUERY_TYPE_ITEMS_FEED'.freeze
+      QUERY_TYPE_LANGUAGES = 'QUERY_TYPE_LANGUAGES'.freeze
 
       # Executes requests against the Kentico Kontent Delivery API.
       class DeliveryClient
@@ -170,6 +171,13 @@ module Kentico
                             query_type: QUERY_TYPE_ELEMENT,
                             with_retry_policy: @with_retry_policy
         end
+
+        def languages
+          DeliveryQuery.new project_id: @project_id,
+                            secure_key: @secure_key,
+                            query_type: QUERY_TYPE_LANGUAGES,
+                            with_retry_policy: @with_retry_policy
+        end
       end
     end
   end

data/lib/delivery/client/request_manager.rb

@@ -85,6 +85,8 @@ module Kentico
               respond_taxonomy response
             when Kentico::Kontent::Delivery::QUERY_TYPE_ELEMENT
               Kentico::Kontent::Delivery::Responses::DeliveryElementResponse.new response.headers, response.body
+            when Kentico::Kontent::Delivery::QUERY_TYPE_LANGUAGES
+              Kentico::Kontent::Delivery::Responses::DeliveryLanguageListingResponse.new response.headers, response.body
             end
           end
 

data/lib/delivery/models/language.rb

@@ -0,0 +1,29 @@
+require 'ostruct'
+
+module Kentico
+  module Kontent
+    module Delivery
+      class Language
+        # Parses the 'system' JSON object as a dynamic OpenStruct object.
+        #
+        # * *Returns*:
+        #   - +OpenStruct+ The system properties of the language
+        def system
+          @system unless @system.nil?
+          @system = JSON.parse(
+            JSON.generate(@source['system']),
+            object_class: OpenStruct
+          )
+        end
+
+        # Constructor.
+        #
+        # * *Args*:
+        #   - *source* (+JSON+) The response from a REST request for a language
+        def initialize(source)
+          @source = source
+        end
+      end
+    end
+  end
+end

data/lib/delivery/responses/delivery_language_listing_response.rb

@@ -0,0 +1,44 @@
+require 'delivery/models/language'
+require 'delivery/responses/response_base'
+
+module Kentico
+  module Kontent
+    module Delivery
+      module Responses
+        # The response of a successful query for project languages.
+        class DeliveryLanguageListingResponse < ResponseBase
+          # Parses the 'pagination' JSON node of the response.
+          #
+          # * *Returns*:
+          #   - Kentico::Kontent::Delivery::Pagination
+          def pagination
+            @pagination unless @pagination.nil?
+            @pagination = Pagination.new @response['pagination']
+          end
+
+          # Parses the 'languages' JSON node of the response from a
+          # Kentico::Kontent::Delivery::DeliveryClient.languages call.
+          #
+          # * *Returns*:
+          #   - +Array+ The content types as Kentico::Kontent::Delivery::Language objects
+          def languages
+            @languages unless @languages.nil?
+            languages = []
+            @response['languages'].each do |n|
+              languages << Kentico::Kontent::Delivery::Language.new(n)
+            end
+            @languages = languages
+          end
+
+          def initialize(headers, body)
+            @response = JSON.parse(body)
+            super 200,
+                  "Success, #{languages.length} languages returned",
+                  headers,
+                  JSON.generate(@response)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delivery/tests/generic/items/where_does_coffee_come_from_.json

@@ -8,7 +8,7 @@
       "type": "article",
       "collection": "default",
       "sitemap_locations": [],
-      "last_modified": "2019-03-27T13:07:32.29Z",
+      "last_modified": "2021-03-20T02:44:46.6377632Z",
       "workflow_step": "published"
     },
     "elements": {
@@ -47,8 +47,10 @@
         "name": "Body Copy",
         "images": {},
         "links": {},
-        "modular_content": [],
-        "value": "<p>The history of coffee is patchy and full of myth and hearsay.</p>\n<p>One of the most popular story goes that Kaldi, an Ethiopian goatherd, saw his goats eating coffee berries and as a result becoming elated. So, Kaldi then tried them himself and thus discovered the potential of coffee. And that's where we got our name - Dancing Goat.</p>\n<p>Although it's far more likely that uses for coffee were developed over time and were discovered by people tasting various parts of the cherry, &nbsp;the old fables do add a bit of romance and are very cute.</p>\n<p>Coffee requires a warm climate and lots of moisture, so it is produced within a belt extending around the world between the Tropic of Cancer and the Tropic of Capricorn.</p>\n<p>Coffee grows on trees that flower and produce fleshy red fruit (orange or yellow is also possible) called a drupe though it is popularly referred to as the ‘berry’ or ‘cherry’. What we refer to as coffee beans are actually seeds, which are produced in the centre of the drupe, often in pairs. After harvesting, the flesh of the drupe is washed or dried and the ‘beans’ extracted.</p>\n<p>Coffee beans vary in their shape, size, color as well as flavor depending on the region and conditions in which they were grown. The difference of aromas and flavors between various regional varietals is as vast as the regions they grow in. Just like the teas and wines of the world, and even more so. It is always worth trying new varietals that may stimulate your taste buds in a different way.</p>\n<p>The two major species of coffee are <em>Coffea arabica</em> and <em>Coffea canephora</em> (also called <em>Coffea robusta</em>).</p>\n<p>Arabica is believed to be the first species of coffee to have been cultivated.</p>\n<p>It requires more care during cultivation and is considered to produce better coffee than robusta. Arabica plants grow at high altitudes of around 1,000 to 2,000 meters, approximately 3,200 to 6,500 ft, above sea level in regions across South and Central America as well as Africa. Arabica is costlier to grow as it produces lower yields than Robusta despite requiring more labor. Despite all that, it is considered superior to robusta. The high demand and lower availability drives the price high. Arabica is the species most associated with specialty (sometimes referred to as gourmet) coffees.</p>\n<p>The only place where Arabica coffee grows indigenously is Ethiopia. It is the birthplace of coffee and also the only place in which it truly grows wild. All countries that produce Arabica coffees have transplanted plant stock directly from Ethiopia or from other countries that had already done so.</p>"
+        "modular_content": [
+          "london_"
+        ],
+        "value": "<object type=\"application/kenticocloud\" data-type=\"item\" data-rel=\"link\" data-codename=\"london_\"></object>\n<p>The history of coffee is patchy and full of myth and hearsay.</p>\n<p>One of the most popular story goes that Kaldi, an Ethiopian goatherd, saw his goats eating coffee berries and as a result becoming elated. So, Kaldi then tried them himself and thus discovered the potential of coffee. And that's where we got our name - Dancing Goat.</p>\n<p>Although it's far more likely that uses for coffee were developed over time and were discovered by people tasting various parts of the cherry, &nbsp;the old fables do add a bit of romance and are very cute.</p>\n<p>Coffee requires a warm climate and lots of moisture, so it is produced within a belt extending around the world between the Tropic of Cancer and the Tropic of Capricorn.</p>\n<p>Coffee grows on trees that flower and produce fleshy red fruit (orange or yellow is also possible) called a drupe though it is popularly referred to as the ‘berry’ or ‘cherry’. What we refer to as coffee beans are actually seeds, which are produced in the centre of the drupe, often in pairs. After harvesting, the flesh of the drupe is washed or dried and the ‘beans’ extracted.</p>\n<p>Coffee beans vary in their shape, size, color as well as flavor depending on the region and conditions in which they were grown. The difference of aromas and flavors between various regional varietals is as vast as the regions they grow in. Just like the teas and wines of the world, and even more so. It is always worth trying new varietals that may stimulate your taste buds in a different way.</p>\n<p>The two major species of coffee are <em>Coffea arabica</em> and <em>Coffea canephora</em> (also called <em>Coffea robusta</em>).</p>\n<p>Arabica is believed to be the first species of coffee to have been cultivated.</p>\n<p>It requires more care during cultivation and is considered to produce better coffee than robusta. Arabica plants grow at high altitudes of around 1,000 to 2,000 meters, approximately 3,200 to 6,500 ft, above sea level in regions across South and Central America as well as Africa. Arabica is costlier to grow as it produces lower yields than Robusta despite requiring more labor. Despite all that, it is considered superior to robusta. The high demand and lower availability drives the price high. Arabica is the species most associated with specialty (sometimes referred to as gourmet) coffees.</p>\n<p>The only place where Arabica coffee grows indigenously is Ethiopia. It is the birthplace of coffee and also the only place in which it truly grows wild. All countries that produce Arabica coffees have transplanted plant stock directly from Ethiopia or from other countries that had already done so.</p>"
       },
       "related_articles": {
         "type": "modular_content",
@@ -172,6 +174,86 @@
     }
   },
   "modular_content": {
+    "london_": {
+      "system": {
+        "id": "473cd60b-a2a7-4e5b-8353-5d1995dd4b50",
+        "name": "London",
+        "codename": "london_",
+        "language": "en-US",
+        "type": "cafe",
+        "collection": "default",
+        "sitemap_locations": [],
+        "last_modified": "2019-03-27T13:19:05.507Z",
+        "workflow_step": "published"
+      },
+      "elements": {
+        "street": {
+          "type": "text",
+          "name": "Street",
+          "value": "344 King's Road"
+        },
+        "city": {
+          "type": "text",
+          "name": "City",
+          "value": "London"
+        },
+        "country": {
+          "type": "text",
+          "name": "Country",
+          "value": "United Kingdom"
+        },
+        "state": {
+          "type": "text",
+          "name": "State",
+          "value": ""
+        },
+        "zip_code": {
+          "type": "text",
+          "name": "ZIP Code",
+          "value": "SW3 5UR"
+        },
+        "phone": {
+          "type": "text",
+          "name": "Phone",
+          "value": "0173-733-6375"
+        },
+        "email": {
+          "type": "text",
+          "name": "Email",
+          "value": "London@localhost.local"
+        },
+        "photo": {
+          "type": "asset",
+          "name": "Photo",
+          "value": [
+            {
+              "name": "cafe01.jpg",
+              "description": "Dancing Goat Café - London",
+              "type": "image/jpeg",
+              "size": 493724,
+              "url": "https://assets-us-01.kc-usercontent.com:443/cbb8fcc6-9201-000d-a115-b1050abd8f34/8fccb3b9-a507-48cc-bccd-0639d7fb69ec/cafe01.jpg",
+              "width": 849,
+              "height": 565
+            }
+          ]
+        },
+        "sitemap": {
+          "type": "taxonomy",
+          "name": "Sitemap",
+          "taxonomy_group": "sitemap_538125f",
+          "value": [
+            {
+              "name": "Cafes",
+              "codename": "cafes"
+            },
+            {
+              "name": "Europe",
+              "codename": "europe"
+            }
+          ]
+        }
+      }
+    },
     "on_roasts": {
       "system": {
         "id": "f4b3fc05-e988-4dae-9ac1-a94aba566474",

data/lib/delivery/tests/generic/languages.json

@@ -0,0 +1,24 @@
+{
+    "languages": [
+      {
+        "system": {
+          "id": "00000000-0000-0000-0000-000000000000",
+          "name": "English (United States)",
+          "codename": "en-US"
+        }
+      },
+      {
+        "system": {
+          "id": "d1f95fde-af02-b3b5-bd9e-f232311ccab8",
+          "name": "Spanish (Spain)",
+          "codename": "es-ES"
+        }
+      }
+    ],
+    "pagination": {
+      "skip": 0,
+      "limit": 0,
+      "count": 2,
+      "next_page": ""
+    }
+  }

data/lib/delivery/tests/generic/taxonomies/manufacturer.json

@@ -0,0 +1,30 @@
+{
+    "system": {
+      "id": "4ce421e9-c403-eee8-fdc2-74f09392a749",
+      "name": "Manufacturer",
+      "codename": "manufacturer",
+      "last_modified": "2017-09-07T08:15:22.7210000Z"
+    },
+    "terms": [
+      {
+        "name": "Aerobie",
+        "codename": "aerobie",
+        "terms": []
+      },
+      {
+        "name": "Chemex",
+        "codename": "chemex",
+        "terms": []
+      },
+      {
+        "name": "Espro",
+        "codename": "espro",
+        "terms": []
+      },
+      {
+        "name": "Hario",
+        "codename": "hario",
+        "terms": []
+      }
+    ]
+  }

data/lib/delivery/tests/generic/types/brewer.json

@@ -0,0 +1,89 @@
+{
+    "system": {
+      "id": "7bc932b3-ce2a-4aa7-954e-04cbcbd214fc",
+      "name": "Brewer",
+      "codename": "brewer",
+      "last_modified": "2019-07-16T07:15:27.5660000Z"
+    },
+    "elements": {
+      "product_name": {
+        "type": "text",
+        "name": "Product name"
+      },
+      "metadata__og_description": {
+        "type": "text",
+        "name": "og:description"
+      },
+      "metadata__meta_title": {
+        "type": "text",
+        "name": "Meta title"
+      },
+      "long_description": {
+        "type": "rich_text",
+        "name": "Long description"
+      },
+      "metadata__og_title": {
+        "type": "text",
+        "name": "og:title"
+      },
+      "metadata__meta_description": {
+        "type": "text",
+        "name": "Meta description"
+      },
+      "metadata__twitter_site": {
+        "type": "text",
+        "name": "twitter:site"
+      },
+      "price": {
+        "type": "number",
+        "name": "Price"
+      },
+      "manufacturer": {
+        "type": "taxonomy",
+        "name": "Manufacturer",
+        "taxonomy_group": "manufacturer"
+      },
+      "metadata__twitter_image": {
+        "type": "asset",
+        "name": "twitter:image"
+      },
+      "metadata__twitter_creator": {
+        "type": "text",
+        "name": "twitter:creator"
+      },
+      "url_pattern": {
+        "type": "url_slug",
+        "name": "URL pattern"
+      },
+      "sitemap": {
+        "type": "taxonomy",
+        "name": "Sitemap",
+        "taxonomy_group": "sitemap_538125f"
+      },
+      "short_description": {
+        "type": "rich_text",
+        "name": "Short description"
+      },
+      "product_status": {
+        "type": "taxonomy",
+        "name": "Product status",
+        "taxonomy_group": "product_status"
+      },
+      "metadata__twitter_title": {
+        "type": "text",
+        "name": "twitter:title"
+      },
+      "metadata__twitter_description": {
+        "type": "text",
+        "name": "twitter:description"
+      },
+      "metadata__og_image": {
+        "type": "asset",
+        "name": "og:image"
+      },
+      "image": {
+        "type": "asset",
+        "name": "Image"
+      }
+    }
+  }

data/lib/kontent-delivery-sdk-ruby.rb

@@ -4,6 +4,7 @@ require File.dirname(__FILE__) + '/delivery/client/request_manager'
 require File.dirname(__FILE__) + '/delivery/models/content_item'
 require File.dirname(__FILE__) + '/delivery/models/content_type'
 require File.dirname(__FILE__) + '/delivery/models/taxonomy_group'
+require File.dirname(__FILE__) + '/delivery/models/language'
 require File.dirname(__FILE__) + '/delivery/query_parameters/filters'
 require File.dirname(__FILE__) + '/delivery/responses/delivery_item_listing_response'
 require File.dirname(__FILE__) + '/delivery/responses/delivery_item_response'
@@ -13,6 +14,7 @@ require File.dirname(__FILE__) + '/delivery/responses/delivery_taxonomy_listing_
 require File.dirname(__FILE__) + '/delivery/responses/delivery_taxonomy_response'
 require File.dirname(__FILE__) + '/delivery/responses/delivery_element_response'
 require File.dirname(__FILE__) + '/delivery/responses/delivery_items_feed_response'
+require File.dirname(__FILE__) + '/delivery/responses/delivery_language_listing_response'
 require File.dirname(__FILE__) + '/delivery/resolvers/content_link_resolver'
 require File.dirname(__FILE__) + '/delivery/resolvers/inline_content_item_resolver'
 require File.dirname(__FILE__) + '/delivery/resolvers/linked_item_resolver'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kontent-delivery-sdk-ruby
 version: !ruby/object:Gem::Version
-  version: 2.0.21
+  version: 2.0.22
 platform: ruby
 authors:
 - Eric Dugre
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-20 00:00:00.000000000 Z
+date: 2021-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dotenv
@@ -156,6 +156,7 @@ files:
 - lib/delivery/client/request_manager.rb
 - lib/delivery/models/content_item.rb
 - lib/delivery/models/content_type.rb
+- lib/delivery/models/language.rb
 - lib/delivery/models/pagination.rb
 - lib/delivery/models/taxonomy_group.rb
 - lib/delivery/query_parameters/filters.rb
@@ -168,6 +169,7 @@ files:
 - lib/delivery/responses/delivery_item_listing_response.rb
 - lib/delivery/responses/delivery_item_response.rb
 - lib/delivery/responses/delivery_items_feed_response.rb
+- lib/delivery/responses/delivery_language_listing_response.rb
 - lib/delivery/responses/delivery_taxonomy_listing_response.rb
 - lib/delivery/responses/delivery_taxonomy_response.rb
 - lib/delivery/responses/delivery_type_listing_response.rb
@@ -185,8 +187,11 @@ files:
 - lib/delivery/tests/generic/items/empty_rich_text.json
 - lib/delivery/tests/generic/items/rich_text_complex_tables.json
 - lib/delivery/tests/generic/items/where_does_coffee_come_from_.json
+- lib/delivery/tests/generic/languages.json
 - lib/delivery/tests/generic/taxonomies.json
+- lib/delivery/tests/generic/taxonomies/manufacturer.json
 - lib/delivery/tests/generic/types.json
+- lib/delivery/tests/generic/types/brewer.json
 - lib/delivery/tests/generic/types/brewer/elements/product_status.json
 - lib/delivery/tests/items_feed/articles_feed_1.json
 - lib/delivery/tests/items_feed/articles_feed_2.json