iknow_view_models 3.2.0 → 3.2.5

data/test/unit/view_model/active_record/customization_test.rb

@@ -1,11 +1,11 @@
-# coding: utf-8
-require_relative "../../../helpers/arvm_test_utilities.rb"
-require_relative "../../../helpers/arvm_test_models.rb"
+# frozen_string_literal: true
 
-require "minitest/autorun"
+require_relative '../../../helpers/arvm_test_utilities'
+require_relative '../../../helpers/arvm_test_models'
 
-require "view_model/active_record"
+require 'minitest/autorun'
 
+require 'view_model/active_record'
 
 require 'renum'
 
@@ -28,15 +28,16 @@ class ViewModel::ActiveRecord::SpecializeAssociationTest < ActiveSupport::TestCa
         attributes :text
         association :translations
 
-        def self.pre_parse_translations(viewmodel_reference, metadata, hash, translations)
-          raise "type check" unless translations.is_a?(Hash) && translations.all? { |k, v| k.is_a?(String) && v.is_a?(String) }
-          hash["translations"] = translations.map { |lang, text| { "_type" => "Translation", "language" => lang, "translation" => text } }
+        def self.pre_parse_translations(_viewmodel_reference, _metadata, hash, translations)
+          raise 'type check' unless translations.is_a?(Hash) && translations.all? { |k, v| k.is_a?(String) && v.is_a?(String) }
+
+          hash['translations'] = translations.map { |lang, text| { '_type' => 'Translation', 'language' => lang, 'translation' => text } }
         end
 
         def resolve_translations(update_datas, previous_translation_views)
           existing = previous_translation_views.index_by { |x| [x.model.language, x.model.translation] }
           update_datas.map do |update_data|
-            existing.fetch([update_data["language"], update_data["translation"]]) { TranslationView.for_new_model }
+            existing.fetch([update_data['language'], update_data['translation']]) { TranslationView.for_new_model }
           end
         end
 
@@ -71,19 +72,19 @@ class ViewModel::ActiveRecord::SpecializeAssociationTest < ActiveSupport::TestCa
   def setup
     super
 
-    @text1 = Text.create(text: "dog",
-                    translations: [Translation.new(language: "ja", translation: "犬"),
-                                   Translation.new(language: "fr", translation: "chien")])
+    @text1 = Text.create(text: 'dog',
+                    translations: [Translation.new(language: 'ja', translation: '犬'),
+                                   Translation.new(language: 'fr', translation: 'chien'),])
 
     @text1_view = {
-      "id"           => @text1.id,
-      "_type"        => "Text",
-      "_version"     => 1,
-      "text"         => "dog",
-      "translations" => {
-        "ja" => "犬",
-        "fr" => "chien"
-      }
+      'id'           => @text1.id,
+      '_type'        => 'Text',
+      '_version'     => 1,
+      'text'         => 'dog',
+      'translations' => {
+        'ja' => '犬',
+        'fr' => 'chien',
+      },
     }
 
     enable_logging!
@@ -94,7 +95,7 @@ class ViewModel::ActiveRecord::SpecializeAssociationTest < ActiveSupport::TestCa
   end
 
   def test_create
-    create_view = @text1_view.dup.tap {|v| v.delete('id')}
+    create_view = @text1_view.dup.tap { |v| v.delete('id') }
     new_text_view = TextView.deserialize_from_view(create_view)
     new_text_model = new_text_view.model
 
@@ -103,8 +104,8 @@ class ViewModel::ActiveRecord::SpecializeAssociationTest < ActiveSupport::TestCa
     new_translations = new_text_model.translations.map do |x|
       [x['language'], x['translation']]
     end
