delivery-sdk-ruby 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 849e51845ec99d8e4e044b61fa4e66e490d05b8a269ceb92e1000f6cd60b79bd
+  data.tar.gz: e66ea8b3abefad47d8064144bd59d74c21357e73133ee4019ac9f080810a19f5
+SHA512:
+  metadata.gz: 99af342265d241b6f0c48dcc6f75ecc0e2640b8fe2f5f5c2ce0af56804b47eb74d101223a1566b17c8404a117b36b60370ddb1375fef26f852a441170da2d456
+  data.tar.gz: b0e24d2fb3e7accd44f4603e30c7b317aa5f03d3e09889c19b988a096d725337a7fabaec5134f212c3f32c49a5dcaf0e4d7beeb5a0733a85012134b5c043436e

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Eric Dugre
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,323 @@
+
+[![Forums](https://img.shields.io/badge/chat-on%20forums-orange.svg)](https://forums.kenticocloud.com) [![Join the chat at https://kentico-community.slack.com](https://img.shields.io/badge/join-slack-E6186D.svg)](https://kentico-community.slack.com) [![Version](https://img.shields.io/badge/version-0.10.0-green.svg)](https://github.com/Kentico/delivery-sdk-ruby/blob/master/lib/delivery/version.rb)
+
+# Delivery Ruby SDK
+
+The Delivery Ruby SDK can be used in Ruby/Rails projects to retrieve content from Kentico Cloud. This is a community project and not an official Kentico SDK. If you find a bug in the SDK or have a feature request, please submit a GitHub issue.
+
+## Installation
+
+To create the gem, clone this repo and run `rake build`, or download the gem from the /pkg directory. Then install the gem and its dependencies as usual:
+
+```ruby
+gem install delivery-sdk-ruby-0.6.1.gem
+gem install rest-client
+gem install nokogiri
+```
+
+Or, if you have a Gemfile, you can link the application directly to this repository:
+
+```ruby
+gem 'delivery-sdk-ruby', :git => 'https://github.com/Kentico/delivery-sdk-ruby.git'
+gem 'rest-client'
+gem 'nokogiri'
+```
+
+Then run `bundle install`. To use the SDK in an `.rb` file, you need to require it:
+
+```ruby
+require 'delivery-sdk-ruby'
+```
+
+## Creating a client
+
+You will use `Delivery::DeliveryClient` to obtain content from Kentico Cloud. Create an instance of the client and pass your project ID:
+
+```ruby
+delivery_client = Delivery::DeliveryClient.new project_id: '<your-project-id>'
+```
+
+### Previewing unpublished content
+
+To enable [preview](https://developer.kenticocloud.com/docs/previewing-content-in-a-separate-environment "preview"), pass the Preview API Key to the constructor:
+
+```ruby
+delivery_client = Delivery::DeliveryClient.new project_id: '<your-project-id>',
+                                               preview_key: '<your-preview-key>'
+```
+
+This enables preview, but you can toggle preview at any time by setting the `use_preview` attribute of DeliveryClient which is propogated to all queries created by the client, _or_ per-query by setting it's `use_preview` attribute:
+
+```ruby
+# For all queries created by client
+delivery_client.use_preview = false
+
+# Per-query
+query = delivery_client.items
+query.use_preview = false
+query.execute do |response|
+  # Do something
+end
+```
+
+### Making secure requests
+
+If you've [secured access](https://developer.kenticocloud.com/docs/securing-public-access "Securing public access") to your project, you need to provide the DeliveryClient with the primary or secondary key:
+
+```ruby
+Delivery::DeliveryClient.new project_id: '<your-project-id>',
+                             secure_key: '<your-secure-key>'
+```
+
+## Listing items
+
+
+Use `.item` or `.items` to create a `Delivery::DeliveryQuery`, then call `.execute` to perform the request.
+
+```ruby
+delivery_client.items.execute do |response|
+  response.items.each do |item|
+    # Do something
+  end
+end
+```
+
+### Filtering
+
+You can use [filtering](https://developer.kenticocloud.com/v1/reference#content-filtering "filtering") to retrieve particular items. The filtering methods are applied directly to a string and the available methods are:
+
+|Method|Example|REST equivalent|
+|--|--|--|
+|all|`'elements.product_status'.all %w[bestseller on_sale]`|?elements.product_status[all]=bestseller,on_sale|
+|any|`'elements.processing'.any %w[dry__natural_ semi_dry]`|?elements.processing[any]=dry__natural_,semi_dry|
+|contains|`'elements.related_articles'.contains 'on_roasts'`|?elements.related_articles[contains]=on_roasts|
+|eq|`'system.type'.eq 'grinder'`|?system.type=grinder|
+|gt|`'elements.price'.gt 20`|?elements.price[gt]=20|
+|gt_or_eq|`'elements.price'.gt_or_eq 20`|?elements.price[gte]=20|
+|in|`'system.type'.in %w[coffee brewer]`|?system.type[in]=coffee,brewer|
+|lt|`'elements.price'.lt 20`|?elements.price[lt]=20|
+|lt_or_eq|`'elements.price'.lt_or_eq 20`|?elements.price[lte]=20|
+|range|`'system.last_modified'.range %w[2018-02-01 2018-03-31]`|?system.last_modified[range]=2018-02-01,2018-03-31|
+
+You can pass a single filter or multiple filters in the DeliveryClient methods. For example:
+
+```ruby
+# Single filter
+delivery_client.items('elements.price'.gt 20)
+
+# Multiple filters
+delivery_client.items [
+  ('elements.price'.gt 20),
+  ('system.type'.eq 'grinder')
+]
+```
+
+### Parameters
+
+The `.item` and `.items` methods return a `Delivery::DeliveryQuery` object which you can further configure before executing. The methods you can call are:
+
+|Method|Example|REST equivalent
+|--|--|--|
+|[order_by](https://developer.kenticocloud.com/v1/reference#content-ordering "order_by")|`order_by 'system.last_modified' '[desc]'`|?order=system.last_modified[desc]
+|[skip](https://developer.kenticocloud.com/v1/reference#listing-response-paging "skip")|`skip 5`|?skip=5
+|[limit](https://developer.kenticocloud.com/v1/reference#listing-response-paging "limit")|`limit 5`|?limit=5
+|[elements](https://developer.kenticocloud.com/v1/reference#projection "elements")|`elements %w[price product_name image]`|?elements=price,product_name,image
+|[depth](https://developer.kenticocloud.com/v1/reference#linked-content "depth")|`depth 0`|?depth=0
+|[language](https://developer.kenticocloud.com/docs/understanding-language-fallbacks "language")|`language 'en'`|?language=en
+
+For example:
+
+```ruby
+delivery_client.items('system.type'.eq 'coffee')
+  .depth(0)
+  .limit(5)
+  .elements(%W[price product_name])
+  .execute do |response|
+    # Do something
+  end
+```
+
+### 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.kenticocloud.com/<your-project-id>/items?system.type=grinder')
+  .execute do |response|
+    # Do something
+  end
+```
+
+### Responses
+
+All responses from the `.execute` method will be/extend the `Delivery::Responses::ResponseBase` class which contains an `http_code` attribute and a friendly message that can be displayed by calling `.to_s`. You can check the code to determine if the request was successful:
+
+```ruby
+delivery_client.items.execute do |response|
+  case response.http_code
+  when 200
+    # Success!
+  when 401
+    # Did you forget the secure key?
+  else
+    puts response.to_s
+  end
+end
+```
+
+For successful content item queries, you will get either `DeliveryItemResponse` for single item queries, or `DeliveryItemListingResponse` for multiple item queries. You can access the returned content item(s) at `.item` or `.items` respectively.
+
+The `ContentItem` object gives you access to all system elements and content type elements at the `.system` and `.elements` properies. These are dynamic objects, so you can simply type the name of the element you need:
+
+```ruby
+price = response.item.elements.price.value
+```
+
+### 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:
+
+```ruby
+url = response.item.get_assets('teaser_image').first.url
+```
+
+### Linked items
+
+You can get a simple array of code names by accessing the element's value:
+
+```ruby
+links = response.item.elements.facts.value
+```
+
+The `.get_links(element)` method will return an array of ContentItems instead:
+
+```ruby
+response.item.get_links('facts').each do |link|
+  title = link.elements.title.value
+end
+```
+
+### Pagination
+
+The `DeliveryItemListingResponse` also contains a `pagination` attribute to access the [paging](https://developer.kenticocloud.com/v1/reference#listing-response-paging "paging") data for the Delivery query. This object contains the following attributes:
+
+- **skip**
+- **limit**
+- **count**
+- **next_page**
+
+For example, to access the next page URL you can use:
+
+```ruby
+delivery_client.items
+    .skip(0)
+    .limit(5)
+    .execute do |response|
+      next_page_url = response.pagination.next_page
+    end
+```
+
+You can then request the secure published content in your project. Be sure to not expose the key if the file(s) it appears in are publicly-available.
+
+## Retrieving content types
+
+You can use the `.type` and `.types` methods to request your content types from Kentico Cloud:
+
+```ruby
+delivery_client.types.execute do |response|
+  # Do something
+end
+delivery_client.type('coffee').execute do |response|
+  # Do something
+end
+```
+
+### Responses
+
+As with content item queries, all content type queries will return a `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:
+
+```ruby
+delivery_client.type('coffee').execute do |response|
+  field_type = response.type.elements.product_status.type # taxonomy
+end
+```
+
+ The DeliveryTypeListingResponse also contains pagination data, similar to DeliveryItemListingResponse.
+
+## 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 `Delivery::Resolvers::ContentLinkResolver` when you instantiate the DeliveryClient. When you create a ContentLinkResolver, you must pass a method that will return the URL:
+
+```ruby
+link_resolver = Delivery::Resolvers::ContentLinkResolver.new(lambda do |link|
+  return "/coffees/#{link.url_slug}" if link.type == 'coffee'
+  return "/brewers/#{link.url_slug}" if link.type == 'brewer'
+end)
+delivery_client = 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 `Delivery::Resolvers::ContentLinkResolver` and contain a `resolve_link(link)` method. For example, you can create `MyLinkResolver.rb`:
+
+```ruby
+class MyLinkResolver < Delivery::Resolvers::ContentLinkResolver
+  def resolve_link(link)
+    return "/coffees/#{link.url_slug}" if link.type == 'coffee'
+    return "/brewers/#{link.url_slug}" if link.type == 'brewer'
+  end
+end
+```
+
+Then create an object of this class when instantiating the DeliveryClient:
+
+```ruby
+delivery_client = 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 = 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
+lambda_resolver = Delivery::Resolvers::ContentLinkResolver.new(lambda do |link|
+  return "/coffees/#{link.url_slug}" if link.type == 'coffee'
+  return "/brewers/#{link.url_slug}" if link.type == 'brewer'
+end)
+delivery_client = Delivery::DeliveryClient.new project_id: '<your-project-id>',
+                                               content_link_url_resolver: lambda_resolver
+delivery_client.item('coffee_processing_techniques').execute do |response|
+  text = response.item.get_string 'body_copy'
+end
+```
+
+## Feedback & Contributing
+
+Check out the [contributing](https://github.com/Kentico/delivery-sdk-ruby/blob/master/CONTRIBUTING.md) page to see the best places to file issues, start discussions, and begin contributing.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Delivery project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/Kentico/delivery-sdk-net/blob/master/CODE_OF_CONDUCT.md).
+
+![Analytics](https://kentico-ga-beacon.azurewebsites.net/api/UA-69014260-4/Kentico/delivery-sdk-ruby?pixel)

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "delivery"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/delivery/client/delivery_client.rb

@@ -0,0 +1,58 @@
+require 'delivery/client/delivery_query'
+require 'delivery/responses/delivery_item_listing_response'
+require 'delivery/responses/delivery_item_response'
+require 'json'
+
+module Delivery
+  QUERY_TYPE_TYPES = 'QUERY_TYPE_TYPES'.freeze
+  QUERY_TYPE_ITEMS = 'QUERY_TYPE_ITEMS'.freeze
+  
+  # Executes requests against the Kentico Cloud Delivery API.
+  class DeliveryClient
+    attr_accessor :use_preview
+
+    def initialize(config)
+      @project_id = config.fetch(:project_id)
+      @preview_key = config.fetch(:preview_key, nil)
+      @secure_key = config.fetch(:secure_key, nil)
+      @content_link_url_resolver = config.fetch(:content_link_url_resolver, nil)
+      self.use_preview = !@preview_key.nil?
+    end
+
+    def types
+      DeliveryQuery.new project_id: @project_id,
+                        secure_key: @secure_key,
+                        query_type: QUERY_TYPE_TYPES
+    end
+
+    def type(code_name)
+      DeliveryQuery.new project_id: @project_id,
+                        secure_key: @secure_key,
+                        code_name: code_name,
+                        query_type: QUERY_TYPE_TYPES
+    end
+
+    def items(query_parameters = [])
+      q = DeliveryQuery.new project_id: @project_id,
+                            secure_key: @secure_key,
+                            qp: query_parameters,
+                            content_link_url_resolver: @content_link_url_resolver,
+                            query_type: QUERY_TYPE_ITEMS
+      q.use_preview = use_preview
+      q.preview_key = @preview_key
+      q
+    end
+
+    def item(code_name, query_parameters = [])
+      q = DeliveryQuery.new project_id: @project_id,
+                            secure_key: @secure_key,
+                            code_name: code_name,
+                            qp: query_parameters,
+                            content_link_url_resolver: @content_link_url_resolver,
+                            query_type: QUERY_TYPE_ITEMS
+      q.use_preview = use_preview
+      q.preview_key = @preview_key
+      q
+    end
+  end
+end

data/lib/delivery/client/delivery_query.rb

@@ -0,0 +1,166 @@
+require 'rest-client'
+require 'delivery/client/url_provider'
+
+module Delivery
+  # Responsible for translating query parameters into the
+  # corresponding REST request to Kentico Cloud.
+  class DeliveryQuery
+    ERROR_PREVIEW = 'Preview is enabled for the query, but the key is null. '\
+                    'You can set the preview_key attribute of the query, or '\
+                    'when you initialize the client. See '\
+                    'https://github.com/Kentico/delivery-sdk-ruby#previewing-unpublished-content'.freeze
+    ERROR_PARAMS = 'Only filters may be passed in the .item or .items methods'\
+                    '. See https://github.com/Kentico/delivery-sdk-ruby#filtering'.freeze
+    attr_accessor :use_preview,
+                  :preview_key,
+                  :project_id,
+                  :code_name,
+                  :params,
+                  :secure_key,
+                  :content_link_url_resolver,
+                  :query_type
+
+    # Setter for url, returns self for chaining
+    # .url represents *manually* configured urls, otherwise final url is
+    # generated in .execute and this will return nil
+    def url(url = nil)
+      @url = url unless url.nil?
+      self
+    end
+
+    def initialize(config)
+      # Map each hash value to attr with corresponding key
+      # from https://stackoverflow.com/a/2681014/5656214
+      config.each do |k, v|
+        instance_variable_set("@#{k}", v) unless v.nil?
+      end
+      return if config.fetch(:qp, nil).nil?
+
+      # Query parameters were passed, parse and validate
+      validate_params config.fetch(:qp)
+    end
+
+    def execute
+      provide_url
+      begin
+        resp = execute_rest
+      rescue RestClient::ExceptionWithResponse => err
+        yield Delivery::Responses::ResponseBase.new err.http_code, err.response
+      rescue RestClient::SSLCertificateNotVerified => err
+        yield Delivery::Responses::ResponseBase.new 500, err
+      rescue SocketError => err
+        yield Delivery::Responses::ResponseBase.new 500, err.message
+      else
+        yield make_response resp
+      end
+    end
+
+    def with_link_resolver(resolver)
+      self.content_link_url_resolver = resolver
+      self
+    end
+
+    def order_by(value, sort = '[asc]')
+      set_param('order', value + sort)
+      self
+    end
+
+    def skip(value)
+      set_param('skip', value)
+      self
+    end
+
+    def language(value)
+      set_param('language', value)
+    end
+
+    def limit(value)
+      set_param('limit', value)
+      self
+    end
+
+    def elements(value)
+      set_param('elements', value)
+      self
+    end
+
+    def depth(value)
+      set_param('depth', value)
+      self
+    end
+
+    private
+
+    def provide_url
+      @url = Delivery::UrlProvider.provide_url self if @url.nil?
+      Delivery::UrlProvider.validate_url @url
+    end
+
+    def validate_params(query_parameters)
+      self.params = if query_parameters.is_a? Array
+                      query_parameters
+                    else
+                      [query_parameters]
+                    end
+      params.each do |p|
+        unless p.is_a? Delivery::QueryParameters::Filter
+          raise ArgumentError, ERROR_PARAMS
+        end
+      end
+    end
+
+    def set_param(key, value)
+      self.params = [] if params.nil?
+      remove_existing_param key
+      params << Delivery::QueryParameters::ParameterBase.new(key, '', value)
+    end
+
+    # Returns true if this query should use preview mode. Raises an error if
+    # preview is enabled, but the key is nil
+    def should_preview
+      raise ERROR_PREVIEW if use_preview && preview_key.nil?
+
+      use_preview && !preview_key.nil?
+    end
+
+    def execute_rest
+      if should_preview
+        RestClient.get @url, Authorization: 'Bearer ' + preview_key
+      else
+        if secure_key.nil?
+          RestClient.get @url
+        else
+          RestClient.get @url, Authorization: 'Bearer ' + secure_key
+        end
+      end
+    end
+
+    def make_response(response)
+      case query_type
+      when Delivery::QUERY_TYPE_ITEMS
+        if code_name.nil?
+          Delivery::Responses::DeliveryItemListingResponse.new(
+            JSON.parse(response),
+            content_link_url_resolver
+          )
+        else
+          Delivery::Responses::DeliveryItemResponse.new(
+            JSON.parse(response),
+            content_link_url_resolver
+          )
+        end
+      when Delivery::QUERY_TYPE_TYPES
+        if code_name.nil?
+          Delivery::Responses::DeliveryTypeListingResponse.new JSON.parse(response)
+        else
+          Delivery::Responses::DeliveryTypeResponse.new JSON.parse(response)
+        end
+      end
+    end
+
+    # Remove existing parameter from @params if key exists
+    def remove_existing_param(key)
+      params.delete_if { |i| i.key.eql? key } unless params.nil?
+    end
+  end
+end

data/lib/delivery/client/url_provider.rb

@@ -0,0 +1,64 @@
+module Delivery
+  # Generates the URL required for Delivery REST API
+  class UrlProvider
+    URL_TEMPLATE_BASE = 'https://deliver.kenticocloud.com/%s'.freeze
+    URL_TEMPLATE_PREVIEW = 'https://preview-deliver.kenticocloud.com/%s'.freeze
+    URL_TEMPLATE_ITEM = '/items/%s'.freeze
+    URL_TEMPLATE_ITEMS = '/items'.freeze
+    URL_TEMPLATE_TYPE = '/types/%s'.freeze
+    URL_TEMPLATE_TYPES = '/types'.freeze
+    URL_TEMPLATE_ELEMENTS = '/types/%s/elements/%s'.freeze
+    URL_TEMPLATE_TAXONOMY = '/taxonomies/%s'.freeze
+    URL_TEMPLATE_TAXONOMIES = '/taxonomies'.freeze
+
+    URL_MAX_LENGTH = 65_519
+    MSG_LONG_QUERY = 'The request url is too long. Split your query into multiple calls.'.freeze
+
+    class << self
+      def provide_url(query)
+        url = provide_base_url(query)
+        url += provide_path_part(query)
+
+        if query.params.nil?
+          url
+        else
+          # Map each parameter to the result of a method and separate with &
+          url + '?' + query.params.map(&:provide_query_string_parameter).join('&')
+        end
+      end
+
+      def validate_url(url)
+        raise UriFormatException, MSG_LONG_QUERY if url.length > URL_MAX_LENGTH
+      end
+
+      private
+
+      # Returns relative path part of URL depending on query type
+      def provide_path_part(query)
+        case query.query_type
+        when Delivery::QUERY_TYPE_ITEMS
+          if query.code_name.nil?
+            URL_TEMPLATE_ITEMS
+          else
+            format(URL_TEMPLATE_ITEM, query.code_name)
+          end
+        when Delivery::QUERY_TYPE_TYPES
+          if query.code_name.nil?
+            URL_TEMPLATE_TYPES
+          else
+            format(URL_TEMPLATE_TYPE, query.code_name)
+          end
+        end
+      end
+
+      # Returns the protocol and domain with project ID
+      def provide_base_url(query)
+        if query.use_preview
+          format(URL_TEMPLATE_PREVIEW, query.project_id)
+        else
+          format(URL_TEMPLATE_BASE, query.project_id)
+        end
+      end
+    end
+  end
+end

data/lib/delivery/models/content_item.rb

@@ -0,0 +1,72 @@
+require 'ostruct'
+require 'nokogiri'
+
+module Delivery
+  # JSON data of a content item parsed as OpenStruct objects for dynamic use
+  class ContentItem
+    attr_accessor :content_link_url_resolver
+
+    def elements
+      @elements unless @elements.nil?
+      @elements = JSON.parse(
+        JSON.generate(@source['elements']),
+        object_class: OpenStruct
+      )
+    end
+
+    def system
+      @system unless @system.nil?
+      @system = JSON.parse(
+        JSON.generate(@source['system']),
+        object_class: OpenStruct
+      )
+    end
+
+    def initialize(source, content_link_url_resolver)
+      @source =
+        if source['item'].nil?
+          source
+        else
+          source['item']
+        end
+      @link_source = source['modular_content']
+      self.content_link_url_resolver = content_link_url_resolver
+    end
+
+    def get_string(code_name)
+      element = get_element code_name
+      
+      # Resolve content links if there are any and we have a resolver
+      return content_link_url_resolver.resolve element['value'], element['links'] if should_resolve element
+
+      element['value'].to_s
+    end
+
+    # Returns an array of assets inserted into the specified element
+    def get_assets(code_name)
+      element = get_element code_name
+      element['value'].map { |n| OpenStruct.new(n) }
+    end
+
+    # Returns an array of ContentItems by comparing code names stored in the
+    # element with items from request's link_source
+    def get_links(code_name)
+      element = get_element code_name
+      filtered = @link_source.values.select { |item| element['value'].include?(item['system']['codename']) }
+      filtered.map { |n| ContentItem.new JSON.parse(JSON.generate(n)), content_link_url_resolver }
+    end
+
+    private
+
+    def should_resolve(element)
+      element['type'] == 'rich_text' && !element['links'].nil? && !content_link_url_resolver.nil?
+    end
+
+    def get_element(code_name)
+      raise ArgumentError, "Argument 'code_name' cannot be null" if code_name.nil?
+      raise ArgumentError, "Argument 'code_name' is not a string" unless code_name.is_a? String
+
+      @source['elements'][code_name]
+    end
+  end
+end

data/lib/delivery/models/content_type.rb

@@ -0,0 +1,26 @@
+require 'ostruct'
+
+module Delivery
+  # JSON data of a content type parsed as OpenStruct objects for dynamic use
+  class ContentType
+    def elements
+      @elements unless @elements.nil?
+      @elements = JSON.parse(
+        JSON.generate(@source['elements']),
+        object_class: OpenStruct
+      )
+    end
+
+    def system
+      @system unless @system.nil?
+      @system = JSON.parse(
+        JSON.generate(@source['system']),
+        object_class: OpenStruct
+      )
+    end
+
+    def initialize(source)
+      @source = source
+    end
+  end
+end

data/lib/delivery/models/pagination.rb

@@ -0,0 +1,13 @@
+module Delivery
+  # Holds pagination data from a DeliveryItemListingResponse
+  class Pagination
+    attr_accessor :skip, :limit, :count, :next_page
+
+    def initialize(json)
+      self.skip = json['skip']
+      self.limit = json['limit']
+      self.count = json['count']
+      self.next_page = json['next_page']
+    end
+  end
+end

data/lib/delivery/query_parameters/filters.rb

@@ -0,0 +1,87 @@
+require 'delivery/query_parameters/parameter_base'
+
+module Delivery
+  module QueryParameters
+    # Provides the base class for filter implementations.
+    class Filter < ParameterBase
+      def initialize(key, operator, values)
+        super(key, operator, values)
+      end
+    end
+  end
+end
+
+# Extend String class to allow semantic typing of filters
+class String
+  # Represents a filter that matches a content item if the specified content
+  # element or system attribute has a value that contains all the specified
+  # values. This filter is applicable to array values only, such as sitemap
+  # location or value of Linked Items, Taxonomy and Multiple choice content elements.
+  def all(*args)
+    Delivery::QueryParameters::Filter.new(self, '[all]', *args)
+  end
+
+  # Represents a filter that matches a content item if the specified content
+  # element or system attribute has a value that contains any the specified
+  # values. This filter is applicable to array values only, such as sitemap
+  # location or value of Linked Items, Taxonomy and Multiple choice content elements.
+  def any(*args)
+    Delivery::QueryParameters::Filter.new(self, '[any]', *args)
+  end
+
+  # Represents a filter that matches a content item if the specified content element
+  # or system attribute has a value that contains the specified value.
+  # This filter is applicable to array values only, such as sitemap location or value
+  # of Linked Items, Taxonomy and Multiple choice content elements.
+  def contains(*args)
+    Delivery::QueryParameters::Filter.new(self, '[contains]', *args)
+  end
+
+  # Represents a filter that matches a content item if the specified
+  # content element or system attribute has the specified value.
+  def eq(*args)
+    Delivery::QueryParameters::Filter.new(self, '', *args)
+  end
+
+  # Represents a filter that matches a content item if the specified content
+  # element or system attribute has a value that is greater than the
+  # specified value.
+  def gt(*args)
+    Delivery::QueryParameters::Filter.new(self, '[gt]', *args)
+  end
+
+  # Represents a filter that matches a content item if the specified content
+  # element or system attribute has a value that is greater than or equal to
+  # the specified value.
+  def gt_or_eq(*args)
+    Delivery::QueryParameters::Filter.new(self, '[gte]', *args)
+  end
+
+  # Represents a filter that matches a content item if the specified
+  # content element or system attribute has a value that matches a
+  # value in the specified list.
+  def in(*args)
+    Delivery::QueryParameters::Filter.new(self, '[in]', *args)
+  end
+
+  # Represents a filter that matches a content item if the specified content
+  # element or system attribute has a value that is less than the
+  # specified value.
+  def lt(*args)
+    Delivery::QueryParameters::Filter.new(self, '[lt]', *args)
+  end
+
+  # Represents a filter that matches a content item if the specified content
+  # element or system attribute has a value that is less than or equal to
+  # the specified value.
+  def lt_or_eq(*args)
+    Delivery::QueryParameters::Filter.new(self, '[lte]', *args)
+  end
+
+  # Represents a filter that matches a content item if the specified
+  # content element or system attribute has a value that falls within
+  # the specified range of values (both inclusive).
+  def range(*args)
+    Delivery::QueryParameters::Filter.new(self, '[range]', *args)
+  end
+end

data/lib/delivery/query_parameters/parameter_base.rb

@@ -0,0 +1,30 @@
+module Delivery
+  # Contains static methods for adding parameters to a DeliveryQuery
+  # as well as the Filter class.
+  module QueryParameters
+    # Base class for all parameters added to a DeliveryQuery using the
+    # .parameters method. All parameters appear in the query string.
+    class ParameterBase
+      attr_accessor :key
+      SEPARATOR = CGI.escape(',')
+
+      def initialize(key, operator, values)
+        self.key = key
+        values = [values] unless values.respond_to? :each
+        @values = values
+        @operator = operator
+      end
+
+      def provide_query_string_parameter
+        escaped_values = []
+        @values.each { |n| escaped_values << CGI.escape(n.to_s) }
+        format(
+          '%<k>s%<o>s=%<v>s',
+          k: CGI.escape(key),
+          o: CGI.escape(@operator),
+          v: escaped_values.join(SEPARATOR)
+        )
+      end
+    end
+  end
+end

data/lib/delivery/resolvers/content_link_resolver.rb

@@ -0,0 +1,62 @@
+require 'nokogiri'
+
+module Delivery
+  module Resolvers
+    # Locates <a data-item-id=""> tags in content and calls a user-defined method
+    # to supply the href for content item links
+    class ContentLinkResolver
+      def initialize(callback = nil)
+        @callback = callback
+      end
+
+      # Resolves all links in the content
+      # @param [String] content The string value stored in the element
+      # @param [Array] links The collection of source links from the JSON response
+      def resolve(content, links)
+        doc = Nokogiri::HTML.parse(content).xpath('//body')
+        links = links.map { |link| ContentLink.new link }
+        tags = doc.xpath('//a[@data-item-id]')
+        # This line performs the link resolving and replaces the tags in doc
+        tags.map { |tag| resolve_tag tag, links }
+        doc.inner_html
+      end
+
+      private
+
+      # Accepts a tag found in the content and tries to locate matching
+      # source link from JSON response. If found, resolves URL and returns
+      # the tag with generated HREF
+      def resolve_tag(tag, links)
+        matches = links.select { |link| link.id == tag['data-item-id'].to_s }
+        url = provide_url matches
+        tag['href'] = url
+        tag
+      end
+
+      # Returns a url if a link was found in source links, otherwise returns 404
+      def provide_url(matches)
+        if !matches.empty?
+          if @callback.nil?
+            resolve_link matches[0]
+          else
+            @callback.call matches[0]
+          end
+        else
+          '/404'
+        end
+      end
+    end
+
+    # Model for links from the JSON response
+    class ContentLink
+      attr_accessor :code_name, :type, :url_slug, :id
+
+      def initialize(link)
+        self.id = link[0]
+        self.code_name = link[1]['codename']
+        self.type = link[1]['type']
+        self.url_slug = link[1]['url_slug']
+      end
+    end
+  end
+end

data/lib/delivery/responses/delivery_item_listing_response.rb

@@ -0,0 +1,33 @@
+require 'delivery/models/content_item'
+require 'delivery/models/pagination'
+require 'delivery/responses/response_base'
+
+module Delivery
+  module Responses
+    # Returned by DeliveryClient.items with an enumerable of ContentItems
+    class DeliveryItemListingResponse < ResponseBase
+      def pagination
+        @pagination unless @pagination.nil?
+        @pagination = Pagination.new @response['pagination']
+      end
+
+      def items
+        @items unless @items.nil?
+        items = []
+        @response['items'].each do |n|
+          items << Delivery::ContentItem.new(
+            n,
+            @content_link_url_resolver
+          )
+        end
+        @items = items
+      end
+
+      def initialize(response, content_link_url_resolver)
+        @response = response
+        @content_link_url_resolver = content_link_url_resolver
+        super 200, "Success, #{items.length} items returned"
+      end
+    end
+  end
+end

data/lib/delivery/responses/delivery_item_response.rb

@@ -0,0 +1,20 @@
+require 'delivery/models/content_item'
+require 'delivery/responses/response_base'
+
+module Delivery
+  module Responses
+    # Returned by DeliveryClient.item containing a single ContentItem
+    class DeliveryItemResponse < ResponseBase
+      def item
+        @item unless @item.nil?
+        @item = Delivery::ContentItem.new(@response, @content_link_url_resolver)
+      end
+
+      def initialize(response, content_link_url_resolver)
+        @response = response
+        @content_link_url_resolver = content_link_url_resolver
+        super 200, "Success, '#{item.system.code_name}' returned"
+      end
+    end
+  end
+end

data/lib/delivery/responses/delivery_type_listing_response.rb

@@ -0,0 +1,29 @@
+require 'delivery/models/content_type'
+require 'delivery/models/pagination'
+require 'delivery/responses/response_base'
+
+module Delivery
+  module Responses
+    # Returned by DeliveryClient.types with an enumerable of ContentTypes
+    class DeliveryTypeListingResponse < ResponseBase
+      def pagination
+        @pagination unless @pagination.nil?
+        @pagination = Pagination.new @response['pagination']
+      end
+
+      def types
+        @types unless @types.nil?
+        types = []
+        @response['types'].each do |n|
+          types << Delivery::ContentType.new(n)
+        end
+        @types = types
+      end
+
+      def initialize(response)
+        @response = response
+        super 200, "Success, #{types.length} types returned"
+      end
+    end
+  end
+end

data/lib/delivery/responses/delivery_type_response.rb

@@ -0,0 +1,19 @@
+require 'delivery/models/content_type'
+require 'delivery/responses/response_base'
+
+module Delivery
+  module Responses
+    # Returned by DeliveryClient.types with an enumerable of ContentTypes
+    class DeliveryTypeResponse < ResponseBase
+      def type
+        @type unless @type.nil?
+        @type = Delivery::ContentType.new(@response)
+      end
+
+      def initialize(response)
+        @response = response
+        super 200, "Success, type '#{type.system.codename}' returned"
+      end
+    end
+  end
+end

data/lib/delivery/responses/response_base.rb

@@ -0,0 +1,18 @@
+module Delivery
+  module Responses
+    # Base class for all responses from DeliveryQuery.execute
+    class ResponseBase
+      attr_accessor :http_code,
+                    :message
+
+      def initialize(http_code, message)
+        self.http_code = http_code
+        self.message = message
+      end
+
+      def to_s
+        "Response is status code #{http_code} with message:\n#{message}"
+      end
+    end
+  end
+end

data/lib/delivery/version.rb

@@ -0,0 +1,3 @@
+module Delivery
+  VERSION = '0.10.0'.freeze
+end

data/lib/delivery-sdk-ruby.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/delivery/client/delivery_client'
+require File.dirname(__FILE__) + '/delivery/client/delivery_query'
+require File.dirname(__FILE__) + '/delivery/models/content_item'
+require File.dirname(__FILE__) + '/delivery/models/content_type'
+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'
+require File.dirname(__FILE__) + '/delivery/responses/delivery_type_listing_response'
+require File.dirname(__FILE__) + '/delivery/responses/delivery_type_response'
+require File.dirname(__FILE__) + '/delivery/resolvers/content_link_resolver'

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: delivery-sdk-ruby
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+platform: ruby
+authors:
+- Eric Dugre
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-02-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Kentico Cloud Delivery SDK for Ruby
+email:
+- EricD@kentico.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- bin/console
+- bin/setup
+- lib/delivery-sdk-ruby.rb
+- lib/delivery/client/delivery_client.rb
+- lib/delivery/client/delivery_query.rb
+- lib/delivery/client/url_provider.rb
+- lib/delivery/models/content_item.rb
+- lib/delivery/models/content_type.rb
+- lib/delivery/models/pagination.rb
+- lib/delivery/query_parameters/filters.rb
+- lib/delivery/query_parameters/parameter_base.rb
+- lib/delivery/resolvers/content_link_resolver.rb
+- lib/delivery/responses/delivery_item_listing_response.rb
+- lib/delivery/responses/delivery_item_response.rb
+- lib/delivery/responses/delivery_type_listing_response.rb
+- lib/delivery/responses/delivery_type_response.rb
+- lib/delivery/responses/response_base.rb
+- lib/delivery/version.rb
+homepage: https://github.com/Kentico/delivery-sdk-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Kentico/delivery-sdk-ruby
+  source_code_uri: https://github.com/Kentico/delivery-sdk-ruby
+  changelog_uri: https://github.com/Kentico/delivery-sdk-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Kentico Cloud Delivery SDK for Ruby
+test_files: []