wcc-contentful 1.0.7 → 1.1.2

data/lib/wcc/contentful/model_api.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/introspection'
+
+module WCC::Contentful::ModelAPI
+  extend ActiveSupport::Concern
+
+  included do
+    include WCC::Contentful::Instrumentation
+
+    # override class-level _instrumentation from WCC::Contentful::Instrumentation
+    def self._instrumentation
+      services.instrumentation
+    end
+
+    # Set the registry at the top of the namespace
+    @registry = {}
+  end
+
+  class_methods do
+    attr_reader :configuration
+
+    def configure(configuration = nil, schema: nil, services: nil)
+      configuration ||= @configuration || WCC::Contentful::Configuration.new
+      yield(configuration) if block_given?
+
+      @schema = schema if schema
+      @services = services if services
+      @configuration = configuration.freeze
+
+      WCC::Contentful::ModelBuilder.new(self.schema, namespace: self).build_models
+      nil
+    end
+
+    def services
+      @services ||=
+        # try looking up the class heierarchy
+        (superclass.services if superclass.respond_to?(:services)) ||
+        # create it if we have a configuration
+        WCC::Contentful::Services.new(configuration)
+    end
+
+    def store(preview = nil)
+      ActiveSupport::Deprecation.warn('Use services.store instead')
+
+      preview ? services.preview_store : services.store
+    end
+
+    def schema
+      return @schema if @schema
+
+      file = configuration.schema_file
+      schema_json = JSON.parse(File.read(file))['contentTypes']
+      unless schema_json
+        raise ArgumentError, 'Please give either a JSON array of content types or file to load from'
+      end
+
+      @schema = WCC::Contentful::ContentTypeIndexer.from_json_schema(schema_json).types
+    end
+
+    # Finds an Entry or Asset by ID in the configured contentful space
+    # and returns an initialized instance of the appropriate model type.
+    #
+    # Makes use of the {WCC::Contentful::Services#store configured store}
+    # to access the Contentful CDN.
+    def find(id, options: nil)
+      options ||= {}
+      store = options[:preview] ? services.preview_store : services.store
+      raw =
+        _instrumentation.instrument 'find.model.contentful.wcc', id: id, options: options do
+          store.find(id, options.except(*WCC::Contentful::ModelMethods::MODEL_LAYER_CONTEXT_KEYS))
+        end
+
+      new_from_raw(raw, options) if raw.present?
+    end
+
+    # Creates a new initialized instance of the appropriate model type for the
+    # given raw value.  The raw value must be the same format as returned from one
+    # of the stores for a given object.
+    def new_from_raw(raw, context = nil)
+      content_type = WCC::Contentful::Helpers.content_type_from_raw(raw)
+      const = resolve_constant(content_type)
+      const.new(raw, context)
+    end
+
+    # Accepts a content type ID as a string and returns the Ruby constant
+    # stored in the registry that represents this content type.
+    def resolve_constant(content_type)
+      raise ArgumentError, 'content_type cannot be nil' unless content_type
+
+      const = _registry[content_type]
+      return const if const
+
+      const_name = WCC::Contentful::Helpers.constant_from_content_type(content_type).to_s
+      # #parent renamed to #module_parent in Rails 6
+      parent = try(:module_parent) || self.parent
+
+      loop do
+        begin
+          # The app may have defined a model and we haven't loaded it yet
+          const = parent.const_missing(const_name)
+          return const if const && const < self
+        rescue NameError => e
+          raise e unless e.message =~ /uninitialized constant (.+::)*#{const_name}$/
+        end
+
+        # const_missing only searches recursively up the module tree in a Rails
+        # context.  If we're in a non-Rails app, we have to do that recursion ourselves.
+        # Keep looking upwards until we get to Object.
+        break if parent == Object
+
+        parent = parent.try(:module_parent) || parent.parent
+      end
+
+      # Autoloading couldn't find their model - we'll register our own.
+      const = const_get(
+        WCC::Contentful::Helpers.constant_from_content_type(content_type)
+      )
+      register_for_content_type(content_type, klass: const)
+    end
+
+    # Registers a class constant to be instantiated when resolving an instance
+    # of the given content type.  This automatically happens for the first subclass
+    # of a generated model type, example:
+    #
+    #   class MyMenu < WCC::Contentful::Model::Menu
+    #   end
+    #
+    # In the above case, instances of MyMenu will be instantiated whenever a 'menu'
+    # content type is resolved.
+    # The mapping can be made explicit with the optional parameters.  Example:
+    #
+    #   class MyFoo < WCC::Contentful::Model::Foo
+    #     register_for_content_type 'bar' # MyFoo is assumed
+    #   end
+    #
+    #   # in initializers/wcc_contentful.rb
+    #   WCC::Contentful::Model.register_for_content_type('bar', klass: MyFoo)
+    def register_for_content_type(content_type = nil, klass: nil)
+      klass ||= self
+      raise ArgumentError, "#{klass} must be a class constant!" unless klass.respond_to?(:new)
+
+      content_type ||= WCC::Contentful::Helpers.content_type_from_constant(klass)
+
+      _registry[content_type] = klass
+    end
+
+    # Returns the current registry of content type names to constants.
+    def registry
+      return {} unless _registry
+
+      _registry.dup.freeze
+    end
+
+    def reload!
+      registry = self.registry
+      registry.each do |(content_type, klass)|
+        const_name = klass.name
+        begin
+          # the const_name is fully qualified so search from root
+          const = Object.const_missing(const_name)
+          register_for_content_type(content_type, klass: const) if const
+        rescue NameError => e
+          msg = "Error when reloading constant #{const_name} - #{e}"
+          if defined?(Rails) && Rails.logger
+            Rails.logger.error msg
+          else
+            puts msg
+          end
+        end
+      end
+    end
+
+    # Checks if a content type has already been registered to a class and returns
+    # that class.  If nil, the generated WCC::Contentful::Model::{content_type} class
+    # will be resolved for this content type.
+    def registered?(content_type)
+      _registry[content_type]
+    end
+
+    protected
+
+    def _registry
+      # If calling register_for_content_type in a subclass, look up the superclass
+      # chain until we get to the model namespace which defines the registry
+      @registry || superclass._registry
+    end
+  end
+end

