hoodoo 2.4.3 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce758beb5008e4badbf7b78e912ed1a3fc09e5659f3a1dd585ad13f69571d568
-  data.tar.gz: 76573396fd9b41de0098b8c511ce5601137d289f751cac9597c91d1bc13ea1ac
+  metadata.gz: 82cf349eadbadcea2eaeb98421fb6a9e8b35dd5b0f037b2089ff553d99b650d0
+  data.tar.gz: 20564a912fb0e68505cb59721b081a61a64227b9676343180b117bcc9246a982
 SHA512:
-  metadata.gz: 19d0366a7da0aaa8c228d4aa1a96f2bd5701bdb9ea70a56c159bca77b959f2705c16b2b803fc3e894f6eeb24d24acb4d63bc0c2b84118673b121f46daf21de38
-  data.tar.gz: 25853720d4851bdd5c992c40645385fd146cfbb0033d17925b6216c4ff97d6fc1d7b9e4244c323ef0696d21e139c2a30c5116e2315e20a179b952803bccadd26
+  metadata.gz: 555bb645bc07d3b4db3ff5341683ea98d5dfeea6a7dc1347723f892a36171da59f6faccb36e4a75e8a4b950c62c173b969e435e3eb8c37bb58319b5753be442c
+  data.tar.gz: 7f4c18b64388d17816227885ba6078d0ddc6fd009ede81e00b76e799c42e0e93b2033eec1e0a9bfb5417449cee5869fa0fc6b78da100873d6d2a00e3f50f92cd

data/lib/hoodoo/client/client.rb

@@ -63,12 +63,12 @@ module Hoodoo
       # implementation of such a Resource interface available! - as follows:
       #
       #     results = members.list(
-      #       :offset    => 50,
-      #       :limit     => 25,
-      #       :sort      => :created_at,
-      #       :direction => :asc,
-      #       :search    => { :surname => 'Smith' },
-      #       :_embed    => 'account'
+      #       offset:    50,
+      #       limit:     25,
+      #       sort:      'created_at',
+      #       direction: 'asc',
+      #       search:    { 'surname' => 'Smith' },
+      #       _embed:    'account'
       #     )
       #
       # This will return a Hoodoo::Client::AugmentedArray. This is an Array

data/lib/hoodoo/client/endpoint/endpoint.rb

@@ -189,7 +189,7 @@ module Hoodoo
       # +query_hash+:: A hash of _unencoded_ data that can be encoded to form
       #                a query string. Search and filter data is represented
       #                with nested hashes. Embed and reference data uses an
-      #                array. Example:
+      #                array. All keys are Strings. Example:
       #
       #                   {
       #                     offset:    75,
@@ -328,13 +328,13 @@ module Hoodoo
         # Returns the +augmented_array+ passed in, with the +next_page_proc+
         # value set.
         #
-        def inject_enumeration_state ( augmented_array, query_hash )
+        def inject_enumeration_state( augmented_array, query_hash )
 
           endpoint                       = self
           query_hash                     = query_hash.nil? ? {} : query_hash.dup
           batch_size                     = [ 1, augmented_array.size ].max
           augmented_array.next_page_proc = Proc.new do
-            query_hash[ :offset ] = ( query_hash[ :offset ] || 0 ) + batch_size
+            query_hash[ 'offset' ] = ( query_hash[ 'offset' ] || 0 ) + batch_size
             endpoint.list( query_hash )
           end
 

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

@@ -162,13 +162,7 @@ module Hoodoo; module Services
                 :embeds              => context.request.embeds,
                 :references          => context.request.references,
                 :headers             => context.request.headers,
-                :list                => {
-                  :offset      => context.request.list.offset,
-                  :limit       => context.request.list.limit,
-                  :sort_data   => context.request.list.sort_data,
-                  :search_data => context.request.list.search_data,
-                  :filter_data => context.request.list.filter_data
-                }
+                :list                => context.request.list.to_h
               }
             }
 

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

@@ -1292,6 +1292,11 @@ module Hoodoo; module Services
       #
       # For other kinds of data, check the secure actions to see if the body
       # should be included.
+      #
+      # TODO: This uses deprecated acccessors into the "context.request.list"
+      #       object, but it keeps the code simple. It'd be nice to just have
+      #       e.g. "data[ :list ] = context.request.list.to_h()" but the
+      #       change in log output format might break dependent clients.
 
       if context.response.body.is_a?( ::Array )
         attributes       = %i( list_offset list_limit list_sort_data list_search_data list_filter_data embeds references )

