deep_unrest 0.1.21 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d956b080370fba60df6de844edcb1346763aa98f
-  data.tar.gz: 0126de558b0326faf98280030b1e6b32f8c208c0
+  metadata.gz: bbbfefbc56611c2e591a4a0b4765ea55b8692208
+  data.tar.gz: eedb25cd0ab54ba479e8d54fba7170f1161708ae
 SHA512:
-  metadata.gz: 096bde94abae1571026d1664dfec6fd87feac55aab27fbd3c2eeac4267f69926f0738b717289f769ff11b1b1b59daf768920117b47606545deab60391f8ad268
-  data.tar.gz: d3574d96731e97b160dcf32c3dd1d6d75c5eace3abc8bbdad93e1ebc163e35803e998f5489d7743bbae7ba24bfaf924949ca9185290bfdc72c7dd1aa14fd66cf
+  metadata.gz: 458883abb589902b4958544173915d8783d4cfd9b99a1ad13a08bb75c54f1b6e1b6a8cf5985c3f9d07ca0d01ae1a8f92f672def3f9d80874fa0d03584e26f5ee
+  data.tar.gz: 503d64e14fc93803a813e45813a387f923b7af89a21e03dc65af0de3e488ef6d45eb4c2f451f0119541d934926d3ccf53d3f0755b2bc82eb971f170f8451bdf7

data/app/controllers/deep_unrest/application_controller.rb

@@ -28,12 +28,11 @@ module DeepUnrest
     end
 
     def update
-      @@temp_ids[request.uuid] = {}
       redirect = allowed_params[:redirect]
       data = repair_nested_params(allowed_params)[:data]
       results = DeepUnrest.perform_update(request.uuid, data, current_user)
       resp = { destroyed: results[:destroyed],
-               tempIds: @@temp_ids[request.uuid] }
+               tempIds: results[:temp_ids] }
       resp[:redirect] = results[:redirect_regex].call(redirect) if redirect
       render json: resp, status: 200
     rescue DeepUnrest::Unauthorized => err

data/lib/deep_unrest.rb

@@ -194,7 +194,11 @@ module DeepUnrest
     idx = {}
     params.map { |operation| collect_action_scopes(operation) }
           .flatten
-          .uniq
+          .each_with_object({}) do |op, memo|
+            # ensure no duplicate scopes
+            memo["#{op[:scope_type]}-#{op[:type]}-#{op[:id]}"] ||= {}
+            memo["#{op[:scope_type]}-#{op[:type]}-#{op[:id]}"].merge!(op)
+          end.values
           .map do |op|
             unless op[:scope_type] == :show
               op[:index] = update_indices(idx, op[:type])[op[:type]] - 1
@@ -204,6 +208,7 @@ module DeepUnrest
   end
 
   def self.parse_id(id_str)
+    return false if id_str.nil?
     id_match = id_str.match(/^\.?(?<id>\d+)$/)
     id_match && id_match[:id]
   end
@@ -256,13 +261,9 @@ module DeepUnrest
     cursor
   end
 
-  def self.get_mutation_cursor(ctx, memo, cursor, addr, type, id, temp_id, scope_type)
+  def self.get_mutation_cursor(memo, cursor, addr, type, id, temp_id, scope_type)
     if memo
       record = { id: id || temp_id }
-      if temp_id
-        record[:deep_unrest_temp_id] = temp_id
-        record[:deep_unrest_context] = ctx
-      end
       if plural?(type)
         cursor[addr] = [record]
         next_cursor = cursor[addr][0]
@@ -277,8 +278,6 @@ module DeepUnrest
       klass = to_class(type)
       body = {}
       body[klass.primary_key.to_sym] = id if id
-      body[:deep_unrest_temp_id] = temp_id if temp_id
-      body[:deep_unrest_context] = ctx if temp_id
       cursor[type_sym] = {
         klass: klass
       }
@@ -295,47 +294,28 @@ module DeepUnrest
     [memo, next_cursor]
   end
 
-  def self.merge_siblings!(mutations)
-    mutations.each do |k, v|
-      case v
-      when Array
-        h = v.each_with_object({}) do |item, memo|
-          if item.respond_to?(:key?) && item.key?(:id)
-            # this is a nested resource. merge as such
-            memo[item[:id]] ||= {}
-            memo[item[:id]].deeper_merge(item)
-            merge_siblings!(item)
-          else
-            # otherwise this is just a normal array
-            idx = memo.keys.size
-            memo[idx] = item
-          end
-        end
-        mutations[k] = h.values
-      when Hash
-        merge_siblings!(v)
-      end
-    end
-    mutations
-  end
-
-  def self.remove_temp_ids!(mutations)
+  def self.convert_temp_ids!(ctx, mutations)
     case mutations
     when Hash
-      mutations.map do |key, val|
+      mutations.keys.map do |key|
+        val = mutations[key]
         if ['id', :id].include?(key)
-          mutations.delete(key) unless parse_id(val)
+          unless parse_id(val)
+            mutations.delete(key)
+            mutations[:deep_unrest_temp_id] = val
+            mutations[:deep_unrest_context] = ctx
+          end
         else
-          remove_temp_ids!(val)
+          convert_temp_ids!(ctx, val)
         end
       end
     when Array