-    assert_equal([%w(fr chien),
-                  %w(ja 犬)],
+    assert_equal([%w[fr chien],
+                  %w[ja 犬],],
                  new_translations.sort)
   end
 
@@ -163,10 +164,11 @@ class ViewModel::ActiveRecord::FlattenAssociationTest < ActiveSupport::TestCase
       def construct_hash(members)
         case self
         when SectionType::Simple
-          raise "nopes" if members.present?
+          raise 'nopes' if members.present?
+
           nil
         else
-          members.merge("_type" => viewmodel.view_name)
+          members.merge('_type' => viewmodel.view_name)
         end
       end
 
@@ -219,7 +221,7 @@ class ViewModel::ActiveRecord::FlattenAssociationTest < ActiveSupport::TestCase
           section_type = SectionType.with_name(section_type_name)
           raise "Invalid section type: #{section_type_name.inspect}" unless section_type
 
-          user_data["section_data"] = section_type.construct_hash(user_data.slice!(*self._members.keys))
+          user_data['section_data'] = section_type.construct_hash(user_data.slice!(*self._members.keys))
         end
 
         def resolve_section_data(update_data, previous_translation_view)
@@ -242,39 +244,38 @@ class ViewModel::ActiveRecord::FlattenAssociationTest < ActiveSupport::TestCase
         end
       end
     end
-
   end
 
   def setup
     super
 
-    @simplesection = Section.create(name: "simple1")
+    @simplesection = Section.create(name: 'simple1')
     @simplesection_view = {
-      "id"           => @simplesection.id,
-      "_type"        => "Section",
-      "_version"     => 1,
-      "section_type" => "Simple",
-      "name"         => "simple1"
+      'id'           => @simplesection.id,
+      '_type'        => 'Section',
+      '_version'     => 1,
+      'section_type' => 'Simple',
+      'name'         => 'simple1',
     }
 
-    @quizsection = Section.create(name: "quiz1", section_data: QuizSection.new(quiz_name: "qq"))
+    @quizsection = Section.create(name: 'quiz1', section_data: QuizSection.new(quiz_name: 'qq'))
     @quizsection_view = {
-      "id"           => @quizsection.id,
-      "_type"        => "Section",
-      "_version"     => 1,
-      "section_type" => "Quiz",
-      "name"         => "quiz1",
-      "quiz_name"    => "qq"
+      'id'           => @quizsection.id,
+      '_type'        => 'Section',
+      '_version'     => 1,
+      'section_type' => 'Quiz',
+      'name'         => 'quiz1',
+      'quiz_name'    => 'qq',
     }
 
-    @vocabsection = Section.create(name: "vocab1", section_data: VocabSection.new(vocab_word: "dog"))
+    @vocabsection = Section.create(name: 'vocab1', section_data: VocabSection.new(vocab_word: 'dog'))
     @vocabsection_view = {
-      "id"           => @vocabsection.id,
-      "_type"        => "Section",
-      "_version"     => 1,
-      "section_type" => "Vocab",
-      "name"         => "vocab1",
-      "vocab_word"   => "dog"
+      'id'           => @vocabsection.id,
+      '_type'        => 'Section',
+      '_version'     => 1,
+      'section_type' => 'Vocab',
+      'name'         => 'vocab1',
+      'vocab_word'   => 'dog',
     }
 
     enable_logging!
@@ -296,7 +297,7 @@ class ViewModel::ActiveRecord::FlattenAssociationTest < ActiveSupport::TestCase
   end
 
   def test_create
-    assert_section = ->(model, name, &check_section){
+    assert_section = ->(model, name, &check_section) {
       assert(!model.changed?)
       assert(!model.new_record?)
       assert_equal(name, model.name)
@@ -313,18 +314,18 @@ class ViewModel::ActiveRecord::FlattenAssociationTest < ActiveSupport::TestCase
     }
 
     v = SectionView.deserialize_from_view(new_view_like(@simplesection_view))
-    assert_section.call(v.model, "simple1")
+    assert_section.call(v.model, 'simple1')
 
     v = SectionView.deserialize_from_view(new_view_like(@quizsection_view))
-    assert_section.call(v.model, "quiz1") do |m|
+    assert_section.call(v.model, 'quiz1') do |m|
       assert(m.is_a?(QuizSection))
-      assert_equal("qq", m.quiz_name)
+      assert_equal('qq', m.quiz_name)
     end
 
     v = SectionView.deserialize_from_view(new_view_like(@vocabsection_view))
-    assert_section.call(v.model, "vocab1") do |m|
+    assert_section.call(v.model, 'vocab1') do |m|
       assert(m.is_a?(VocabSection))
-      assert_equal("dog", m.vocab_word)
+      assert_equal('dog', m.vocab_word)
     end
   end
 
@@ -363,15 +364,15 @@ class ViewModel::ActiveRecord::FlattenAssociationTest < ActiveSupport::TestCase
     def setup
       super
       sections = [
-        Section.new(name: "simple1"),
-        Section.new(name: "quiz1", section_data: QuizSection.new(quiz_name: "qq")),
-        Section.new(name: "vocab1", section_data: VocabSection.new(vocab_word: "dog")),
+        Section.new(name: 'simple1'),
+        Section.new(name: 'quiz1', section_data: QuizSection.new(quiz_name: 'qq')),
+        Section.new(name: 'vocab1', section_data: VocabSection.new(vocab_word: 'dog')),
       ]
       @exercise1 = Exercise.create(sections: sections)
     end
 
     def test_functional_update
-      alter_by_view!(ExerciseView, @exercise1) do |view, refs|
+      alter_by_view!(ExerciseView, @exercise1) do |view, _refs|
         view['sections'] = {
           '_type'   => '_update',
           'actions' => [{ '_type'  => 'append',
@@ -380,7 +381,7 @@ class ViewModel::ActiveRecord::FlattenAssociationTest < ActiveSupport::TestCase
                                          'name'         => 'vocab_new',
                                          'vocab_word'   => 'cat',
                                        }],
-                        }]
+                        }],
         }
       end
     end