data/lib/hoodoo/services/services/request.rb

@@ -63,6 +63,46 @@ module Hoodoo; module Services
         self.search_data = {}
         self.filter_data = {}
       end
+
+      # Represent the list data as a Hash, for uses such as persistence
+      # or loading into another session instance. The returned Hash is a
+      # full deep copy of any internal data; changing it will not alter
+      # the ListParameters object state.
+      #
+      # Top-level keys in the Hash are Strings corresponding to the names
+      # of accessor parameters:
+      #
+      #   * +"offset"+
+      #   * +"limit"+
+      #   * +"sort_data"+
+      #   * +"search_data"+
+      #   * +"filter_data"+
+      #
+      # Sort, search and filter data, if not empty, also have String keys.
+      #
+      # See also #from_h!.
+      #
+      def to_h
+        {
+          'offset'      => self.offset,
+          'limit'       => self.limit,
+          'sort_data'   => Hoodoo::Utilities.deep_dup( self.sort_data   ),
+          'search_data' => Hoodoo::Utilities.deep_dup( self.search_data ),
+          'filter_data' => Hoodoo::Utilities.deep_dup( self.filter_data )
+        }
+      end
+
+      # Load list parameters from a given Hash, of the form set by #to_h.
+      # Overwrites any corresponding internal attributes and takes full
+      # deep copies of sort, search and filter values.
+      #
+      def from_h!( hash )
+        self.offset      = hash[ 'offset' ] if hash.has_key?( 'offset' )
+        self.limit       = hash[ 'limit'  ] if hash.has_key?( 'limit'  )
+        self.sort_data   = Hoodoo::Utilities.deep_dup( hash[ 'sort_data'   ] ) if hash[ 'sort_data'   ].is_a?( Hash )
+        self.search_data = Hoodoo::Utilities.deep_dup( hash[ 'search_data' ] ) if hash[ 'search_data' ].is_a?( Hash )
+        self.filter_data = Hoodoo::Utilities.deep_dup( hash[ 'filter_data' ] ) if hash[ 'filter_data' ].is_a?( Hash )
+      end
     end
 
     # Requested locale for internationalised operations; +"en-nz"+ by

data/lib/hoodoo/version.rb

@@ -12,11 +12,11 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, be sure to re-run
   # <tt>bundle install</tt> or <tt>bundle update</tt>.
   #
-  VERSION = '2.4.3'
+  VERSION = '2.5.0'
 
   # The Hoodoo gem date. If this changes, be sure to re-run
   # <tt>bundle install</tt> or <tt>bundle update</tt>.
   #
-  DATE = '2018-04-30'
+  DATE = '2018-05-17'
 
 end

data/spec/services/middleware/exception_reporting/base_reporter_spec.rb

@@ -88,11 +88,11 @@ describe Hoodoo::Services::Middleware::ExceptionReporting::BaseReporter do
             :references          => [ 'r1', 'r2' ],
             :headers             => { 'HTTP_X_EXAMPLE' => '42' },
             :list                => {
-              :offset      => 0,
-              :limit       => 50,
-              :sort_data   => { 'created_at' => 'desc' },
-              :search_data => { 'example'    => '42'   },
-              :filter_data => { 'unexample'  => '24'   }
+              'offset'      => 0,
+              'limit'       => 50,
+              'sort_data'   => { 'created_at' => 'desc' },
+              'search_data' => { 'example'    => '42'   },
+              'filter_data' => { 'unexample'  => '24'   }
             }
           },
           :session => Hoodoo::Services::Middleware.test_session().to_h()

data/spec/services/services/request_spec.rb

@@ -1,12 +1,30 @@
 require 'spec_helper'
 
 describe Hoodoo::Services::Request do
-  context 'uri_path_components' do
-    before do
-      @r = Hoodoo::Services::Request.new
-    end
+  before do
+    @r = Hoodoo::Services::Request.new
+  end
+
+  it 'has correct default values' do
 
