hoodoo 1.11.0 → 1.12.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    Y2FmMmNkOGIxNmI3Yjc3Njk2ZGU4MmJlMzVkZDkyYWQ2ZGI2NGNiNQ==
-  data.tar.gz: !binary |-
-    YWNkMjFhNmMwODQ2OGYxYjZmNDI1ZGIxZGJmNzg3YjQyY2I5ZDMxYw==
+SHA1:
+  metadata.gz: 30fd454d84a35502e8c324645a1c8c981521aa7e
+  data.tar.gz: fae766337e9034cf46e9c030c64d5d6ea0609827
 SHA512:
-  metadata.gz: !binary |-
-    ZWJjN2JjMjA3Zjc1YTRmMzYwN2ZkODYyMzE4M2I2N2VkOTg4M2I1MDBjMDhj
-    ZGE3N2RhNWZlOGMwMDQ2MWVmNzNhMzQ3MWEwZTRiZDhjMjBkMDNjNDdhZjdh
-    ZjYxOGUwYTk1NDFlYTJmY2VhNGYxYWI5ODk5YzdmNDNkOThjYTE=
-  data.tar.gz: !binary |-
-    MmQzNzQxZWI0OTQ2YjI2Nzg1ODAxMzA0ODVlNmM0ODRmMTE2YTY0YmEwYzA2
-    YTdjMzZkMTY4NWRlNjlmMzdhNTc1NDdiYWM4OTQ1YjNkNzQzNjYzZTlmNDFl
-    Nzc3Mzk5ZmFhMDIxOTk0NmY2MzIyMTc2MGQ2YjFlYWQ5MDQxMGQ=
+  metadata.gz: be4607dfff0f5f798b48eb83abbd3985562df696570137f1c7c9fa7fbaad5df227659c274c758c323fb12901365d665c9a1642d743c17103708cb1509b23db3f
+  data.tar.gz: 0c35e38a6740d1e689c361fcf2f0ab07bac09540eb46a9bb1d7ac2f3ab40319c3711b26741fe85c0836e5b1d277208c9c06152f3aa5369745c936714de7a4bf7

data/lib/hoodoo/active/active_record/finder.rb

@@ -20,8 +20,8 @@ module Hoodoo
     #
     # It is _STRONGLY_ _RECOMMENDED_ that you use the likes of:
     #
-    # * Hoodoo::ActiveRecord::Finder::ClassMethods::acquire_in
-    # * Hoodoo::ActiveRecord::Finder::ClassMethods::list_in
+    # * Hoodoo::ActiveRecord::Finder::ClassMethods#acquire_in
+    # * Hoodoo::ActiveRecord::Finder::ClassMethods#list_in
     #
     # ...to retrieve model data related to resource instances and participate
     # "for free" in whatever plug-in ActiveRecord modules are mixed into the
@@ -428,20 +428,14 @@ module Hoodoo
           finder = all.offset( list_parameters.offset ).limit( list_parameters.limit )
           finder = finder.order( list_parameters.sort_data )
 
-          # DRY up the 'each' loops below. Use a Proc not a method because any
-          # methods we define will end up being defined on the including Model,
-          # increasing the chance of a name collision.
-          #
-          dry_proc = Proc.new do | data, attr, proc |
-            value = data[ attr ]
-            proc.call( attr, value ) unless value.nil?
-          end
-
           search_map = self.nz_co_loyalty_hoodoo_search_with
 
           unless search_map.nil?
-            search_map.each do | attr, proc |
-              args   = dry_proc.call( list_parameters.search_data, attr, proc )
+            search_map.each do | attr, finder_args_proc |
+              value = list_parameters.search_data[ attr ]
+              next if value.nil?
+
+              args   = finder_args_proc.call( attr, value )
               finder = finder.where( *args ) unless args.nil?
             end
           end
@@ -449,8 +443,11 @@ module Hoodoo
           filter_map = self.nz_co_loyalty_hoodoo_filter_with
 
           unless filter_map.nil?
-            filter_map.each do | attr, proc |
-              args   = dry_proc.call( list_parameters.filter_data, attr, proc )
+            filter_map.each do | attr, finder_args_proc |
+              value = list_parameters.filter_data[ attr ]
+              next if value.nil?
+
+              args   = finder_args_proc.call( attr, value )
               finder = finder.where.not( *args ) unless args.nil?
             end
           end