data/lib/wcc/contentful/model_builder.rb

@@ -7,8 +7,11 @@ module WCC::Contentful
   class ModelBuilder
     include Helpers
 
-    def initialize(types)
+    attr_reader :namespace
+
+    def initialize(types, namespace: WCC::Contentful::Model)
       @types = types
+      @namespace = namespace
     end
 
     def build_models
@@ -21,12 +24,13 @@ module WCC::Contentful
 
     def build_model(typedef)
       const = typedef.name
-      return WCC::Contentful::Model.const_get(const) if WCC::Contentful::Model.const_defined?(const)
+      ns = namespace
+      return ns.const_get(const) if ns.const_defined?(const)
 
       # TODO: https://github.com/dkubb/ice_nine ?
       typedef = typedef.deep_dup.freeze
-      WCC::Contentful::Model.const_set(const,
-        Class.new(WCC::Contentful::Model) do
+      ns.const_set(const,
+        Class.new(namespace) do
           extend ModelSingletonMethods
           include ModelMethods
           include Helpers
@@ -50,6 +54,8 @@ module WCC::Contentful
             typedef
           end
 
+          define_singleton_method(:model_namespace) { ns }
+
           define_method(:initialize) do |raw, context = nil|
             ct = content_type_from_raw(raw)
             if ct != typedef.content_type

data/lib/wcc/contentful/model_methods.rb

@@ -5,8 +5,6 @@
 #
 # @api Model
 module WCC::Contentful::ModelMethods
-  include WCC::Contentful::Instrumentation
-
   # The set of options keys that are specific to the Model layer and shouldn't
   # be passed down to the Store layer.
   MODEL_LAYER_CONTEXT_KEYS = %i[
@@ -40,6 +38,7 @@ module WCC::Contentful::ModelMethods
 
     typedef = self.class.content_type_definition
     links = fields.select { |f| %i[Asset Link].include?(typedef.fields[f].type) }
+    store = context[:preview] ? self.class.services.preview_store : self.class.services.store
 
     raw_link_ids =
       links.map { |field_name| raw.dig('fields', field_name, sys.locale) }
@@ -54,12 +53,11 @@ module WCC::Contentful::ModelMethods
       raw =
         _instrument 'resolve', id: id, depth: depth, backlinks: backlinked_ids do
           # use include param to do resolution
-          self.class.store(context[:preview])
-            .find_by(content_type: self.class.content_type,
-                     filter: { 'sys.id' => id },
-                     options: context.except(*MODEL_LAYER_CONTEXT_KEYS).merge!({
-                       include: [depth, 10].min
-                     }))
+          store.find_by(content_type: self.class.content_type,
+                        filter: { 'sys.id' => id },
+                        options: context.except(*MODEL_LAYER_CONTEXT_KEYS).merge!({
+                          include: [depth, 10].min
+                        }))
         end
       unless raw
         raise WCC::Contentful::ResolveError, "Cannot find #{self.class.content_type} with ID #{id}"
@@ -170,10 +168,10 @@ module WCC::Contentful::ModelMethods
           if raw.dig('sys', 'type') == 'Link'
             _instrument 'resolve',
               id: self.id, depth: depth, backlinks: context[:backlinks]&.map(&:id) do
-              WCC::Contentful::Model.find(id, options: new_context)
+              self.class.model_namespace.find(id, options: new_context)
             end
           else
-            WCC::Contentful::Model.new_from_raw(raw, new_context)
+            self.class.model_namespace.new_from_raw(raw, new_context)
           end
 
         m.resolve(depth: depth - 1, context: new_context, **options) if m && depth > 1

data/lib/wcc/contentful/model_singleton_methods.rb

@@ -12,9 +12,9 @@ module WCC::Contentful::ModelSingletonMethods
   #   WCC::Contentful::Model::Page.find(id)
   def find(id, options: nil)
     options ||= {}
-    store = store(options[:preview])
+    store = options[:preview] ? services.preview_store : services.store
     raw =
-      WCC::Contentful::Instrumentation.instrument 'find.model.contentful.wcc',
+      _instrumentation.instrument 'find.model.contentful.wcc',
         content_type: content_type, id: id, options: options do
         store.find(id, { hint: type }.merge!(options.except(:preview)))
       end
@@ -34,9 +34,9 @@ module WCC::Contentful::ModelSingletonMethods
 
     filter.transform_keys! { |k| k.to_s.camelize(:lower) } if filter.present?
 
-    store = store(options[:preview])
+    store = options[:preview] ? services.preview_store : services.store
     query =
-      WCC::Contentful::Instrumentation.instrument 'find_all.model.contentful.wcc',
+      _instrumentation.instrument 'find_all.model.contentful.wcc',
         content_type: content_type, filter: filter, options: options do
         store.find_all(content_type: content_type, options: options.except(:preview))
       end
@@ -56,9 +56,9 @@ module WCC::Contentful::ModelSingletonMethods
 
     filter.transform_keys! { |k| k.to_s.camelize(:lower) } if filter.present?
 
-    store = store(options[:preview])
+    store = options[:preview] ? services.preview_store : services.store
     result =
-      WCC::Contentful::Instrumentation.instrument 'find_by.model.contentful.wcc',
+      _instrumentation.instrument 'find_by.model.contentful.wcc',
         content_type: content_type, filter: filter, options: options do
         store.find_by(content_type: content_type, filter: filter, options: options.except(:preview))
       end
@@ -69,9 +69,9 @@ module WCC::Contentful::ModelSingletonMethods
   def inherited(subclass)
     # If another different class is already registered for this content type,
     # don't auto-register this one.
-    return if WCC::Contentful::Model.registered?(content_type)
+    return if model_namespace.registered?(content_type)
 
-    WCC::Contentful::Model.register_for_content_type(content_type, klass: subclass)
+    model_namespace.register_for_content_type(content_type, klass: subclass)
   end
 
   class ModelQuery

data/lib/wcc/contentful/rspec.rb

@@ -12,16 +12,18 @@ module WCC::Contentful::RSpec
   # Builds out a fake Contentful entry for the given content type, and then
   # stubs the Model API to return that content type for `.find` and `.find_by`
   # query methods.
-  def contentful_stub(content_type, **attrs)
-    const = WCC::Contentful::Model.resolve_constant(content_type.to_s)
-    instance = contentful_create(content_type, **attrs)
+  def contentful_stub(const, **attrs)
+    unless const.respond_to?(:content_type_definition)
+      const = WCC::Contentful::Model.resolve_constant(const.to_s)
+    end
+    instance = contentful_create(const, **attrs)
 
     # mimic what's going on inside model_singleton_methods.rb
     # find, find_by, etc always return a new instance from the same raw
     allow(WCC::Contentful::Model).to receive(:find)
       .with(instance.id, any_args) do |_id, keyword_params|
         options = keyword_params && keyword_params[:options]
-        contentful_create(content_type, options, raw: instance.raw, **attrs)
+        contentful_create(const, options, raw: instance.raw, **attrs)
       end
     allow(const).to receive(:find) { |id, options| WCC::Contentful::Model.find(id, **(options || {})) }
 
@@ -31,7 +33,7 @@ module WCC::Contentful::RSpec
           filter = filter&.dup
           options = filter&.delete(:options) || {}
 
-          contentful_create(content_type, options, raw: instance.raw, **attrs)
+          contentful_create(const, options, raw: instance.raw, **attrs)
         end
     end
 

data/lib/wcc/contentful/services.rb

@@ -4,15 +4,16 @@ module WCC::Contentful
   class Services
     class << self
       def instance
-        @singleton__instance__ ||= new # rubocop:disable Naming/MemoizedInstanceVariableName
+        @singleton__instance__ ||= # rubocop:disable Naming/MemoizedInstanceVariableName
+          (new(WCC::Contentful.configuration) if WCC::Contentful.configuration)
       end
     end
 
-    def configuration
-      @configuration ||= WCC::Contentful.configuration
-    end
+    attr_reader :configuration
+
+    def initialize(configuration)
+      raise ArgumentError, 'Not yet configured!' unless configuration
 
-    def initialize(configuration = nil)
       @configuration = configuration
     end
 
@@ -33,10 +34,7 @@ module WCC::Contentful
     #
     # @api Store
     def store
-      @store ||=
-        ensure_configured do |config|
-          config.store.build(self)
-        end
+      @store ||= configuration.store.build(self)
     end
 
     # An instance of {WCC::Contentful::Store::CDNAdapter} which connects to the
@@ -45,13 +43,11 @@ module WCC::Contentful
     # @api Store
     def preview_store
       @preview_store ||=
-        ensure_configured do |config|
-          WCC::Contentful::Store::Factory.new(
-            config,
-            :direct,
-            :preview
-          ).build(self)
-        end
+        WCC::Contentful::Store::Factory.new(
+          configuration,
+          :direct,
+          :preview
+        ).build(self)
     end
 
     # Gets a {WCC::Contentful::SimpleClient::Cdn CDN Client} which provides
@@ -60,16 +56,15 @@ module WCC::Contentful
     # @api Client
     def client
       @client ||=
-        ensure_configured do |config|
-          WCC::Contentful::SimpleClient::Cdn.new(
-            **config.connection_options,
-            access_token: config.access_token,
-            space: config.space,
-            default_locale: config.default_locale,
-            connection: config.connection,
-            environment: config.environment
-          )
-        end
+        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
 
     # Gets a {WCC::Contentful::SimpleClient::Cdn CDN Client} which provides
@@ -78,17 +73,16 @@ module WCC::Contentful
     # @api Client
     def preview_client
       @preview_client ||=
-        ensure_configured do |config|
-          if config.preview_token.present?
-            WCC::Contentful::SimpleClient::Preview.new(
-              **config.connection_options,
-              preview_token: config.preview_token,
-              space: config.space,
-              default_locale: config.default_locale,
-              connection: config.connection,
-              environment: config.environment
-            )
-          end
+        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
 
@@ -98,17 +92,16 @@ module WCC::Contentful
     # @api Client
     def management_client
       @management_client ||=
-        ensure_configured do |config|
-          if config.management_token.present?
-            WCC::Contentful::SimpleClient::Management.new(
-              **config.connection_options,
-              management_token: config.management_token,
-              space: config.space,
-              default_locale: config.default_locale,
-              connection: config.connection,
-              environment: config.environment
-            )
-          end
+        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
 
@@ -132,25 +125,30 @@ module WCC::Contentful
 
     # Gets the configured instrumentation adapter, defaulting to ActiveSupport::Notifications
     def instrumentation
-      return @instrumentation if @instrumentation
-      return ActiveSupport::Notifications if WCC::Contentful.configuration.nil?
-
       @instrumentation ||=
-        WCC::Contentful.configuration.instrumentation_adapter ||
+        configuration.instrumentation_adapter ||
         ActiveSupport::Notifications
     end
-
-    private
-
-    def ensure_configured
-      raise StandardError, 'WCC::Contentful has not yet been configured!' if configuration.nil?
-
-      yield configuration
+    # Allow it to be injected into a store
+    alias_method :_instrumentation, :instrumentation
+
+    ##
+    # 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.
+    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
   end
 
-  SERVICES = (WCC::Contentful::Services.instance_methods -
-      Object.instance_methods)
+  SERVICES =
+    WCC::Contentful::Services.instance_methods(false)
+      .select { |m| WCC::Contentful::Services.instance_method(m).arity == 0 }
 
   # Include this module to define accessors for every method defined on the
   # {Services} singleton.

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

@@ -105,6 +105,11 @@ module WCC::Contentful::Store
 
       def apply_operator(operator, field, expected, context = nil)
         op = operator == :eq ? nil : operator
+        if expected.is_a?(Array)
+          expected = expected.join(',')
+          op = :in if op.nil?
+        end
+
         param = parameter(field, operator: op, context: context, locale: true)
 
         self.class.new(
@@ -158,7 +163,8 @@ module WCC::Contentful::Store
       def resolve_includes(entry, depth)
         return entry unless entry && depth && depth > 0
 
-        WCC::Contentful::LinkVisitor.new(entry, :Link, :Asset, depth: depth - 1).map! do |val|
+        # Dig links out of response.includes and insert them into the entry
+        WCC::Contentful::LinkVisitor.new(entry, :Link, depth: depth - 1).map! do |val|
           resolve_link(val)
         end
       end

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

@@ -75,6 +75,7 @@ module WCC::Contentful::Store
           middleware, params, configure_proc = middleware_config
           middleware_options = options.merge((params || []).extract_options!)
           middleware = middleware.call(memo, *params, **middleware_options)
+          services.inject_into(middleware, except: %i[store preview_store])
           middleware&.instance_exec(&configure_proc) if configure_proc
           middleware || memo
         end
@@ -154,12 +155,7 @@ module WCC::Contentful::Store
         end
 
       # Inject services into the custom store class
-      (WCC::Contentful::SERVICES - %i[store preview_store]).each do |s|
-        next unless store.respond_to?("#{s}=")
-
-        store.public_send("#{s}=",
-          services.public_send(s))
-      end
+      services.inject_into(store, except: %i[store preview_store])
 
       store
     end

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

@@ -38,7 +38,13 @@ module WCC::Contentful::Store
       end
     end
 
+    SUPPORTED_OPS = %i[eq ne in nin].freeze
+
     def execute(query)
+      (query.conditions.map(&:op) - SUPPORTED_OPS).each do |op|
+        raise ArgumentError, "Operator :#{op} not supported"
+      end
+
       relation = mutex.with_read_lock { @hash.values }
 
       # relation is an enumerable that we apply conditions to in the form of
@@ -56,21 +62,49 @@ module WCC::Contentful::Store
       # For each condition, we apply a new Enumerable#select with a block that
       # enforces the condition.
       query.conditions.reduce(relation) do |memo, condition|
-        memo.select do |entry|
-          # Our naiive implementation only supports equality operator
-          raise ArgumentError, "Operator #{condition.op} not supported" unless condition.op == :eq
+        __send__("apply_#{condition.op}", memo, condition)
+      end
+    end
 
-          # The condition's path tells us where to find the value in the JSON object
-          val = entry.dig(*condition.path)
+    private
 
-          # For arrays, equality is defined as does the array include the expected value.
-          # See https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/search-parameters/array-equality-inequality
-          if val.is_a? Array
-            val.include?(condition.expected)
-          else
-            val == condition.expected
-          end
-        end
+    def apply_eq(memo, condition)
+      memo.select { |entry| eq?(entry, condition) }
+    end
+
+    def apply_ne(memo, condition)
+      memo.reject { |entry| eq?(entry, condition) }
+    end
+
+    def eq?(entry, condition)
+      # The condition's path tells us where to find the value in the JSON object
+      val = entry.dig(*condition.path)
+
+      # For arrays, equality is defined as does the array include the expected value.
+      # See https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/search-parameters/array-equality-inequality
+      if val.is_a? Array
+        val.include?(condition.expected)
+      else
+        val == condition.expected
+      end
+    end
+
+    def apply_in(memo, condition)
+      memo.select { |entry| in?(entry, condition) }
+    end
+
+    def apply_nin(memo, condition)
+      memo.reject { |entry| in?(entry, condition) }
+    end
+
+    def in?(entry, condition)
+      val = entry.dig(*condition.path)
+
+      if val.is_a? Array
+        # TODO: detect if in ruby 3.1 and use val.intersect?(condition.expected)
+        val.any? { |item| condition.expected.include?(item) }
+      else
+        condition.expected.include?(val)
       end
     end
   end