data/test/unit/view_model/active_record/has_many_test.rb

@@ -1,10 +1,12 @@
-require_relative "../../../helpers/arvm_test_utilities.rb"
-require_relative "../../../helpers/arvm_test_models.rb"
-require_relative '../../../helpers/viewmodel_spec_helpers.rb'
+# frozen_string_literal: true
 
-require "minitest/autorun"
+require_relative '../../../helpers/arvm_test_utilities'
+require_relative '../../../helpers/arvm_test_models'
+require_relative '../../../helpers/viewmodel_spec_helpers'
 
-require "view_model/active_record"
+require 'minitest/autorun'
+
+require 'view_model/active_record'
 
 class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   include ARVMTestUtilities
@@ -15,15 +17,15 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   def setup
     super
 
-    @model1 = model_class.new(name: "p1",
-                          children: [child_model_class.new(name: "p1c1", position: 1),
-                                     child_model_class.new(name: "p1c2", position: 2),
-                                     child_model_class.new(name: "p1c3", position: 3)])
+    @model1 = model_class.new(name: 'p1',
+                          children: [child_model_class.new(name: 'p1c1', position: 1),
+                                     child_model_class.new(name: 'p1c2', position: 2),
+                                     child_model_class.new(name: 'p1c3', position: 3),])
     @model1.save!
 
-    @model2 = model_class.new(name: "p2",
-                          children: [child_model_class.new(name: "p2c1").tap { |c| c.position = 1 },
-                                     child_model_class.new(name: "p2c2").tap { |c| c.position = 2 }])
+    @model2 = model_class.new(name: 'p2',
+                          children: [child_model_class.new(name: 'p2c1').tap { |c| c.position = 1 },
+                                     child_model_class.new(name: 'p2c2').tap { |c| c.position = 2 },])
 
     @model2.save!
 
@@ -35,22 +37,21 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     childviews = parentview.load_associated(:children)
     assert_equal(3, childviews.size)
