wcc-contentful 1.1.2 → 1.3.0

data/lib/wcc/contentful/rich_text.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative './rich_text/node'
+
+##
+# This module contains a number of structs representing nodes in a Contentful
+# rich text field.  When the Model layer parses a Rich Text field from
+# Contentful, it is turned into a WCC::Contentful::RichText::Document node.
+# The {WCC::Contentful::RichText::Document#content content} method of this
+# node is an Array containing paragraph, blockquote, entry, and other nodes.
+#
+# The various structs in the RichText object model are designed to mimic the
+# Hash interface, so that the indexing operator `#[]` and the `#dig` method
+# can be used to traverse the data.  The data can also be accessed by the
+# attribute reader methods defined on the structs.  Both of these are considered
+# part of the public API of the model and will not change.
+#
+# In a future release we plan to implement automatic link resolution.  When that
+# happens, the `.data` attribute of embedded entries and assets will return a
+# new class that is able to resolve the `.target` automatically into a full
+# entry or asset.  This future class will still respect the hash accessor methods
+# `#[]`, `#dig`, `#keys`, and `#each`, so it is safe to use those.
+module WCC::Contentful::RichText
+  ##
+  # Recursively converts a raw JSON-parsed hash into the RichText object model.
+  def self.tokenize(raw, context = nil)
+    return unless raw
+    return raw.map { |c| tokenize(c, context) } if raw.is_a?(Array)
+
+    klass =
+      case raw['nodeType']
+      when 'document'
+        Document
+      when 'paragraph'
+        Paragraph
+      when 'blockquote'
+        Blockquote
+      when 'text'
+        Text
+      when 'embedded-entry-inline'
+        EmbeddedEntryInline
+      when 'embedded-entry-block'
+        EmbeddedEntryBlock
+      when 'embedded-asset-block'
+        EmbeddedAssetBlock
+      when /heading-(\d+)/
+        size = Regexp.last_match(1)
+        const_get("Heading#{size}")
+      else
+        Unknown
+      end
+
+    klass.tokenize(raw, context)
+  end
+
+  Document =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  Paragraph =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  Blockquote =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  Text =
+    Struct.new(:nodeType, :value, :marks, :data) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  EmbeddedEntryInline =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  EmbeddedEntryBlock =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  EmbeddedAssetBlock =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  (1..5).each do |i|
+    struct =
+      Struct.new(:nodeType, :data, :content) do
+        include WCC::Contentful::RichText::Node
+      end
+    sz = i
+    struct.define_singleton_method(:node_type) { "heading-#{sz}" }
+    const_set("Heading#{sz}", struct)
+  end
+
+  Unknown =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+end

data/lib/wcc/contentful/rspec.rb

@@ -13,9 +13,7 @@ module WCC::Contentful::RSpec
   # stubs the Model API to return that content type for `.find` and `.find_by`
   # query methods.
   def contentful_stub(const, **attrs)
-    unless const.respond_to?(:content_type_definition)
-      const = WCC::Contentful::Model.resolve_constant(const.to_s)
-    end
+    const = WCC::Contentful::Model.resolve_constant(const.to_s) unless const.respond_to?(:content_type_definition)
     instance = contentful_create(const, **attrs)
 
     # mimic what's going on inside model_singleton_methods.rb

data/lib/wcc/contentful/services.rb

@@ -132,6 +132,15 @@ module WCC::Contentful
     # Allow it to be injected into a store
     alias_method :_instrumentation, :instrumentation
 
+    # Gets the configured logger, defaulting to Rails.logger in a rails context,
+    # or logging to STDERR in a non-rails context.
+    def logger
+      @logger ||=
+        configuration.logger ||
+        (Rails.logger if defined?(Rails)) ||
+        Logger.new($stderr)
+    end
+
     ##
     # This method enables simple dependency injection -
     # If the target has a setter matching the name of one of the services,

