Class: WCC::Contentful::Services

Inherits:
Object
  • Object
show all
Defined in:
lib/wcc/contentful/services.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(configuration, model_namespace: nil) ⇒ Services

Returns a new instance of Services.

Raises:



18
19
20
21
22
23
 
# File 'lib/wcc/contentful/services.rb', line 18

def initialize(configuration, model_namespace: nil)
  raise ArgumentError, 'Not yet configured!' unless configuration

  @configuration = configuration
  @model_namespace = model_namespace
end

Instance Attribute Details

#configuration ⇒ Object (readonly)

Returns the value of attribute configuration.



12
13
14
 
# File 'lib/wcc/contentful/services.rb', line 12

def configuration
  @configuration
end

Class Method Details

.instance ⇒ Object 



6
7
8
9
 
# File 'lib/wcc/contentful/services.rb', line 6

def instance
  @singleton__instance__ ||= # rubocop:disable Naming/MemoizedInstanceVariableName
    (new(WCC::Contentful.configuration) if WCC::Contentful.configuration)
end

Instance Method Details

#client ⇒ Object

Gets a CDN Client which provides methods for getting and paging raw JSON data from the Contentful CDN.

API:

  • Client



62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/wcc/contentful/services.rb', line 62

def client
  @client ||=
    WCC::Contentful::SimpleClient::Cdn.new(
      **configuration.connection_options,
      access_token: configuration.access_token,
      space: configuration.space,
      default_locale: configuration.default_locale,
      connection: configuration.connection,
      environment: configuration.environment,
      instrumentation: instrumentation
    )
end

#inject_into(target, except: []) ⇒ Object

This method enables simple dependency injection - If the target has a setter matching the name of one of the services, set that setter with the value of the service.



175
176
177
178
179
180
181
182
 
# File 'lib/wcc/contentful/services.rb', line 175

def inject_into(target, except: [])
  (WCC::Contentful::SERVICES - except).each do |s|
    next unless target.respond_to?("#{s}=")

    target.public_send("#{s}=",
      public_send(s))
  end
end

#instrumentation ⇒ Object Also known as: _instrumentation

Gets the configured instrumentation adapter, defaulting to ActiveSupport::Notifications



154
155
156
157
158
 
# File 'lib/wcc/contentful/services.rb', line 154

def instrumentation
  @instrumentation ||=
    configuration.instrumentation_adapter ||
    ActiveSupport::Notifications
end

#logger ⇒ Object

Gets the configured logger, defaulting to Rails.logger in a rails context, or logging to STDERR in a non-rails context.



164
165
166
167
168
169
 
# File 'lib/wcc/contentful/services.rb', line 164

def logger
  @logger ||=
    configuration.logger ||
    (Rails.logger if defined?(Rails)) ||
    Logger.new($stderr)
end

#management_client ⇒ Object

Gets a Management Client which provides methods for updating data via the Contentful Management API

API:

  • Client



98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/wcc/contentful/services.rb', line 98

def management_client
  @management_client ||=
    if configuration.management_token.present?
      WCC::Contentful::SimpleClient::Management.new(
        **configuration.connection_options,
        management_token: configuration.management_token,
        space: configuration.space,
        default_locale: configuration.default_locale,
        connection: configuration.connection,
        environment: configuration.environment,
        instrumentation: instrumentation
      )
    end
end

#model_namespace ⇒ Object 



14
15
16
 
# File 'lib/wcc/contentful/services.rb', line 14

def model_namespace
  @model_namespace || WCC::Contentful::Model
end

#preview_client ⇒ Object

Gets a CDN Client which provides methods for getting and paging raw JSON data from the Contentful Preview API.

API:

  • Client



79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/wcc/contentful/services.rb', line 79

def preview_client
  @preview_client ||=
    if configuration.preview_token.present?
      WCC::Contentful::SimpleClient::Preview.new(
        **configuration.connection_options,
        preview_token: configuration.preview_token,
        space: configuration.space,
        default_locale: configuration.default_locale,
        connection: configuration.connection,
        environment: configuration.environment,
        instrumentation: instrumentation
      )
    end
end

#preview_store ⇒ Object

An instance of WCC::Contentful::Store::CDNAdapter which connects to the Contentful Preview API to return preview content.

API:

  • Store



49
50
51
52
53
54
55
56
 
# File 'lib/wcc/contentful/services.rb', line 49

def preview_store
  @preview_store ||=
    WCC::Contentful::Store::Factory.new(
      configuration,
      :direct,
      :preview
    ).build(self)
end

#rich_text_renderer ⇒ Object

Returns a callable object which can be used to render a rich text document. This object will have all the connected services injected into it. The implementation class is configured by Configuration#rich_text_renderer. In a rails context the default implementation is ActionViewRichTextRenderer.



135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/wcc/contentful/services.rb', line 135

def rich_text_renderer
  @rich_text_renderer ||=
    if implementation_class = configuration&.rich_text_renderer
      RichTextRendererFactory.new(implementation_class, services: self)
    else
      # Create a renderer that renders a more helpful error message, but delay the error message until #to_html
      # is actually invoked in case the user never actually uses the renderer.
      Class.new(WCC::Contentful::RichTextRenderer) do
        def call
          raise WCC::Contentful::RichTextRenderer::AbstractRendererError,
            'No rich text renderer implementation has been configured.  ' \
            'Please install a supported implementation such as ActionView, ' \
            'or set WCC::Contentful.configuration.rich_text_renderer to a custom implementation.'
        end
      end
    end
end

#store ⇒ Object

Gets the data-store which executes the queries run against the dynamic models in the WCC::Contentful::Model namespace. This is one of the following based on the configured store method:

[:direct] an instance of WCC::Contentful::Store::CDNAdapter with a CDN Client to access the CDN.

[:lazy_sync] an instance of Middleware::Store::CachingMiddleware with the configured ActiveSupport::Cache implementation around a WCC::Contentful::Store::CDNAdapter for when data cannot be found in the cache.

[:eager_sync] an instance of the configured Store type, defined by Configuration#sync_store

API:

  • Store



41
42
43
 
# File 'lib/wcc/contentful/services.rb', line 41

def store
  @store ||= configuration.store.build(self)
end

#sync_engine ⇒ Object

Gets the configured WCC::Contentful::SyncEngine which is responsible for updating the currently configured store. The application must periodically call #next on this instance. Alternately, the application can mount the WCC::Contentful::Engine, which will call #next anytime a webhook is received.

This returns nil if the currently configured store does not respond to sync events.



120
121
122
123
124
125
126
127
128
129
 
# File 'lib/wcc/contentful/services.rb', line 120

def sync_engine
  @sync_engine ||=
    if store.index?
      SyncEngine.new(
        store: store,
        client: client,
        key: 'sync:token'
      )
    end
end