@@ -714,7 +711,8 @@ module Hoodoo
         #         which assist with filling in non-nil values for this Hash.
         #
         def search_with( hash )
-          self.nz_co_loyalty_hoodoo_search_with = Hoodoo::ActiveRecord::Support.process_to_map( hash )
+          self.nz_co_loyalty_hoodoo_search_with ||= Hoodoo::ActiveRecord::Support.framework_search_and_filter_data()
+          self.nz_co_loyalty_hoodoo_search_with.merge!( Hoodoo::ActiveRecord::Support.process_to_map( hash ) )
         end
 
         # As #search_with, but used in +where.not+ queries.
@@ -735,7 +733,8 @@ module Hoodoo
         # +map+:: As #search_with.
         #
         def filter_with( hash )
-          self.nz_co_loyalty_hoodoo_filter_with = Hoodoo::ActiveRecord::Support.process_to_map( hash )
+          self.nz_co_loyalty_hoodoo_filter_with ||= Hoodoo::ActiveRecord::Support.framework_search_and_filter_data()
+          self.nz_co_loyalty_hoodoo_filter_with.merge!( Hoodoo::ActiveRecord::Support.process_to_map( hash ) )
         end
 
         # Deprecated interface replaced by #acquire. Instead of:

data/lib/hoodoo/active/active_record/search_helper.rb

@@ -14,8 +14,9 @@ module Hoodoo
     module Finder
 
       # Help build up Hash maps to pass into Hoodoo::ActiveRecord::Finder
-      # methods Hoodoo::ActiveRecord::Finder#search_with and
-      # Hoodoo::ActiveRecord::Finder#filter_with.
+      # methods Hoodoo::ActiveRecord::Finder::ClassMethods#search_with and
+      # Hoodoo::ActiveRecord::Finder::ClassMethods#filter_with. Used also
+      # by the default framework search scopes.
       #
       # The usage pattern is as follows, using "sh" as a local variable
       # just for brevity - it isn't required:
@@ -31,7 +32,7 @@ module Hoodoo
       #     end
       #
       # The helper methods just provide values to pass into the Hash used
-      # with the search/fitler Hoodoo::ActiveRecord::Finder methods, so
+      # with the search/filter Hoodoo::ActiveRecord::Finder methods, so
       # they're optional and compatible with calls that write it out "by
       # hand".
       #
@@ -48,15 +49,16 @@ module Hoodoo
         # will be case sensitive only if your database is configured for
         # case sensitive matching by default.
         #
-        # Results in a <tt>foo = bar</tt> query.
+        # Results in a <tt>foo = bar AND foo IS NOT NULL</tt> query.
         #
         # +model_field_name+:: If the model attribute name differs from the
         #                      search key you want to use in the URI, give
         #                      the model attribute name here, else omit.
         #
         # Returns a value that can be asssigned to a URI query string key in