data/lib/wcc/contentful/simple_client/cdn.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# The CDN SimpleClient accesses 'https://cdn.contentful.com' to get raw
+# JSON responses.  It exposes methods to query entries, assets, and content_types.
+# The responses are instances of WCC::Contentful::SimpleClient::Response
+# which handles paging automatically.
+#
+# @api Client
+class WCC::Contentful::SimpleClient::Cdn < WCC::Contentful::SimpleClient
+  def initialize(space:, access_token:, **options)
+    super(
+      api_url: options[:api_url] || 'https://cdn.contentful.com/',
+      space: space,
+      access_token: access_token,
+      **options
+    )
+  end
+
+  def client_type
+    'cdn'
+  end
+
+  # Gets an entry by ID
+  def entry(key, query = {})
+    resp =
+      _instrument 'entries', id: key, type: 'Entry', query: query do
+        get("entries/#{key}", query)
+      end
+    resp.assert_ok!
+  end
+
+  # Queries entries with optional query parameters
+  def entries(query = {})
+    resp =
+      _instrument 'entries', type: 'Entry', query: query do
+        get('entries', query)
+      end
+    resp.assert_ok!
+  end
+
+  # Gets an asset by ID
+  def asset(key, query = {})
+    resp =
+      _instrument 'entries', type: 'Asset', id: key, query: query do
+        get("assets/#{key}", query)
+      end
+    resp.assert_ok!
+  end
+
+  # Queries assets with optional query parameters
+  def assets(query = {})
+    resp =
+      _instrument 'entries', type: 'Asset', query: query do
+        get('assets', query)
+      end
+    resp.assert_ok!
+  end
+
+  # Queries content types with optional query parameters
+  def content_types(query = {})
+    resp =
+      _instrument 'content_types', query: query do
+        get('content_types', query)
+      end
+    resp.assert_ok!
+  end
+
+  # Accesses the Sync API to get a list of items that have changed since
+  # the last sync.  Accepts a block that receives each changed item, and returns
+  # the next sync token.
+  #
+  # If `sync_token` is nil, an initial sync is performed.
+  #
+  # @return String the next sync token parsed from nextSyncUrl
+  # @example
+  #    my_sync_token = storage.get('sync_token')
+  #    my_sync_token = client.sync(sync_token: my_sync_token) do |item|
+  #      storage.put(item.dig('sys', 'id'), item) }
+  #    end
+  #    storage.put('sync_token', my_sync_token)
+  def sync(sync_token: nil, **query, &block)
+    return sync_old(sync_token: sync_token, **query) unless block_given?
+
+    sync_token =
+      if sync_token
+        { sync_token: sync_token }
+      else
+        { initial: true }
+      end
+    query = query.merge(sync_token)
+
+    _instrument 'sync', sync_token: sync_token, query: query do
+      resp = get('sync', query)
+      resp = SyncResponse.new(resp)
+      resp.assert_ok!
+
+      resp.each_page do |page|
+        page.page_items.each(&block)
+        sync_token = resp.next_sync_token
+      end
+    end
+
+    sync_token
+  end
+
+  private
+
+  def sync_old(sync_token: nil, **query)
+    ActiveSupport::Deprecation.warn('Sync without a block is deprecated, please use new block syntax instead')
+
+    sync_token =
+      if sync_token
+        { sync_token: sync_token }
+      else
+        { initial: true }
+      end
+    query = query.merge(sync_token)
+
+    resp =
+      _instrument 'sync', sync_token: sync_token, query: query do
+        get('sync', query)
+      end
+    resp = SyncResponse.new(resp, memoize: true)
+    resp.assert_ok!
+  end
+end

data/lib/wcc/contentful/simple_client/preview.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# @api Client
+class WCC::Contentful::SimpleClient::Preview < WCC::Contentful::SimpleClient::Cdn
+  def initialize(space:, preview_token:, **options)
+    super(
+      **options,
+      api_url: options[:preview_api_url] || 'https://preview.contentful.com/',
+      space: space,
+      access_token: preview_token
+    )
+  end
+
+  def client_type
+    'preview'
+  end
+end

data/lib/wcc/contentful/simple_client/response.rb

@@ -6,9 +6,7 @@ class WCC::Contentful::SimpleClient
   class Response
     include ::WCC::Contentful::Instrumentation
 