-    it 'should record path components properly' do
+    # For list parameters in @r.list, see later.
+    #
+    expect( @r.locale              ).to eq( 'en-nz' )
+    expect( @r.dated_at            ).to eq( nil     )
+    expect( @r.body                ).to eq( nil     )
+    expect( @r.uri_path_components ).to eq( []      )
+    expect( @r.ident               ).to eq( nil     )
+    expect( @r.uri_path_extension  ).to eq( ''      )
+    expect( @r.embeds              ).to eq( []      )
+    expect( @r.references          ).to eq( []      )
+    expect( @r.headers             ).to eq( {}      )
+
+    expect( @r.headers.frozen? ).to eq( true )
+
+  end
+
+  context 'uri_path_components' do
+    it 'records path components properly' do
       ary = [ 'one', 'two', 'three' ]
       @r.uri_path_components = ary
 
@@ -14,7 +32,7 @@ describe Hoodoo::Services::Request do
       expect(@r.ident).to eq(ary.first)
     end
 
-    it 'should deal with nil path components properly' do
+    it 'deals with nil path components properly' do
       ary = nil
       @r.uri_path_components = ary
 
@@ -22,56 +40,165 @@ describe Hoodoo::Services::Request do
       expect(@r.ident).to be_nil
     end
 
-    it 'should deal with non-array path components properly' do
+    it 'deals with non-array path components properly' do
       ary = 'not an array'
       @r.uri_path_components = ary
 
       expect(@r.uri_path_components).to be_nil
       expect(@r.ident).to be_nil
     end
+  end
 
-    it 'rationalises date/time' do
-      [ :dated_at, :dated_from ].each do | attr |
-        now = DateTime.now
-        @r.send( "#{ attr }=", now )
-        expect( @r.send( attr ) ).to eq( now )
+  it 'rationalises date/time' do
+    [ :dated_at, :dated_from ].each do | attr |
+      now = DateTime.now
+      @r.send( "#{ attr }=", now )
+      expect( @r.send( attr ) ).to eq( now )
 
-        now = DateTime.now + 10
-        @r.send( "#{ attr }=", now.to_time )
-        expect( @r.send( attr ) ).to eq( now )
+      now = DateTime.now + 10
+      @r.send( "#{ attr }=", now.to_time )
+      expect( @r.send( attr ) ).to eq( now )
 
-        now = DateTime.now + 20
-        @r.send( "#{ attr }=", Hoodoo::Utilities::nanosecond_iso8601( now ) )
-        expect( @r.send( attr ) ).to eq( now )
-      end
+      now = DateTime.now + 20
+      @r.send( "#{ attr }=", Hoodoo::Utilities::nanosecond_iso8601( now ) )
+      expect( @r.send( attr ) ).to eq( now )
     end
+  end
 
+  context '#list' do
     it 'has correct default values' do
-      expect( @r.locale              ).to eq( 'en-nz'                    )
-      expect( @r.dated_at            ).to eq( nil                        )
-      expect( @r.body                ).to eq( nil                        )
-      expect( @r.uri_path_components ).to eq( []                         )
-      expect( @r.ident               ).to eq( nil                        )
-      expect( @r.uri_path_extension  ).to eq( ''                         )
-      expect( @r.list.offset         ).to eq( 0                          )
-      expect( @r.list.limit          ).to eq( 50                         )
-      expect( @r.list_sort_data      ).to eq( { 'created_at' => 'desc' } )
-      expect( @r.list.search_data    ).to eq( {}                         )
-      expect( @r.list.filter_data    ).to eq( {}                         )
-      expect( @r.embeds              ).to eq( []                         )
-      expect( @r.references          ).to eq( []                         )
-      expect( @r.headers             ).to eq( {}                         )
-
-      expect( @r.headers.frozen? ).to eq( true )
+      expect( @r.list.offset      ).to eq( 0                          )
+      expect( @r.list.limit       ).to eq( 50                         )
+      expect( @r.list.sort_data   ).to eq( { 'created_at' => 'desc' } )
+      expect( @r.list.search_data ).to eq( {}                         )
+      expect( @r.list.filter_data ).to eq( {}                         )
     end
 