-        # the Hash given to Hoodoo::ActiveRecord::Finder#search_with or
-        # Hoodoo::ActiveRecord::Finder#filter_with.
+        # the Hash given to
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#search_with or
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#filter_with.
         #
         def self.cs_match( model_field_name = nil )
           Proc.new { | attr, value |
@@ -70,15 +72,17 @@ module Hoodoo
         # which are split into an array then processed by AREL back to
         # something SQL-safe.
         #
-        # Results in a <tt>foo IN bar,baz,boo</tt> query.
+        # Results in a <tt>foo IN (bar,baz,boo) AND foo IS NOT NULL</tt>
+        # query.
         #
         # +model_field_name+:: If the model attribute name differs from the
         #                      search key you want to use in the URI, give
         #                      the model attribute name here, else omit.
         #
         # Returns a value that can be asssigned to a URI query string key in
-        # the Hash given to Hoodoo::ActiveRecord::Finder#search_with or
-        # Hoodoo::ActiveRecord::Finder#filter_with.
+        # the Hash given to
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#search_with or
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#filter_with.
         #
         def self.cs_match_csv( model_field_name = nil )
           Proc.new { | attr, value |
@@ -92,17 +96,20 @@ module Hoodoo
         # Case-sensitive match of a series of values given as an Array.
         # Normally, query string information comes in as a String so the
         # use cases for this are quite unusual; you probably want to use
-        # #cs_match_csv most of the time.
+        # Hoodoo::ActiveRecord::Finder::SearchHelper::cs_match_csv most of
+        # the time.
         #
-        # Results in a <tt>foo IN bar,baz,boo</tt> query.
+        # Results in a <tt>foo IN (bar,baz,boo) AND foo IS NOT NULL</tt>
+        # query.
         #
         # +model_field_name+:: If the model attribute name differs from the
         #                      search key you want to use in the URI, give
         #                      the model attribute name here, else omit.
         #
         # Returns a value that can be asssigned to a URI query string key in
-        # the Hash given to Hoodoo::ActiveRecord::Finder#search_with or
-        # Hoodoo::ActiveRecord::Finder#filter_with.
+        # the Hash given to
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#search_with or
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#filter_with.
         #
         def self.cs_match_array( model_field_name = nil )
           Proc.new { | attr, value |
@@ -113,8 +120,11 @@ module Hoodoo
           }
         end
 
-        # As #cs_match, but adds wildcards at the front and end of the string
-        # for a case-sensitive-all-wildcard match.
+        # As Hoodoo::ActiveRecord::Finder::SearchHelper::cs_match, but
+        # adds wildcards at the front and end of the string for a
+        # case-sensitive-all-wildcard match.
+        #
+        # Results in a <tt>foo LIKE bar AND foo IS NOT NULL</tt> query.
         #
         def self.csaw_match( model_field_name = nil )
           Proc.new { | attr, value |
@@ -127,19 +137,22 @@ module Hoodoo
 
         # Case-insensitive match which should be fairly database independent
         # but will run relatively slowly as a result. If you are using
-        # PostgreSQL, consider using the faster #ci_match_postgres method
+        # PostgreSQL, consider using the faster
+        # Hoodoo::ActiveRecord::Finder::SearchHelper::ci_match_postgres method
         # instead.
         #
-        # Results in a <tt>lower(foo) = bar</tt> query with +bar+ coerced to
-        # a String and converted to lower case by Ruby first.
+        # Results in a <tt>lower(foo) = bar AND foo IS NOT NULL</tt> query
+        # with +bar+ coerced to a String and converted to lower case by Ruby
+        # first.
         #
         # +model_field_name+:: If the model attribute name differs from the
         #                      search key you want to use in the URI, give
         #                      the model attribute name here, else omit.
         #
         # Returns a value that can be asssigned to a URI query string key in
-        # the Hash given to Hoodoo::ActiveRecord::Finder#search_with or
-        # Hoodoo::ActiveRecord::Finder#filter_with.
+        # the Hash given to
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#search_with or
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#filter_with.
         #
         def self.ci_match_generic( model_field_name = nil )
           Proc.new { | attr, value |
@@ -150,8 +163,11 @@ module Hoodoo
           }
         end
 
-        # As #ci_match_generic, but adds wildcards at the front and end of
-        # the string for a case-insensitive-all-wildcard match.
+        # As Hoodoo::ActiveRecord::Finder::SearchHelper::ci_match_generic,
+        # but adds wildcards at the front and end of the string for a
+        # case-insensitive-all-wildcard match.
+        #
+        # Results in a <tt>foo LIKE %bar% AND foo IS NOT NULL</tt> query.
         #
         def self.ciaw_match_generic( model_field_name = nil )
           Proc.new { | attr, value |
@@ -164,17 +180,20 @@ module Hoodoo
 
         # Case-insensitive match which requires PostgreSQL but should run
         # quickly. If you need a database agnostic solution, consider using
-        # the slower #ci_match_generic method instead.
+        # the slower
+        # Hoodoo::ActiveRecord::Finder::SearchHelper::ci_match_generic method
+        # instead.
         #
-        # Results in a <tt>foo ILIKE bar</tt> query.
+        # Results in a <tt>foo ILIKE bar AND foo IS NOT NULL</tt> query.
         #
         # +model_field_name+:: If the model attribute name differs from the
         #                      search key you want to use in the URI, give
         #                      the model attribute name here, else omit.
         #
         # Returns a value that can be asssigned to a URI query string key in
-        # the Hash given to Hoodoo::ActiveRecord::Finder#search_with or
-        # Hoodoo::ActiveRecord::Finder#filter_with.
+        # the Hash given to
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#search_with or
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#filter_with.
         #
         def self.ci_match_postgres( model_field_name = nil )
           Proc.new { | attr, value |
@@ -184,8 +203,11 @@ module Hoodoo
           }
         end
 
-        # As #ci_match_postgres, but adds wildcards at the front and end of
-        # the string for a case-insensitive-all-wildcard match.
+        # As Hoodoo::ActiveRecord::Finder::SearchHelper::ci_match_postgres,
+        # but adds wildcards at the front and end of the string for a
+        # case-insensitive-all-wildcard match.
+        #
+        # Results in a <tt>foo ILIKE %bar% AND foo IS NOT NULL</tt> query.
         #
         def self.ciaw_match_postgres( model_field_name = nil )
           Proc.new { | attr, value |
@@ -194,8 +216,75 @@ module Hoodoo
             [ "#{ column } ILIKE ? AND #{ column } IS NOT NULL", "%#{ value }%" ]
           }
         end
-      end
 
+        # Case-sensitive less-than (default-style comparison). *WARNING:* This
+        # will be case sensitive only if your database is configured for
+        # case sensitive matching by default.
+        #
+        # If comparing non-string column types be sure to pass in a value of an
+        # appropriate matching type (e.g. compare dates with DateTimes), else
+        # returned results will be incorrect but errors may not arise depending
+        # on database engine in use.
+        #
+        # Results in a <tt>foo < bar AND foo IS NOT NULL</tt> query.
+        #
+        # +model_field_name+:: If the model attribute name differs from the
+        #                      search key you want to use in the URI, give
+        #                      the model attribute name here, else omit.
+        #
+        # Returns a value that can be asssigned to a URI query string key in
+        # the Hash given to
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#search_with or
+        # Hoodoo::ActiveRecord::Finder::ClassMethods#filter_with.
+        #
+        def self.cs_lt( model_field_name = nil )
+          Proc.new { | attr, value |
+            column = model_field_name || attr
+
+            [ "#{ column } < ? AND #{ column } IS NOT NULL", value ]
+          }
+        end
+
+        # As Hoodoo::ActiveRecord::Finder::SearchHelper::cs_lt, but
+        # compares with less-than-or-equal-to.
+        #
+        # Results in a <tt>foo <= bar AND foo IS NOT NULL</tt> query.
+        #
+        def self.cs_lte( model_field_name = nil )
+          Proc.new { | attr, value |
+            column = model_field_name || attr
+
+            [ "#{ column } <= ? AND #{ column } IS NOT NULL", value ]
+          }
+        end
+
+        # As Hoodoo::ActiveRecord::Finder::SearchHelper::cs_lt, but
+        # compares with greater-than.
+        #
+        # Results in a <tt>foo > bar AND foo IS NOT NULL</tt> query.
+        #
+        def self.cs_gt( model_field_name = nil )
+          Proc.new { | attr, value |
+            column = model_field_name || attr
+
+            [ "#{ column } > ? AND #{ column } IS NOT NULL", value ]
+          }
+        end
+
+        # As Hoodoo::ActiveRecord::Finder::SearchHelper::cs_lt, but
+        # compares with greater-than-or-equal-to.
+        #
+        # Results in a <tt>foo >= bar AND foo IS NOT NULL</tt> query.
+        #
+        def self.cs_gte( model_field_name = nil )
+          Proc.new { | attr, value |
+            column = model_field_name || attr
+
+            [ "#{ column } >= ? AND #{ column } IS NOT NULL", value ]
+          }
+        end
+
+      end
     end
   end
 end

data/lib/hoodoo/active/active_record/support.rb

@@ -35,6 +35,51 @@ module Hoodoo
     #
     class Support
 
+      # Returns a (newly generated) Hash of search keys mapping to helper Procs
+      # which are in the same format as would be passed to
+      # Hoodoo::ActiveRecord::Finder::ClassMethods#search_with or
+      # Hoodoo::ActiveRecord::Finder::ClassMethods#filter_with, describing the
+      # default framework search parameters. The middleware defines keys, but
+      # each ORM adapter module must specify how those keys actually get used
+      # to search inside supported database engines.
+      #
+      def self.framework_search_and_filter_data
+
+        # The middleware includes framework-level mappings between URI query
+        # string search keys and data validators and processors which convert
+        # types where necessary. For example, 'created_at' must be given a
+        # valid ISO 8601 subset string and a parsed DateTime will end up in
+        # the parsed search hash.
+        #
+        # Services opt out of framework-level searching at an interface level
+        # which means the Finder code herein, under normal flow, will never
+        # be asked to process something the interface omits. There is thus no
+        # need to try and break encapsulation and come up with a way to read
+        # the service interface's omissions. Instead, map everything.
+        #
+        # This could actually be useful if someone manually drives the #list
+        # mechanism with hand-constructed search or filter data that quite
+        # intentionally includes framework level parameters even if their own
+        # service interface for some reason opts out of allowing them to be
+        # exposed to API callers.
+        #
+        # Note that the #search_with / #filter_with DSL declaration in an
+        # appropriately extended model can be used to override the default
+        # values wired in below, because the defaults are established by
+        # design _before_ the model declarations are processed.
+        #
+        mapping = {
+          'created_after'  => Hoodoo::ActiveRecord::Finder::SearchHelper.cs_gt( :created_at ),
+          'created_before' => Hoodoo::ActiveRecord::Finder::SearchHelper.cs_lt( :created_at )
+        }
+
+        if mapping.keys.length != ( mapping.keys | Hoodoo::Services::Middleware::FRAMEWORK_QUERY_DATA.keys ).length
+          raise 'Hoodoo::ActiveRecord::Support#framework_search_and_filter_data: Mismatch between internal mapping and Hoodoo::Services::Middleware::FRAMEWORK_QUERY_DATA'
+        end
+
+        return mapping
+      end
+
       # Takes a Hash of possibly-non-String keys and with +nil+ values or
       # Proc instances appropriate for Hoodoo::ActiveRecord::Finder#search_with
       # / #filter_with. Returns a similar Hash with all-String keys and a Proc

data/lib/hoodoo/client/paginated_enumeration.rb

@@ -52,7 +52,7 @@ module Hoodoo
           if results.size > 0
 
             if results.platform_errors.has_errors?
-              raise "Hoodoo::Client:: PaginatedEnumeration#enumerate_all: Unexpected internal state combination of results set and results error indication"
+              raise 'Hoodoo::Client::PaginatedEnumeration#enumerate_all: Unexpected internal state combination of results set and results error indication'
             end
 
             # Yield a resource at a time to the caller

data/lib/hoodoo/services/middleware/middleware.rb

@@ -175,6 +175,48 @@ module Hoodoo; module Services
       }
     } )
 
+    # A validation Proc for FRAMEWORK_QUERY_DATA - see that for details. This
+    # one ensures that the value is a valid ISO 8601 subset date/time string
+    # and evaluates to the parsed version of that string if so.
+    #
+    FRAMEWORK_QUERY_VALUE_DATE_PROC = -> ( value ) {
+      Hoodoo::Utilities.valid_iso8601_subset_datetime?( value ) ?
+      Hoodoo::Utilities.rationalise_datetime( value )           :
+      nil
+    }
+
+    # Out-of-box search and filter query keys. Interfaces can override the
+    # support for these inside the Hoodoo::Services::Interface.to_list block
+    # using Hoodoo::Services::Interface::ToListDSL.do_not_search and
+    # Hoodoo::Services::Interface::ToListDSL.do_not_filter.
+    #
+    # Keys, in order, are:
+    #
+    # * Query key to detect records with a +created_at+ date that is after the
+    #   given value, in supporting resource; if used as a filter instead of a
+    #   search string, would find records on-or-before the date.
+    #
+    # * Query key to detect records with a +created_at+ date that is before
+    #   the given value, in supporting resource; if used as a filter instead
+    #   of a search string, would find records on-or-after the date.
+    #
+    # Values are either a validation Proc or +nil+ for no validation. The
+    # Proc takes the search query value as its sole input paraeter and must
+    # evaluate to the input value either unmodified or in some canonicalised
+    # form if it is valid, else to +nil+ if the input value is invalid. The
+    # canonicalisation is typically used to coerce a URI query string based
+    # String type into a more useful comparable entity such as an Integer or
+    # DateTime.
+    #
+    # *IMPORTANT* - if this list is changed, any database support modules -
+    # e.g. in Hoodoo::ActiveRecord::Support - will need any internal mapping
+    # of "framework query keys to module-appropriate query code" updating.
+    #
+    FRAMEWORK_QUERY_DATA = {
+      'created_after'  => FRAMEWORK_QUERY_VALUE_DATE_PROC,
+      'created_before' => FRAMEWORK_QUERY_VALUE_DATE_PROC,
+    }
+
     # Utility - returns the execution environment as a Rails-like environment
     # object which answers queries like +production?+ or +staging?+ with +true+
     # or +false+ according to the +RACK_ENV+ environment variable setting.
@@ -2770,21 +2812,52 @@ module Hoodoo; module Services
         end
       end
 
-      search = query_hash[ 'search' ] || {}
-      unrecognised_search_keys = search.keys - interface.to_list.search
-      malformed << "search: #{ unrecognised_search_keys.join(', ') }" unless unrecognised_search_keys.empty?
+      search           = query_hash[ 'search' ] || {}
+      framework_search = FRAMEWORK_QUERY_DATA.keys - interface.to_list.do_not_search
+      bad_search_keys  = search.keys - framework_search - interface.to_list.search
+
+      framework_search.each do | search_key |
+        next unless search.has_key?( search_key )
+
+        search_value = search[ search_key ]
+        validator    = FRAMEWORK_QUERY_DATA[ search_key ]
+        canonical    = validator.call( search_value )
+
+        if canonical.nil?
+          bad_search_keys << search_key
+        else
+          search[ search_key ] = canonical
+        end
+      end
+
+      filter           = query_hash[ 'filter' ] || {}
+      framework_filter = FRAMEWORK_QUERY_DATA.keys - interface.to_list.do_not_filter
+      bad_filter_keys  = filter.keys - framework_filter - interface.to_list.filter
+
+      framework_filter.each do | filter_key |
+        next unless filter.has_key?( filter_key )
+
+        filter_value = filter[ filter_key ]
+        validator    = FRAMEWORK_QUERY_DATA[ filter_key ]
+        canonical    = validator.call( filter_value )
+
+        if canonical.nil?
+          bad_filter_keys << filter_key
+        else
+          filter[ filter_key ] = canonical
+        end
+      end
 
-      filter = query_hash[ 'filter' ] || {}
-      unrecognised_filter_keys = filter.keys - interface.to_list.filter
-      malformed << "filter: #{ unrecognised_filter_keys.join(', ') }" unless unrecognised_filter_keys.empty?
+      embeds           = query_hash[ '_embed' ] || []
+      bad_embeds       = embeds - interface.embeds
 
-      embeds = query_hash[ '_embed' ] || []
-      unrecognised_embeds = embeds - interface.embeds
-      malformed << "_embed: #{ unrecognised_embeds.join(', ') }" unless unrecognised_embeds.empty?
+      references       = query_hash[ '_reference' ] || []
+      bad_references   = references - interface.embeds # (sic.)
 
-      references = query_hash[ '_reference' ] || []
-      unrecognised_references = references - interface.embeds # (sic.)
-      malformed << "_reference: #{ unrecognised_references.join(', ') }" unless unrecognised_references.empty?
+      malformed <<     "search: #{ bad_search_keys.join( ', ' ) }" unless bad_search_keys.empty?
+      malformed <<     "filter: #{ bad_filter_keys.join( ', ' ) }" unless bad_filter_keys.empty?
+      malformed <<     "_embed: #{ bad_embeds.join( ', ' ) }"      unless bad_embeds.empty?
+      malformed << "_reference: #{ bad_references.join( ', ' ) }"  unless bad_references.empty?
 
       return response.add_error(
         'platform.malformed',