-    attr_reader :raw_response
-    attr_reader :client
-    attr_reader :request
+    attr_reader :raw_response, :client, :request
 
     delegate :status, to: :raw_response
     alias_method :code, :status
@@ -26,7 +24,7 @@ class WCC::Contentful::SimpleClient
     def error_message
       parsed_message =
         begin
-          raw.dig('message')
+          raw['message']
         rescue JSON::ParserError
           nil
         end
@@ -49,7 +47,6 @@ class WCC::Contentful::SimpleClient
 
     def next_page
       return unless next_page?
-      return @next_page if @next_page
 
       query = (@request[:query] || {}).merge({
         skip: page_items.length + skip
@@ -58,7 +55,7 @@ class WCC::Contentful::SimpleClient
         _instrument 'page', url: @request[:url], query: query do
           @client.get(@request[:url], query)
         end
-      @next_page = np.assert_ok!
+      np.assert_ok!
     end
 
     def initialize(client, request, raw_response)
@@ -77,16 +74,7 @@ class WCC::Contentful::SimpleClient
     def each_page(&block)
       raise ArgumentError, 'Not a collection response' unless page_items
 
-      ret =
-        Enumerator.new do |y|
-          y << self
-
-          if next_page?
-            next_page.each_page.each do |page|
-              y << page
-            end
-          end
-        end
+      ret = PaginatingEnumerable.new(self)
 
       if block_given?
         ret.map(&block)
@@ -115,20 +103,16 @@ class WCC::Contentful::SimpleClient
 
     def includes
       @includes ||=
-        raw.dig('includes')&.each_with_object({}) do |(_t, entries), h|
+        raw['includes']&.each_with_object({}) do |(_t, entries), h|
           entries.each { |e| h[e.dig('sys', 'id')] = e }
         end || {}
-
-      return @includes unless @next_page
-
-      # This could be more efficient - maybe not worth worrying about
-      @includes.merge(@next_page.includes)
     end
   end
 
   class SyncResponse < Response
-    def initialize(response)
+    def initialize(response, memoize: false)
       super(response.client, response.request, response.raw_response)
+      @memoize = memoize
     end
 
     def next_page?
@@ -137,6 +121,7 @@ class WCC::Contentful::SimpleClient
 
     def next_page
       return unless next_page?
+      return @next_page if @next_page
 
       url = raw['nextPageUrl']
       next_page =
@@ -144,37 +129,33 @@ class WCC::Contentful::SimpleClient
           @client.get(url)
         end
 
-      @next_page ||= SyncResponse.new(next_page)
-      @next_page.assert_ok!
+      next_page = SyncResponse.new(next_page)
+      next_page.assert_ok!
+      @next_page = next_page if @memoize
+      next_page
     end
 
     def next_sync_token
-      # If we haven't grabbed the next page yet, then our next "sync" will be getting
-      # the next page.  We could just as easily call sync again with that token.
-      @next_page&.next_sync_token ||
-        @next_sync_token ||= SyncResponse.parse_sync_token(
-          raw['nextPageUrl'] || raw['nextSyncUrl']
-        )
-    end
+      # If we have iterated some pages, return the sync token of the final
+      # page that was iterated.  Do this without maintaining a reference to
+      # all the pages.
+      return @last_sync_token if @last_sync_token
 
-    def each_page
-      raise ArgumentError, 'Not a collection response' unless page_items
+      SyncResponse.parse_sync_token(raw['nextPageUrl'] || raw['nextSyncUrl'])
+    end
 
-      ret =
-        Enumerator.new do |y|
-          y << self
+    def each_page(&block)
+      if block_given?
+        super do |page|
+          @last_sync_token = page.next_sync_token
 
-          if next_page?
-            next_page.each_page.each do |page|
-              y << page
-            end
-          end
+          yield page
         end
-
-      if block_given?
-        ret.map(&block)
       else
-        ret.lazy
+        super.map do |page|
+          @last_sync_token = page.next_sync_token
+          page
+        end
       end
     end
 
@@ -190,6 +171,26 @@ class WCC::Contentful::SimpleClient
     end
   end
 
+  class PaginatingEnumerable
+    include Enumerable
+
+    def initialize(initial_page)
+      raise ArgumentError, 'Must provide initial page' unless initial_page.present?
+
+      @initial_page = initial_page
+    end
+
+    def each
+      page = @initial_page
+      yield page
+
+      while page.next_page?
+        page = page.next_page
+        yield page
+      end
+    end
+  end
+
   class ApiError < StandardError
     attr_reader :response
 

data/lib/wcc/contentful/simple_client.rb

@@ -2,6 +2,8 @@
 
 require_relative 'simple_client/response'
 require_relative 'simple_client/management'
+require_relative 'simple_client/cdn'
+require_relative 'simple_client/preview'
 require_relative 'instrumentation'
 
 module WCC::Contentful
@@ -24,8 +26,7 @@ module WCC::Contentful
   class SimpleClient
     include WCC::Contentful::Instrumentation
 
-    attr_reader :api_url
-    attr_reader :space
+    attr_reader :api_url, :space
 
     # Creates a new SimpleClient with the given configuration.
     #
@@ -41,7 +42,7 @@ module WCC::Contentful
     # @option options [Number] rate_limit_wait_timeout The maximum time to block the thread waiting
     #   on a rate limit response.  By default will wait for one 429 and then fail on the second 429.
     def initialize(api_url:, space:, access_token:, **options)
-      @api_url = URI.join(api_url, '/spaces/', space + '/')
+      @api_url = URI.join(api_url, '/spaces/', "#{space}/")
       @space = space
       @access_token = access_token
 
@@ -57,7 +58,7 @@ module WCC::Contentful
 
       return unless options[:environment].present?
 
-      @api_url = URI.join(@api_url, 'environments/', options[:environment] + '/')
+      @api_url = URI.join(@api_url, 'environments/', "#{options[:environment]}/")
     end
 
     # performs an HTTP GET request to the specified path within the configured
@@ -84,15 +85,13 @@ module WCC::Contentful
       case adapter
       when nil
         ADAPTERS.each do |a, spec|
-          begin
-            gem(*spec)
-            return load_adapter(a)
-          rescue Gem::LoadError
-            next
-          end
+          gem(*spec)
+          return load_adapter(a)
+        rescue Gem::LoadError
+          next
         end
-        raise ArgumentError, 'Unable to load adapter!  Please install one of '\
-          "#{ADAPTERS.values.map(&:join).join(',')}"
+        raise ArgumentError, 'Unable to load adapter!  Please install one of ' \
+                             "#{ADAPTERS.values.map(&:join).join(',')}"
       when :faraday
         require 'faraday'
         ::Faraday.new do |faraday|
@@ -104,8 +103,8 @@ module WCC::Contentful
         TyphoeusAdapter.new
       else
         unless adapter.respond_to?(:get)
-          raise ArgumentError, "Adapter #{adapter} is not invokeable!  Please "\
-            "pass use one of #{ADAPTERS.keys} or create a Faraday-compatible adapter"
+          raise ArgumentError, "Adapter #{adapter} is not invokeable!  Please " \
+                               "pass use one of #{ADAPTERS.keys} or create a Faraday-compatible adapter"
         end
         adapter
       end
@@ -149,109 +148,5 @@ module WCC::Contentful
         return resp
       end
     end
-
-    # The CDN SimpleClient accesses 'https://cdn.contentful.com' to get raw
-    # JSON responses.  It exposes methods to query entries, assets, and content_types.
-    # The responses are instances of WCC::Contentful::SimpleClient::Response
-    # which handles paging automatically.
-    #
-    # @api Client
-    class Cdn < SimpleClient
-      def initialize(space:, access_token:, **options)
-        super(
-          api_url: options[:api_url] || 'https://cdn.contentful.com/',
-          space: space,
-          access_token: access_token,
-          **options
-        )
-      end
-
-      def client_type
-        'cdn'
-      end
-
-      # Gets an entry by ID
-      def entry(key, query = {})
-        resp =
-          _instrument 'entries', id: key, type: 'Entry', query: query do
-            get("entries/#{key}", query)
-          end
-        resp.assert_ok!
-      end
-
-      # Queries entries with optional query parameters
-      def entries(query = {})
-        resp =
-          _instrument 'entries', type: 'Entry', query: query do
-            get('entries', query)
-          end
-        resp.assert_ok!
-      end
-
-      # Gets an asset by ID
-      def asset(key, query = {})
-        resp =
-          _instrument 'entries', type: 'Asset', id: key, query: query do
-            get("assets/#{key}", query)
-          end
-        resp.assert_ok!
-      end
-
-      # Queries assets with optional query parameters
-      def assets(query = {})
-        resp =
-          _instrument 'entries', type: 'Asset', query: query do
-            get('assets', query)
-          end
-        resp.assert_ok!
-      end
-
-      # Queries content types with optional query parameters
-      def content_types(query = {})
-        resp =
-          _instrument 'content_types', query: query do
-            get('content_types', query)
-          end
-        resp.assert_ok!
-      end
-
-      # Accesses the Sync API to get a list of items that have changed since
-      # the last sync.
-      #
-      # If `sync_token` is nil, an initial sync is performed.
-      # Returns a WCC::Contentful::SimpleClient::SyncResponse
-      # which handles paging automatically.
-      def sync(sync_token: nil, **query)
-        sync_token =
-          if sync_token
-            { sync_token: sync_token }
-          else
-            { initial: true }
-          end
-        query = query.merge(sync_token)
-        resp =
-          _instrument 'sync', sync_token: sync_token, query: query do
-            get('sync', query)
-          end
-        resp = SyncResponse.new(resp)
-        resp.assert_ok!
-      end
-    end
-
-    # @api Client
-    class Preview < Cdn
-      def initialize(space:, preview_token:, **options)
-        super(
-          **options,
-          api_url: options[:preview_api_url] || 'https://preview.contentful.com/',
-          space: space,
-          access_token: preview_token
-        )
-      end
-
-      def client_type
-        'preview'
-      end
-    end
   end
 end

data/lib/wcc/contentful/store/base.rb

@@ -50,30 +50,30 @@ module WCC::Contentful::Store
     # implementation calls into #set and #delete to perform the appropriate
     # operations in the store.
     def index(json)
+      # This implementation assumes that #delete and #set are individually thread-safe.
+      # No mutex is needed so long as the revisions are accurate.
       # Subclasses can override to do this in a more performant thread-safe way.
       # Example: postgres_store could do this in a stored procedure for speed
-      mutex.with_write_lock do
-        prev =
-          case type = json.dig('sys', 'type')
-          when 'DeletedEntry', 'DeletedAsset'
-            delete(json.dig('sys', 'id'))
-          else
-            set(json.dig('sys', 'id'), json)
-          end
-
-        if (prev_rev = prev&.dig('sys', 'revision')) && (next_rev = json.dig('sys', 'revision'))
-          if next_rev < prev_rev
-            # Uh oh! we overwrote an entry with a prior revision.  Put the previous back.
-            return index(prev)
-          end
-        end
-
-        case type
+      prev =
+        case type = json.dig('sys', 'type')
         when 'DeletedEntry', 'DeletedAsset'
-          nil
+          delete(json.dig('sys', 'id'))
         else
-          json
+          set(json.dig('sys', 'id'), json)
         end
+
+      if (prev_rev = prev&.dig('sys', 'revision')) &&
+          (next_rev = json.dig('sys', 'revision')) &&
+          (next_rev < prev_rev)
+        # Uh oh! we overwrote an entry with a prior revision.  Put the previous back.
+        return index(prev)
+      end
+
+      case type
+      when 'DeletedEntry', 'DeletedAsset'
+        nil
+      else
+        json
       end
     end
 
@@ -107,17 +107,9 @@ module WCC::Contentful::Store
       )
     end
 
-    def initialize
-      @mutex = Concurrent::ReentrantReadWriteLock.new
-    end
-
     def ensure_hash(val)
       raise ArgumentError, 'Value must be a Hash' unless val.is_a?(Hash)
     end
-
-    private
-
-    attr_reader :mutex
   end
 end