-    assert_equal(["p1c1", "p1c2", "p1c3"],
+    assert_equal(['p1c1', 'p1c2', 'p1c3'],
                  childviews.map(&:name))
   end
 
   def test_serialize_view
     view, _refs = serialize_with_references(viewmodel_class.new(@model1))
 
-
-    assert_equal({ "_type"    => "Model",
-                   "_version" => 1,
-                   "id"       => @model1.id,
-                   "name"     => @model1.name,
-                   "children" => @model1.children.map { |child| { "_type"    => "Child",
-                                                                   "_version" => 1,
-                                                                   "id"       => child.id,
-                                                                   "name"     => child.name } } },
+    assert_equal({ '_type'    => 'Model',
+                   '_version' => 1,
+                   'id'       => @model1.id,
+                   'name'     => @model1.name,
+                   'children' => @model1.children.map { |child| { '_type' => 'Child',
+                                                                   '_version' => 1,
+                                                                   'id'       => child.id,
+                                                                   'name'     => child.name } } },
                  view)
   end
 
@@ -64,10 +65,10 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   def test_create_from_view
     view = {
-      "_type"    => "Model",
-      "name"     => "p",
-      "children" => [{ "_type" => "Child", "name" => "c1" },
-                     { "_type" => "Child", "name" => "c2" }]
+      '_type'    => 'Model',
+      'name'     => 'p',
+      'children' => [{ '_type' => 'Child', 'name' => 'c1' },
+                     { '_type' => 'Child', 'name' => 'c2' },],
     }
 
     pv = viewmodel_class.deserialize_from_view(view)
@@ -76,7 +77,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     assert(!p.changed?)
     assert(!p.new_record?)
 
-    assert_equal("p", p.name)
+    assert_equal('p', p.name)
 
     assert_equal(2, p.children.count)
     p.children.order(:id).each_with_index do |c, i|
@@ -91,7 +92,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     assert_raises(ViewModel::AccessControlError) do
       # append child
-      viewmodel_class.new(@model1).append_associated(:children, { "_type" => "Child", "name" => "hi" }, deserialize_context: no_edit_context)
+      viewmodel_class.new(@model1).append_associated(:children, { '_type' => 'Child', 'name' => 'hi' }, deserialize_context: no_edit_context)
     end
 
     assert_raises(ViewModel::AccessControlError) do
@@ -110,7 +111,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     view = { '_type'    => 'Model',
              'name'     => 'p',
              'children' => [{ '_type' => 'Child', 'name' => 'c1' },
-                            { '_type' => 'Child', 'name' => 'c2' }] }
+                            { '_type' => 'Child', 'name' => 'c2' },] }
 
     context = viewmodel_class.new_deserialize_context
     pv = viewmodel_class.deserialize_from_view(view, deserialize_context: context)
@@ -124,8 +125,8 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   def test_nil_multiple_association
     view = {
-      "_type" => "Model",
-      "children" => nil
+      '_type' => 'Model',
+      'children' => nil,
     }
     ex = assert_raises(ViewModel::DeserializationError::InvalidSyntax) do
       viewmodel_class.deserialize_from_view(view)
@@ -136,8 +137,8 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   def test_non_array_multiple_association
     view = {
-      "_type" => "Model",
-      "children" => { '_type' => 'Child', 'name' => 'c1' }
+      '_type' => 'Model',
+      'children' => { '_type' => 'Child', 'name' => 'c1' },
     }
     ex = assert_raises(ViewModel::DeserializationError::InvalidSyntax) do
       viewmodel_class.deserialize_from_view(view)
@@ -149,7 +150,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   def test_replace_has_many
     old_children = @model1.children
 
-    alter_by_view!(viewmodel_class, @model1) do |view, refs|
+    alter_by_view!(viewmodel_class, @model1) do |view, _refs|
       view['children'] = [{ '_type' => 'Child', 'name' => 'new_child' }]
     end
 
@@ -169,7 +170,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     expected_edit_checks = [pv.to_reference,
                             *old_children.map { |x| ViewModel::Reference.new(child_viewmodel_class, x.id) },
-                            *nc.map(&:to_reference)]
+                            *nc.map(&:to_reference),]
 
     assert_contains_exactly(expected_edit_checks,
                             context.valid_edit_refs)
@@ -200,7 +201,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     expected_edit_checks = [pv.to_reference,
                             ViewModel::Reference.new(child_viewmodel_class, new_child.id),
                             ViewModel::Reference.new(child_viewmodel_class, old_children.first.id),
-                            ViewModel::Reference.new(child_viewmodel_class, old_children.last.id)]
+                            ViewModel::Reference.new(child_viewmodel_class, old_children.last.id),]
 
     assert_contains_exactly(expected_edit_checks,
                             context.valid_edit_refs)