-      mutations.map { |val| remove_temp_ids!(val) }
+      mutations.map { |val| convert_temp_ids!(ctx, val) }
     end
     mutations
   end
 
-  def self.build_mutation_fragment(ctx, op, scopes, user, err_path_memo, rest = nil, memo = nil, cursor = nil, type = nil)
+  def self.build_mutation_fragment(op, scopes, user, err_path_memo, rest = nil, memo = nil, cursor = nil, type = nil)
     rest ||= parse_path(op[:path])
 
     if rest.empty?
@@ -349,8 +329,7 @@ module DeepUnrest
     scope_type = get_scope_type(id_str, rest.blank?, op[:destroy])
     temp_id = scope_type == :create ? id_str : nil
 
-    memo, next_cursor = get_mutation_cursor(ctx,
-                                            memo,
+    memo, next_cursor = get_mutation_cursor(memo,
                                             cursor,
                                             addr,
                                             type,
@@ -359,13 +338,42 @@ module DeepUnrest
                                             scope_type)
 
     next_cursor[:id] = id if id
-    build_mutation_fragment(ctx, op, scopes, user, err_path_memo, rest, memo, next_cursor, type)
+    build_mutation_fragment(op, scopes, user, err_path_memo, rest, memo, next_cursor, type)
+  end
+
+  def self.combine_arrays(a, b)
+    # get list of dupe items
+    groups = (a + b).flatten.group_by { |item| item[:id] }
+
+    dupes = groups.select { |_, v| v.size > 1 }.values
+
+    # combine non-dupe items
+    non_dupes = groups.select { |_, v| v.size == 1 }.values
+
+    # deep_merge dupes
+    merged = dupes.map do |(a2, b2)|
+      a2.deep_merge(b2) do |_, a3, b3|
+        if a3.is_a? Array
+          combine_arrays(a3, b3)
+        else
+          b3
+        end
+      end
+    end
+
+    (non_dupes + merged).flatten
   end
 
-  def self.build_mutation_body(ctx, ops, scopes, user)
+  def self.build_mutation_body(ops, scopes, user)
     err_path_memo = {}
     ops.each_with_object(HashWithIndifferentAccess.new({})) do |op, memo|
-      memo.deeper_merge(build_mutation_fragment(ctx, op, scopes, user, err_path_memo))
+      memo.deep_merge!(build_mutation_fragment(op, scopes, user, err_path_memo)) do |key, a, b|
+        if a.is_a? Array
+          combine_arrays(a, b)
+        else
+          b
+        end
+      end
     end
   end
 
@@ -392,6 +400,7 @@ module DeepUnrest
                      when :destroy
                        item[:klass].destroy(id)
                      end
+
             result = { record: record }
             if action[:temp_id]
               result[:temp_ids] = {}
@@ -480,6 +489,12 @@ module DeepUnrest
   end
 
   def self.perform_update(ctx, params, user)
+    temp_id_map = DeepUnrest::ApplicationController.class_variable_get(
+      '@@temp_ids'
+    )
+
+    temp_id_map[ctx] = {}
+
     # reject new resources marked for destruction
     viable_params = params.reject do |param|
       temp_id?(param[:path]) && param[:destroy].present?
@@ -492,10 +507,10 @@ module DeepUnrest
     DeepUnrest.authorization_strategy.authorize(scopes, user).flatten
 
     # bulid update arguments
-    mutations = build_mutation_body(ctx, viable_params, scopes, user)
+    mutations = build_mutation_body(viable_params, scopes, user)
 
-    merge_siblings!(mutations)
-    remove_temp_ids!(mutations)
+    # convert temp_ids from ids to non-activerecord attributes
+    convert_temp_ids!(ctx, mutations)
 
     # perform update
     results = mutate(mutations, user).flatten
@@ -507,12 +522,9 @@ module DeepUnrest
                     .compact
 
     if errors.empty?
-      temp_ids = results.map { |res| res[:temp_ids] }
-                        .compact
-                        .each_with_object({}) { |item, mem| mem.merge!(item) }
-
       return {
-        redirect_regex: build_redirect_regex(temp_ids),
+        redirect_regex: build_redirect_regex(temp_id_map[ctx]),
+        temp_ids: temp_id_map[ctx],
         destroyed: scopes.select { |item| item[:destroyed] }
                          .map do |item|
                            { type: item[:type],

data/lib/deep_unrest/engine.rb

@@ -3,7 +3,6 @@ require 'deep_unrest/authorization/none_strategy'
 require 'deep_unrest/authorization/pundit_strategy'
 require 'deep_unrest/concerns/null_concern'
 require 'deep_unrest/concerns/map_temp_ids'
-require 'deep_merge/rails_compat'
 
 module DeepUnrest
   class Engine < ::Rails::Engine

data/lib/deep_unrest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeepUnrest
-  VERSION = '0.1.21'
+  VERSION = '0.1.22'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deep_unrest
 version: !ruby/object:Gem::Version
-  version: 0.1.21
+  version: 0.1.22
 platform: ruby
 authors:
 - Lynn Hurley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-18 00:00:00.000000000 Z
+date: 2017-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -52,20 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.0
-- !ruby/object:Gem::Dependency
-  name: deep_merge
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.1.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.1.1
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement