contentful 0.1.0

data/lib/contentful/response.rb

@@ -0,0 +1,64 @@
+require_relative 'error'
+require 'multi_json'
+
+module Contentful
+  # An object representing an answer by the contentful service. It is later used
+  # to build a Resource, which is done by the ResourceBuilder.
+  #
+  # The Response parses the http response (as returned by the underlying http library) to
+  # a JSON object. Responses can be asked the following methods:
+  # - #raw (raw HTTP response by the HTTP library)
+  # - #object (the parsed JSON object)
+  # - #request (the request the response is refering to)
+  #
+  # It also sets a #status which can be one of:
+  # - :ok (seems to be a valid resource object)
+  # - :contentful_error (valid error object)
+  # - :not_contentful (valid json, but missing the contentful's sys property)
+  # - :unparsable_json (invalid json)
+  #
+  # Error Repsonses also contain a:
+  # - :error_message
+  class Response
+    attr_reader :raw, :object, :status, :error_message, :request
+
+    def initialize(raw, request = nil)
+      @raw     = raw
+      @request = request
+      @status  = :ok
+
+      if parse_json!
+        parse_contentful_error!
+      end
+    end
+
+
+    private
+
+    def parse_json!
+      @object = MultiJson.load(raw.to_s)
+      true
+    rescue MultiJson::LoadError => e
+      @status = :unparsable_json
+      @error_message = e.message
+      @object = e
+      false
+    end
+
+    def parse_contentful_error!
+      if @object && @object["sys"]
+        if @object["sys"]["type"] == 'Error'
+          @status = :contentful_error
+          @error_message = object['message']
+          true
+        else
+          false
+        end
+      else
+        @status = :not_contentful
+        @error_message = "No contentful system properties found in object"
+      end
+    end
+
+  end
+end

data/lib/contentful/space.rb

@@ -0,0 +1,14 @@
+require_relative '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
+
+    property :name, :string
+    property :locales, Locale
+  end
+end

data/lib/contentful/support.rb

@@ -0,0 +1,18 @@
+module Contentful
+  # Utility methods used by the contentful gem
+  module Support
+    class << self
+      # Transforms CamelCase into snake_case (taken from zucker)
+      def snakify(object)
+        object.to_s.gsub(/(?<!^)[A-Z]/) do "_#$&" end.downcase
+      end
+
+      # Transforms each hash key into a symbol (like in AS)
+      def symbolize_keys(h)
+        result = {}
+        h.each_key{ |key| result[(key.to_sym rescue key)] = h[key] }
+        result
+      end
+    end
+  end
+end

data/lib/contentful/version.rb

@@ -0,0 +1,3 @@
+module Contentful
+  VERSION = "0.1.0"
+end

data/spec/array_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Contentful::Array do
+  let(:array){ vcr('array'){ create_client.content_types } }
+
+  describe 'SystemProperties' do
+    it 'has a #sys getter returning a hash with symbol keys' do
+      expect( array.sys ).to be_a Hash
+      expect( array.sys.keys.sample ).to be_a Symbol
+    end
+
+    it 'has #type' do
+      expect( array.type ).to eq "Array"
+    end
+  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
+
+    it 'has #skip' do
+      expect( array.skip ).to eq 0
+    end
+
+    it 'has #limit' do
+      expect( array.limit ).to eq 100
+    end
+
+    it 'has #items which contain resources' do
+      expect( array.items ).to be_a Array
+      expect( array.items.sample ).to be_a Contentful::Resource
+    end
+  end
+
+  describe '#each' do
+    it 'is an Enumerator' do
+      expect( array.each ).to be_a Enumerator
+    end
+
+    it 'iterates over items' do
+      expect( array.each.to_a ).to eq array.items
+    end
+
+    it 'includes Enumerable' do
+      expect( array.map{ |r| r.type } ).to eq array.items.map{ |r| r.type }
+    end
+  end
+
+  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 }
+
+      expect( array_page_2 ).to be_a Contentful::Array
+      expect( array_page_2.limit ).to eq 2
+      expect( array_page_2.skip  ).to eq 5
+    end
+
+    it 'will return false if #request not available' do
+      expect( Contentful::Array.new({}).reload ).to be_false
+    end
+  end
+end

data/spec/asset_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Contentful::Asset do
+  let(:asset){ vcr('asset'){ create_client.asset('nyancat') } }
+
+  describe 'SystemProperties' do
+    it 'has a #sys getter returning a hash with symbol keys' do
+      expect( asset.sys ).to be_a Hash
+      expect( asset.sys.keys.sample ).to be_a Symbol
+    end
+
+    it 'has #id' do
+      expect( asset.id ).to eq "nyancat"
+    end
+
+    it 'has #type' do
+      expect( asset.type ).to eq "Asset"
+    end
+
+    it 'has #space' do
+      expect( asset.space ).to be_a Contentful::Link
+    end
+
+    it 'has #created_at' do
+      expect( asset.created_at ).to be_a DateTime
+    end
+
+    it 'has #updated_at' do
+      expect( asset.updated_at ).to be_a DateTime
+    end
+
+    it 'has #revision' do
+      expect( asset.revision ).to eq 1
+    end
+  end
+
+  describe 'Fields' do
+    it 'has #title' do
+      expect( asset.title ).to eq "Nyan Cat"
+    end
+
+    it 'could have #description' do
+      expect( asset ).to respond_to :description
+    end
+
+    it 'has #file' do
+      expect( asset.file ).to be_a Contentful::File
+    end
+  end
+
+  describe '#image_url' do
+    it 'returns #url of #file without parameter' do
+      expect( asset.image_url ).to eq asset.file.url
+    end
+
+    it 'adds image options if given' do
+      url = asset.image_url(width: 100, format: 'jpg', quality: 50)
+      expect(url).to include asset.file.url
+      expect(url).to include "?w=100&fm=jpg&q=50"
+    end
+  end
+end

data/spec/auto_includes_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'Auto-include resources' do
+  let(:entries){ vcr('entries'){ create_client.entries } } # entries come with asset includes
+
+  it 'replaces Contentful::Links which are actually included with the resource' do
+    asset = entries.items[1].fields[:image]
+
+    expect( asset ).not_to be_a Contentful::Link
+    expect( asset ).to be_a Contentful::Asset
+  end
+end

data/spec/client_class_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+
+describe Contentful::Client do
+  describe '#get' do
+    let(:client){ create_client }
+    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
+    end
+
+    it 'uses #request_headers' do
+      stub(client).request_headers{{
+        'User-Agent' => 'RubyContentfulGem/0.1.0',
+        'Authorization' => 'Bearer b4c0n73n7fu1',
+        'Content-Type' => 'application/vnd.contentful.delivery.v1+json',
+      }}
+      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" }
+      vcr('content_type'){ client.get(request) }
+      expect( request ).to have_received.url
+    end
+
+    it 'uses Request#query' do
+      stub(request).query
+      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') }
+      client.get(request)
+      expect( client.class ).to have_received.get_http(client.base_url + request.url, request.query, client.request_headers)
+    end
+
+    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
+      end
+
+      it 'returns a Contentful::Response object if second parameter is not true' do
+        res = vcr('content_type'){ client.get(request, false) }
+        expect( res ).to be_a Contentful::Response
+      end
+    end
+
+  end
+end