@@ -215,7 +216,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   def test_remove_has_many
     old_children = @model1.children
-    _, context = alter_by_view!(viewmodel_class, @model1) do |view, refs|
+    _, context = alter_by_view!(viewmodel_class, @model1) do |view, _refs|
       view['children'] = []
     end
 
@@ -239,7 +240,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
                          deserialize_context: context)
 
     expected_edit_checks = [ViewModel::Reference.new(viewmodel_class, @model1.id),
-                            ViewModel::Reference.new(child_viewmodel_class,  c1.id)].to_set
+                            ViewModel::Reference.new(child_viewmodel_class, c1.id),].to_set
 
     assert_equal(expected_edit_checks,
                  context.valid_edit_refs.to_set)
@@ -260,8 +261,8 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     assert_contains_exactly(
       [ViewModel::Reference.new(viewmodel_class, @model1.id),
-       ViewModel::Reference.new(child_viewmodel_class,  c1.id),  # deleted child
-       ViewModel::Reference.new(child_viewmodel_class,  nc.id)], # created child
+       ViewModel::Reference.new(child_viewmodel_class,  c1.id), # deleted child
+       ViewModel::Reference.new(child_viewmodel_class,  nc.id),], # created child
       context.valid_edit_refs)
 
     assert_equal([c2, c3, child_model_class.find_by_name('new_c')],
@@ -314,7 +315,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
                          deserialize_context: (context = viewmodel_class.new_deserialize_context))
 
     expected_edit_checks = [ViewModel::Reference.new(viewmodel_class, @model1.id),
-                            ViewModel::Reference.new(viewmodel_class, @model2.id)]
+                            ViewModel::Reference.new(viewmodel_class, @model2.id),]
 
     assert_contains_exactly(expected_edit_checks, context.valid_edit_refs)
 
@@ -335,7 +336,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     n1 = child_model_class.find_by_name('new1')
 
     expected_edit_checks = [ViewModel::Reference.new(viewmodel_class, @model1.id),
-                            ViewModel::Reference.new(child_viewmodel_class, n1.id)]
+                            ViewModel::Reference.new(child_viewmodel_class, n1.id),]
 
     assert_contains_exactly(expected_edit_checks, context.valid_edit_refs)
 
@@ -351,7 +352,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     n2 = child_model_class.find_by_name('new2')
 
     expected_edit_checks = [ViewModel::Reference.new(viewmodel_class, @model1.id),
-                            ViewModel::Reference.new(child_viewmodel_class, n2.id)]
+                            ViewModel::Reference.new(child_viewmodel_class, n2.id),]
 
     assert_contains_exactly(expected_edit_checks, context.valid_edit_refs)
 
@@ -366,7 +367,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     n3 = child_model_class.find_by_name('new3')
 
     expected_edit_checks = [ViewModel::Reference.new(viewmodel_class, @model1.id),
-                            ViewModel::Reference.new(child_viewmodel_class, n3.id)]
+                            ViewModel::Reference.new(child_viewmodel_class, n3.id),]
 
     assert_contains_exactly(expected_edit_checks, context.valid_edit_refs)
 
@@ -377,7 +378,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   def test_edit_implicit_list_position
     c1, c2, c3 = @model1.children.order(:position).to_a
 
-    alter_by_view!(viewmodel_class, @model1) do |view, refs|
+    alter_by_view!(viewmodel_class, @model1) do |view, _refs|
       view['children'].reverse!
       view['children'].insert(1, { '_type' => 'Child', 'name' => 'new_c' })
     end
@@ -388,11 +389,11 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   def test_edit_missing_child
     view = {
-      "_type" => "Model",
-      "children" => [{
-                       "_type" => "Child",
-                       "id"    => 9999
-                     }]
+      '_type' => 'Model',
+      'children' => [{
+                       '_type' => 'Child',
+                       'id'    => 9999,
+                     }],
     }
 
     ex = assert_raises(ViewModel::DeserializationError::NotFound) do