-    it 'supports deprecated accessors' do
-      expect( @r.list_offset         ).to eq( 0                          )
-      expect( @r.list_limit          ).to eq( 50                         )
-      expect( @r.list_sort_data      ).to eq( { 'created_at' => 'desc' } )
-      expect( @r.list_search_data    ).to eq( {}                         )
-      expect( @r.list_filter_data    ).to eq( {}                         )
+    context 'and hashes via' do
+      before :each do
+        @offset = 1000
+        @limit  = 500
+        @sort   = { 'created_at' => 'asc' }
+        @search = { 'foo' => 'bar', 'bar' => { 'baz' => 3 } }
+        @filter = { 'bar' => 'foo', 'baz' => { 'bar' => 2 } }
+
+        @replacement_hash = {
+          'offset'      => @offset,
+          'limit'       => @limit,
+          'sort_data'   => @sort,
+          'search_data' => @search,
+          'filter_data' => @filter
+        }
+      end
+
+      context '#to_h' do
+        before :each do
+          @r.list.offset      = @offset
+          @r.list.limit       = @limit
+          @r.list.sort_data   = @sort
+          @r.list.search_data = @search
+          @r.list.filter_data = @filter
+        end
+
+        it 'returns the expected Hash' do
+          expect( @r.list.to_h ).to eq( @replacement_hash )
+        end
+
+        it 'deep-duplicates the parameters' do
+          result = @r.list.to_h()
+
+          old_sort_value = @sort[ @sort.keys.first ]
+          result[ 'sort_data' ][ @sort.keys.first ] == 'changed'
+          expect( @sort[ @sort.keys.first ] ).to eql( old_sort_value )
+
+          old_search_value = @search[ @search.keys.first ]
+          result[ 'search_data' ][ @search.keys.first ] == 'changed'
+          expect( @search[ @search.keys.first ] ).to eql( old_search_value )
+
+          old_filter_value = @filter[ @filter.keys.first ]
+          result[ 'filter_data' ][ @filter.keys.first ] == 'changed'
+          expect( @filter[ @filter.keys.first ] ).to eql( old_filter_value )
+        end
+      end
+
+      context '#from_h!' do
+        it 'overwrites all parameters' do
+          request = Hoodoo::Services::Request.new
+
+          expect( request.list.offset      ).to eq( 0                          )
+          expect( request.list.limit       ).to eq( 50                         )
+          expect( request.list.sort_data   ).to eq( { 'created_at' => 'desc' } )
+          expect( request.list.search_data ).to eq( {}                         )
+          expect( request.list.filter_data ).to eq( {}                         )
+
+          request.list.from_h!( @replacement_hash )
+
+          expect( request.list.offset      ).to eq( @offset )
+          expect( request.list.limit       ).to eq( @limit  )
+          expect( request.list.sort_data   ).to eq( @sort   )
+          expect( request.list.search_data ).to eq( @search )
+          expect( request.list.filter_data ).to eq( @filter )
+        end
+
+        it 'overwrites only provided parameters' do
+          replacements = {
+            'offset'      => @offset,
+            'limit'       => @limit,
+            'sort_data'   => @sort,
+            'search_data' => @search,
+            'filter_data' => @filter
+          }
+
+          # Iterate over all the possible keys above and build a Hash that
+          # contains just one at a time. Make a new request, set the list
+          # options from the one-at-a-time Hash and verify that only that
+          # one parameter changed.
+
+          replacements.each do | replacement_key, replacement_value |
+            request = Hoodoo::Services::Request.new
+            clean   = {
+              'offset'      => request.list.offset,
+              'limit'       => request.list.limit,
+              'sort_data'   => request.list.sort_data,
+              'search_data' => request.list.search_data,
+              'filter_data' => request.list.filter_data
+            }
+
+            hash = { replacement_key => replacement_value }
+            request.list.from_h!( hash )
+
+            clean.each do | clean_key, clean_value |
+              if clean_key == replacement_key
+                expect( request.list.send( clean_key ) ).to eql( replacement_value )
+              else
+                expect( request.list.send( clean_key ) ).to eql( clean_value )
+              end
+            end
+          end
+        end
+      end
+
+      context '#to_h and #from_h! together' do
+        before :each do
+          @r.list.offset      = @offset
+          @r.list.limit       = @limit
+          @r.list.sort_data   = @sort
+          @r.list.search_data = @search
+          @r.list.filter_data = @filter
+        end
 
+        it 'translates from one list to another' do
+          hash = @r.list.to_h
+
+          request = Hoodoo::Services::Request.new
+          request.list.from_h!( hash )
+
+          expect( request.list.to_h ).to eql( @replacement_hash )
+        end
+      end
+    end
+
+    it 'supports deprecated accessors' do
       lo = 10
       ll = 20
       ke = 'foo'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hoodoo
 version: !ruby/object:Gem::Version
-  version: 2.4.3
+  version: 2.5.0
 platform: ruby
 authors:
 - Loyalty New Zealand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-30 00:00:00.000000000 Z
+date: 2018-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dalli