data/spec/client_configuration_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+
+describe 'Client Configuration Options' do
+  describe ':space' do
+    it 'is required' do
+      expect{
+        Contentful::Client.new(access_token: 'b4c0n73n7fu1')
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe ':access_token' do
+    it 'is required' do
+      expect{
+        Contentful::Client.new(space: 'cfexampleapi')
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe ':secure' do
+    it 'will use https [default]' do
+      expect(
+        create_client.base_url
+      ).to start_with 'https://'
+    end
+
+    it 'will use http when secure set to false' do
+      expect(
+        create_client(secure: false).base_url
+      ).to start_with 'http://'
+    end
+  end
+
+  describe ':raise_errors' do
+    it 'will raise response errors if set to true [default]' do
+      expect_vcr('not found'){
+        create_client.entry "not found"
+      }.to raise_error Contentful::NotFound
+    end
+
+    it 'will not raise response errors if set to false' do
+      res = nil
+
+      expect_vcr('not found'){
+        res = create_client(raise_errors: false).entry "not found"
+      }.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
+    end
+
+    it 'will create dynamic entries if dynamic_entry_cache is not empty' do
+      client = create_client(dynamic_entries: :manual)
+      vcr('entry_cache'){ client.update_dynamic_entry_cache! }
+      entry = vcr('nyancat'){ client.entry('nyancat') }
+
+      expect( entry ).to be_a Contentful::DynamicEntry
+    end
+
+    context ':auto' do
+      it 'will call update dynamic_entry_cache on start-up' do
+        client = vcr('entry_cache'){
+           create_client(dynamic_entries: :auto)
+        }
+        expect( client.dynamic_entry_cache ).not_to be_empty
+        expect( client.dynamic_entry_cache.values.first.ancestors ).to \
+            include Contentful::DynamicEntry
+      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
+      end
+    end
+
+    describe '#update_dynamic_entry_cache!' do
+      let(:client){ create_client(dynamic_entries: :manual) }
+
+      it 'will fetch all content_types' do
+        stub(client).content_types{{}}
+        client.update_dynamic_entry_cache!
+        expect( client ).to have_received.content_types(limit: 0)
+      end
+
+      it 'will save dynamic entries in @dynamic_entry_cache' do
+        vcr('entry_cache'){
+          client.update_dynamic_entry_cache!
+        }
+        expect( client.dynamic_entry_cache ).not_to be_empty
+        expect( client.dynamic_entry_cache.values.first.ancestors ).to \
+            include Contentful::DynamicEntry
+      end
+    end
+
+    describe '#register_dynamic_entry' do
+      let(:client){ create_client(dynamic_entries: :manual) }
+
+      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
+
+        entry = vcr('nyancat'){ client.entry('nyancat') }
+        expect( entry ).to be_a Contentful::DynamicEntry
+        expect( entry ).to be_a CatEntry
+      end
+    end
+  end
+
+  describe ':api_url' do
+    it 'is "cdn.contentful.com" [default]' do
+      expect(
+        create_client.configuration[:api_url]
+      ).to eq "cdn.contentful.com"
+    end
+
+    it 'will be used as base url' do
+      expect(
+        create_client(api_url: "cdn2.contentful.com").base_url
+      ).to start_with "https://cdn2.contentful.com"
+    end
+  end
+
+  describe ':api_version' do
+    it 'is 1 [default]' do
+      expect(
+        create_client.configuration[:api_version]
+      ).to eq 1
+    end
+
+    it 'will used for the http content type request header' do
+      expect(
+        create_client(api_version: 2).request_headers['Content-Type']
+      ).to eq "application/vnd.contentful.delivery.v2+json"
+    end
+  end
+
+  describe ':authentication_mechanism' do
+    describe ':header [default]' do
+      it 'will add the :access_token as authorization bearer token request header' do
+        expect(
+          create_client.request_headers['Authorization']
+        ).to eq "Bearer b4c0n73n7fu1"
+      end
+
+      it 'will not add :access_token to query' do
+        expect(
+          create_client.request_query({})['access_token']
+        ).to be_nil
+      end
+    end
+
+    describe ':query_string' do
+      it 'will add the :access_token to query' do
+        expect(
+          create_client(authentication_mechanism: :query_string).
+              request_query({})['access_token']
+        ).to eq "b4c0n73n7fu1"
+      end
+
+      it 'will not add the :access_token as authorization bearer token request header' do
+        expect(
+          create_client(authentication_mechanism: :query_string).
+              request_headers['Authorization']
+        ).to be_nil
+      end
+    end
+  end
+
+  describe ':resource_mapping' do
+    it 'lets you register your own resource classes for certain response types' do
+      class MyBetterAsset < Contentful::Asset
+        def https_image_url
+          image_url.sub %r<\A//>, 'https://'
+        end
+      end
+
+      client = create_client(
+        resource_mapping: {
+          'Asset' => MyBetterAsset,
+        }
+      )
+
+      nyancat = vcr('asset'){ client.asset 'nyancat' }
+      expect( nyancat ).to be_a MyBetterAsset
+      expect( nyancat.https_image_url ).to start_with 'https'
+    end
+  end
+end