@@ -411,7 +412,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     view = { '_type'    => 'Model',
              'name'     => 'new_p',
              'children' => [moved_child_ref,
-                            { '_type' => 'Child', 'name' => 'new' }] }
+                            { '_type' => 'Child', 'name' => 'new' },] }
 
     retained_children = old_children - [moved_child]
     release_view = { '_type'    => 'Model',
@@ -430,7 +431,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     # child should be added to new parent
     new_children = new_parent.children.order(:position)
-    assert_equal(%w(p1c2 new), new_children.map(&:name))
+    assert_equal(%w[p1c2 new], new_children.map(&:name))
     assert_equal(moved_child, new_children.first)
   end
 
@@ -470,7 +471,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     retained_children = old_children - [moved_child]
     release_view = { '_type' => 'Model', 'id' => @model1.id,
-                     'children' => retained_children.map { |c| update_hash_for(child_viewmodel_class, c) }}
+                     'children' => retained_children.map { |c| update_hash_for(child_viewmodel_class, c) } }
 
     viewmodel_class.deserialize_from_view([view, release_view])
 
@@ -482,25 +483,25 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     # child should be added to new parent with valid position
     new_children = @model2.children.order(:position)
-    assert_equal(%w(p2c1 p2c2 p1c2), new_children.map(&:name))
+    assert_equal(%w[p2c1 p2c2 p1c2], new_children.map(&:name))
     assert_equal(moved_child, new_children.last)
   end
 
   def test_has_many_append_child
-    viewmodel_class.new(@model1).append_associated(:children, { "_type" => "Child", "name" => "new" })
+    viewmodel_class.new(@model1).append_associated(:children, { '_type' => 'Child', 'name' => 'new' })
 
     @model1.reload
 
     assert_equal(4, @model1.children.size)
     lc = @model1.children.order(:position).last
-    assert_equal("new", lc.name)
+    assert_equal('new', lc.name)
   end
 
   def test_has_many_append_and_update_existing_association
     child = @model1.children[1]
 
     cv = child_viewmodel_class.new(child).to_hash
-    cv["name"] = "newname"
+    cv['name'] = 'newname'
 
     viewmodel_class.new(@model1).append_associated(:children, cv)
 
@@ -509,28 +510,28 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     # Child should have been moved to the end (and edited)
     assert_equal(3, @model1.children.size)
     c1, c2, c3 = @model1.children.order(:position)
-    assert_equal("p1c1", c1.name)
-    assert_equal("p1c3", c2.name)
+    assert_equal('p1c1', c1.name)
+    assert_equal('p1c3', c2.name)
     assert_equal(child, c3)
-    assert_equal("newname", c3.name)
+    assert_equal('newname', c3.name)
   end
 
   def test_has_many_move_existing_association
     p1c2 = @model1.children[1]
     assert_equal(2, p1c2.position)
 
-    viewmodel_class.new(@model2).append_associated("children", { "_type" => "Child", "id" => p1c2.id })
+    viewmodel_class.new(@model2).append_associated('children', { '_type' => 'Child', 'id' => p1c2.id })
 
     @model1.reload
     @model2.reload
 
     p1c = @model1.children.order(:position)
     assert_equal(2, p1c.size)
-    assert_equal(["p1c1", "p1c3"], p1c.map(&:name))
+    assert_equal(['p1c1', 'p1c3'], p1c.map(&:name))
 
     p2c = @model2.children.order(:position)
     assert_equal(3, p2c.size)
-    assert_equal(["p2c1", "p2c2", "p1c2"], p2c.map(&:name))
+    assert_equal(['p2c1', 'p2c2', 'p1c2'], p2c.map(&:name))
     assert_equal(p1c2, p2c[2])
     assert_equal(3, p2c[2].position)
   end
@@ -545,8 +546,8 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     # Child should have been removed
     assert_equal(2, @model1.children.size)
     c1, c2 = @model1.children.order(:position)
-    assert_equal("p1c1", c1.name)
-    assert_equal("p1c3", c2.name)
+    assert_equal('p1c1', c1.name)
+    assert_equal('p1c3', c2.name)
 
     assert_equal(0, child_model_class.where(id: child.id).size)
   end
@@ -555,47 +556,47 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     child = @model1.children[1]
 
     child_view = child_viewmodel_class.new(child).to_hash
-    child_view["name"] = "changed"
+    child_view['name'] = 'changed'
 
-    view = { "_type" => "Model",
-             "name" => "new_p",
-             "children" => [child_view, { "_type" => "Child", "name" => "new" }]}
+    view = { '_type' => 'Model',
+             'name' => 'new_p',
+             'children' => [child_view, { '_type' => 'Child', 'name' => 'new' }] }
 
-    # TODO this is as awkward here as it is in the application
-    release_view = { "_type" => "Model",
-                     "id" => @model1.id,
-                     "children" => [{ "_type" => "Child", "id" => @model1.children[0].id },
-                                    { "_type" => "Child", "id" => @model1.children[2].id }]}
+    # TODO: this is as awkward here as it is in the application
+    release_view = { '_type' => 'Model',
+                     'id' => @model1.id,
+                     'children' => [{ '_type' => 'Child', 'id' => @model1.children[0].id },
+                                    { '_type' => 'Child', 'id' => @model1.children[2].id },] }
 
     pv = viewmodel_class.deserialize_from_view([view, release_view])
     new_parent = pv.first.model
 
     # child should be removed from old parent and positions updated
     @model1.reload
-    assert_equal(2, @model1.children.size, "database has 2 children")
+    assert_equal(2, @model1.children.size, 'database has 2 children')
     oc1, oc2 = @model1.children.order(:position)
-    assert_equal("p1c1", oc1.name, "database c1 unchanged")
-    assert_equal("p1c3", oc2.name, "database c2 unchanged")
+    assert_equal('p1c1', oc1.name, 'database c1 unchanged')
+    assert_equal('p1c3', oc2.name, 'database c2 unchanged')
 
     # child should be added to new parent with valid position
-    assert_equal(2, new_parent.children.size, "viewmodel has 2 children")
+    assert_equal(2, new_parent.children.size, 'viewmodel has 2 children')
     nc1, nc2 = new_parent.children.order(:position)
     assert_equal(child, nc1)
-    assert_equal("changed", nc1.name)
-    assert_equal("new", nc2.name)
+    assert_equal('changed', nc1.name)
+    assert_equal('new', nc2.name)
   end
 
   def test_move_and_edit_child_to_existing
     old_child = @model1.children[1]
 
     old_child_view = child_viewmodel_class.new(old_child).to_hash
-    old_child_view["name"] = "changed"
+    old_child_view['name'] = 'changed'
     view = viewmodel_class.new(@model2).to_hash
-    view["children"] << old_child_view
+    view['children'] << old_child_view
 
-    release_view = {"_type" => "Model", "id" => @model1.id,
-                    "children" => [{"_type" => "Child", "id" => @model1.children[0].id},
-                                   {"_type" => "Child", "id" => @model1.children[2].id}]}
+    release_view = { '_type' => 'Model', 'id' => @model1.id,
+                    'children' => [{ '_type' => 'Child', 'id' => @model1.children[0].id },
+                                   { '_type' => 'Child', 'id' => @model1.children[2].id },] }
 
     viewmodel_class.deserialize_from_view([view, release_view])
 
@@ -606,46 +607,46 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     assert_equal(2, @model1.children.size)
     oc1, oc2 = @model1.children.order(:position)
 
-    assert_equal("p1c1", oc1.name)
-    assert_equal("p1c3", oc2.name)
+    assert_equal('p1c1', oc1.name)
+    assert_equal('p1c3', oc2.name)
 
     # child should be added to new parent with valid position
     assert_equal(3, @model2.children.size)
     nc1, _, nc3 = @model2.children.order(:position)
-    assert_equal("p2c1", nc1.name)
+    assert_equal('p2c1', nc1.name)
 
-    assert_equal("p2c1", nc1.name)
+    assert_equal('p2c1', nc1.name)
 
     assert_equal(old_child, nc3)
-    assert_equal("changed", nc3.name)
+    assert_equal('changed', nc3.name)
   end
 
   def test_functional_update_append
     children_before = @model1.children.order(:position).pluck(:id)
     fupdate = build_fupdate do
       append([{ '_type' => 'Child' },
-              { '_type' => 'Child' }])
+              { '_type' => 'Child' },])
     end
 
-    append_view     = { '_type'    => 'Model',
+    append_view = { '_type' => 'Model',
                         'id'       => @model1.id,
                         'children' => fupdate }
 
-    result          = viewmodel_class.deserialize_from_view(append_view)
+    result = viewmodel_class.deserialize_from_view(append_view)
     @model1.reload
 
-    created_children = result.children[-2,2].map(&:id)
+    created_children = result.children[-2, 2].map(&:id)
 
     assert_equal(children_before + created_children,
                  @model1.children.order(:position).pluck(:id))
   end
 
   def test_functional_update_append_before_mid
-    c1, c2, c3  = @model1.children.order(:position)
+    c1, c2, c3 = @model1.children.order(:position)
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
+              { '_type' => 'Child', 'name' => 'new c2' },],
              before: { '_type' => 'Child', 'id' => c2.id })
     end
 
@@ -660,7 +661,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   end
 
   def test_functional_update_append_before_reorder
-    c1, c2, c3  = @model1.children.order(:position)
+    c1, c2, c3 = @model1.children.order(:position)
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'id' => c3.id }],
@@ -678,11 +679,11 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   end
 
   def test_functional_update_append_before_beginning
-    c1, c2, c3  = @model1.children.order(:position)
+    c1, c2, c3 = @model1.children.order(:position)
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
+              { '_type' => 'Child', 'name' => 'new c2' },],
              before: { '_type' => 'Child', 'id' => c1.id })
     end
 
@@ -702,7 +703,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
+              { '_type' => 'Child', 'name' => 'new c2' },],
              before: { '_type' => 'Child', 'id' => c2.id })
     end
 
@@ -715,11 +716,11 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   end
 
   def test_functional_update_append_after_mid
-    c1, c2, c3  = @model1.children.order(:position)
+    c1, c2, c3 = @model1.children.order(:position)
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
+              { '_type' => 'Child', 'name' => 'new c2' },],
              after: { '_type' => 'Child', 'id' => c2.id })
     end
 
@@ -734,12 +735,12 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   end
 
   def test_functional_update_append_after_end
-    c1, c2, c3  = @model1.children.order(:position)
+    c1, c2, c3 = @model1.children.order(:position)
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
-             after: { '_type' => 'Child', 'id' => c3.id, })
+              { '_type' => 'Child', 'name' => 'new c2' },],
+             after: { '_type' => 'Child', 'id' => c3.id })
     end
 
     append_view = { '_type'    => 'Model',
@@ -758,9 +759,9 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
+              { '_type' => 'Child', 'name' => 'new c2' },],
              after: { '_type' => 'Child', 'id' => c2.id },
-             )
+            )
     end
 
     append_view = { '_type'    => 'Model',
@@ -778,7 +779,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
       remove([{ '_type' => 'Child', 'id' => c2_id }])
     end
 
-    remove_view         = { '_type'    => 'Model',
+    remove_view = { '_type' => 'Model',
                             'id'       => @model1.id,
                             'children' => fupdate }
     viewmodel_class.deserialize_from_view(remove_view)
@@ -788,7 +789,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   end
 
   def test_functional_update_remove_failure
-    c_id        = @model1.children.pluck(:id).first
+    c_id = @model1.children.pluck(:id).first
 
     fupdate = build_fupdate do
       remove([{ '_type' => 'Child',
@@ -816,7 +817,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
                 'name'  => 'Functionally Updated Child' }])
     end
 
-    update_view         = { '_type'    => 'Model',
+    update_view = { '_type' => 'Model',
                             'id'       => @model1.id,
                             'children' => fupdate }
     viewmodel_class.deserialize_from_view(update_view)
@@ -866,7 +867,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   describe 'owned reference children' do
     def child_attributes
-      super.merge(viewmodel: ->(v) { root! })
+      super.merge(viewmodel: ->(_v) { root! })
     end
 
     def new_model