iknow_view_models 2.10.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9b87bb5a0377e13f42a5468d35a918f7555cad606a85a8ec20217862c9e3382
-  data.tar.gz: 84b0c4a23ed0749dc27a029cc93958f2571e047ce327214c174386e26ce921a3
+  metadata.gz: a86c98f9ceda1cb4bf6980a84eb2051b5bc3904c08ab85b8546c4b16c78d26ff
+  data.tar.gz: 3b988a29d63e06d929c3fa0ca31b7b11f585e03263653c8f5bea64f2583c2fa3
 SHA512:
-  metadata.gz: 0d2b3aafd5900d7cccd209c7526a39ad6099d670e4a15586e9b64b28a0211d153bef4dadca7d3ab4ed2a7203167e0022565e28bb8337669175c2d0d2257a6593
-  data.tar.gz: b8e28fca052e4664244704d876d94242d1ca4c2b40d696095011a5d795921d31dd5a588133e22ee813540e56a9cacfc77158b50b6df70288e1e59e6a3fa87fc3
+  metadata.gz: f281b79eda3e83689d5f2aec0239f89d73a4c1ad0778ee017c20af65088c50dc7356d2149bce7b487766a68947c85645cddd0f6e92f0312a7c2cad1489ccb6f0
+  data.tar.gz: a3f4960911039bc0679c068cc67c86bee0cdad278ab7acfbea66e36cdf8e064e45eed8ea709ecd3b75ddc42a7934645f93ad9699be5c40a0595a3d2b5db10dc6

data/.circleci/config.yml

@@ -0,0 +1,119 @@
+version: 2.1
+
+executors:
+  ruby-pg:
+    parameters:
+      ruby-version:
+        type: string
+        default: "2.6"
+      pg-version:
+        type: string
+        default: "11"
+      gemfile:
+        type: string
+        default: "Gemfile"
+    environment:
+      PGHOST: 127.0.0.1
+      PGUSER: eikaiwa
+    docker:
+      - image: circleci/ruby:<< parameters.ruby-version >>
+        environment:
+          BUNDLE_JOBS: 3
+          BUNDLE_RETRY: 3
+          BUNDLE_PATH: vendor/bundle
+          RAILS_ENV: test
+          BUNDLE_GEMFILE: << parameters.gemfile >>
+      - image: circleci/postgres:<< parameters.pg-version >>-alpine
+        environment:
+          POSTGRES_USER: eikaiwa
+          POSTGRES_DB: iknow_view_models
+          POSTGRES_PASSWORD: ""
+
+jobs:
+  test:
+    parameters:
+      ruby-version:
+        type: string
+      pg-version:
+        type: string
+      gemfile:
+        type: string
+    executor:
+      name: ruby-pg
+      ruby-version: << parameters.ruby-version >>
+      pg-version: << parameters.pg-version >>
+      gemfile: << parameters.gemfile >>
+    parallelism: 1
+    steps:
+      - checkout
+
+      - run:
+          # Remove the non-appraisal gemfile for safety: we never want to use it.
+          name: Prepare bundler
+          command: bundle -v && rm Gemfile
+
+      - run:
+          name: Compute a gemfile lock
+          command: bundle lock && cp "${BUNDLE_GEMFILE}.lock" /tmp/gem-lock
+
+      - restore_cache:
+          keys:
+            - iknow_viewmodels-<< parameters.ruby-version >>-{{ checksum "/tmp/gem-lock" }}
+            - iknow_viewmodels-
+
+      - run:
+          name: Bundle Install
+          command: bundle check || bundle install
+
+      - save_cache:
+          key: iknow_viewmodels-<< parameters.ruby-version >>-{{ checksum "/tmp/gem-lock" }}
+          paths:
+            - vendor/bundle
+
+      - run:
+          name: Wait for DB
+          command: dockerize -wait tcp://localhost:5432 -timeout 1m
+
+      - run:
+          name: Run minitest
+          command: bundle exec rake test
+
+      - store_test_results:
+          path: test/reports
+
+  publish:
+    executor: ruby-pg
+    steps:
+       - checkout
+       - run:
+           name: Setup Rubygems
+           command: |
+             mkdir ~/.gem &&
+             echo -e "---\r\n:rubygems_api_key: $RUBYGEMS_API_KEY" > ~/.gem/credentials &&
+             chmod 0600 ~/.gem/credentials
+       - run:
+           name: Publish to Rubygems
+           command: |
+             gem build iknow_view_models.gemspec
+             gem push iknow_view_models-*.gem
+
+workflows:
+  version: 2.1
+  build:
+    jobs:
+      - test:
+          name: 'ruby 2.6 rails 5.2 pg 11'
+          ruby-version: "2.6"
+          pg-version: "11"
+          gemfile: gemfiles/rails_5_2.gemfile
+      - test:
+          name: 'ruby 2.6 rails 6.0 pg 11'
+          ruby-version: "2.6"
+          pg-version: "11"
+          gemfile: gemfiles/rails_6_0_beta.gemfile
+      - publish:
+          filters:
+            branches:
+              only: master
+            tags:
+              ignore: /.*/

data/.travis.yml

@@ -0,0 +1,31 @@
+dist: trusty
+sudo: false
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.5
+
+gemfile:
+  - gemfiles/rails_5_2.gemfile
+
+addons:
+  postgresql: "10"
+  apt:
+    packages:
+      - postgresql-10
+      - postgresql-client-10
+      - postgresql-server-dev-10
+env:
+  global:
+    - PGPORT=5433
+
+before_install:
+  - gem update --system
+  - gem install bundler
+
+before_script:
+  - psql -c 'CREATE DATABASE iknow_view_models;'
+
+notifications:
+  email: false

data/Appraisals

@@ -1,19 +1,9 @@
-appraise 'rails-5-2' do
-  gem 'activerecord', '~> 5.2.0'
-  gem 'activesupport', '~> 5.2.0'
+appraise "rails-5-2" do
+  gem "activerecord", "~> 5.2.0"
+  gem "activesupport", "~> 5.2.0"
 end
 
-appraise 'rails-6-0' do
-  gem 'activerecord', '~> 6.0.0'
-  gem 'activesupport', '~> 6.0.0'
-end
-
-appraise 'rails-6-1' do
-  gem 'activerecord', '~> 6.1.0'
-  gem 'activesupport', '~> 6.1.0'
-end
-
-appraise 'rails-7-0' do
-  gem 'activerecord', '~> 7.0.0'
-  gem 'activesupport', '~> 7.0.0'
+appraise "rails-6-0-beta" do
+  gem "activerecord", "~> 6.0.0.beta"
+  gem "activesupport", "~> 6.0.0.beta"
 end

data/gemfiles/{rails_7_0.gemfile → rails_6_0_beta.gemfile}

@@ -3,7 +3,7 @@
 source "https://rubygems.org"
 
 gem "minitest-ci"
-gem "activerecord", "~> 7.0.0"
-gem "activesupport", "~> 7.0.0"
+gem "activerecord", "~> 6.0.0.beta"
+gem "activesupport", "~> 6.0.0.beta"
 
 gemspec path: "../"

data/iknow_view_models.gemspec

@@ -20,15 +20,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.7.3'
-
   spec.add_dependency "activerecord", ">= 5.0"
   spec.add_dependency "activesupport", ">= 5.0"
 
   spec.add_dependency "acts_as_manual_list"
-  spec.add_dependency "deep_preloader"
+  spec.add_dependency "deep_preloader", ">= 1.0.1"
   spec.add_dependency "iknow_cache"
-  spec.add_dependency "iknow_params", ">= 2.2.0", "< 2.4"
+  spec.add_dependency "iknow_params", "~> 2.2.0"
   spec.add_dependency "safe_values"
   spec.add_dependency "keyword_builder"
 
@@ -44,7 +42,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "byebug"
   spec.add_development_dependency "method_source"
   spec.add_development_dependency "minitest-hooks"
-  spec.add_development_dependency "pg"
+  spec.add_development_dependency "pg", '~> 0.18' # As of 5.1.4, Rails runtime check excludes pg 1.x, see #31669
   spec.add_development_dependency "pry"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec-expectations"

data/lib/iknow_view_models/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IknowViewModels
-  VERSION = '2.10.1'
+  VERSION = '3.0.0'
 end

data/lib/view_model/active_record/association_data.rb

@@ -1,95 +1,137 @@
 # frozen_string_literal: true
 
-# TODO consider rephrase scope for consistency
 class ViewModel::ActiveRecord::AssociationData
-  attr_reader :direct_reflection, :association_name
-
-  def initialize(association_name, direct_reflection, viewmodel_classes, shared, optional, through_to, through_order_attr)
-    @association_name   = association_name
-    @direct_reflection  = direct_reflection
-    @shared             = shared
-    @optional           = optional
-    @through_to         = through_to
-    @through_order_attr = through_order_attr
-
-    if viewmodel_classes
-      @viewmodel_classes = Array.wrap(viewmodel_classes).map! do |v|
-        case v
-        when String, Symbol
-          ViewModel::Registry.for_view_name(v.to_s)
-        when Class
-          v
+  class InvalidAssociation < RuntimeError; end
+
+  attr_reader :association_name, :direct_reflection
+
+  def initialize(owner:,
+                 association_name:,
+                 direct_association_name:,
+                 indirect_association_name:,
+                 target_viewmodels:,
+                 external:,
+                 through_order_attr:,
+                 read_only:)
+    @association_name = association_name
+
+    @direct_reflection = owner.model_class.reflect_on_association(direct_association_name)
+    if @direct_reflection.nil?
+      raise InvalidAssociation.new("Association '#{direct_association_name}' not found in model '#{model_class.name}'")
+    end
+
+    @indirect_association_name = indirect_association_name
+
+    @read_only           = read_only
+    @external            = external
+    @through_order_attr  = through_order_attr
+    @target_viewmodels   = target_viewmodels
+
+    # Target models/reflections/viewmodels are lazily evaluated so that we can
+    # safely express cycles.
+    @initialized         = false
+    @mutex               = Mutex.new
+  end
+
+  def lazy_initialize!
+    @mutex.synchronize do
+      return if @initialized
+
+      if through?
+        intermediate_model   = @direct_reflection.klass
+        @indirect_reflection = load_indirect_reflection(intermediate_model, @indirect_association_name)
+        target_reflection    = @indirect_reflection
+      else
+        target_reflection    = @direct_reflection
+      end
+
+      @viewmodel_classes =
+        if @target_viewmodels.present?
+          # Explicitly named
+          @target_viewmodels.map { |v| resolve_viewmodel_class(v) }
         else
-          raise ArgumentError.new("Invalid viewmodel class: #{v.inspect}")
+          # Infer name from name of model
+          if target_reflection.polymorphic?
+            raise InvalidAssociation.new(
+                    'Cannot automatically infer target viewmodels from polymorphic association')
+          end
+          infer_viewmodel_class(target_reflection.klass)
         end
+
+      @referenced = @viewmodel_classes.first.root?
+
+      # Non-referenced viewmodels must be owned. For referenced viewmodels, we
+      # own it if it points to us. Through associations aren't considered
+      # `owned?`: while we do own the implicit direct viewmodel, we don't own
+      # the target of the association.
+      @owned = !@referenced || (target_reflection.macro != :belongs_to)
+
+      unless @viewmodel_classes.all? { |v| v.root? == @referenced }
+        raise InvalidAssociation.new('Invalid association target: mixed root and non-root viewmodels')
       end
-    end
 
-    if through?
-      # Through associations must always be an owned direct association to a
-      # shared indirect target. We expect the user to set shared: true to
-      # express the ownership of the indirect target, but this direct
-      # association to the intermediate is in fact owned. This ownership
-      # property isn't directly used anywhere: the synthetic intermediate
-      # viewmodel is only used in the deserialization update operations, which
-      # directly understands the semantics of through associations.
-      raise ArgumentError.new("Through associations must be to a shared target") unless @shared
-      raise ArgumentError.new("Through associations must be `has_many`") unless direct_reflection.macro == :has_many
-    end
-  end
+      if external? && !@referenced
+        raise InvalidAssociation.new('External associations must be to root viewmodels')
+      end
 
-  # reflection for the target of this association: indirect if through, direct otherwise
-  def target_reflection
-    if through?
-      indirect_reflection
-    else
-      direct_reflection
+      if through?
+        unless @referenced
+          raise InvalidAssociation.new('Through associations must be to root viewmodels')
+        end
+
+        @direct_viewmodel = build_direct_viewmodel(@direct_reflection, @indirect_reflection,
+                                                   @viewmodel_classes, @through_order_attr)
+      end
+
+      @initialized = true
     end
   end
 
-  def polymorphic?
-    target_reflection.polymorphic?
+  def association?
+    true
   end
 
-  def viewmodel_classes
-    # If we weren't given explicit viewmodel classes, try to work out from the
-    # names. This should work unless the association is polymorphic.
-    @viewmodel_classes ||=
-      begin
-        model_class = target_reflection.klass
-        if model_class.nil?
-          raise "Couldn't derive target class for association '#{target_reflection.name}"
-        end
-        inferred_view_name = ViewModel::Registry.default_view_name(model_class.name)
-        viewmodel_class = ViewModel::Registry.for_view_name(inferred_view_name) # TODO: improve error message to show it's looking for default name
-        [viewmodel_class]
-      end
+  def referenced?
+    lazy_initialize! unless @initialized
+    @referenced
   end
 
-  private def model_to_viewmodel
-    @model_to_viewmodel ||= viewmodel_classes.each_with_object({}) do |vm, h|
-      h[vm.model_class] = vm
-    end
+  def nested?
+    !referenced?
   end
 
-  private def name_to_viewmodel
-    @name_to_viewmodel ||= viewmodel_classes.each_with_object({}) do |vm, h|
-      h[vm.view_name] = vm
-      vm.view_aliases.each do |view_alias|
-        h[view_alias] = vm
-      end
-    end
+  def owned?
+    lazy_initialize! unless @initialized
+    @owned
   end
 
   def shared?
-    @shared
+    !owned?
+  end
+
+  def external?
+    @external
+  end
+
+  def read_only?
+    @read_only
+  end
+
+  # reflection for the target of this association: indirect if through, direct otherwise
+  def target_reflection
+    if through?
+      indirect_reflection
+    else
+      direct_reflection
+    end
   end
 
-  def optional?
-    @optional
+  def polymorphic?
+    target_reflection.polymorphic?
   end
 
-  def pointer_location # TODO name
+  # The side of the immediate association that holds the pointer.
+  def pointer_location
     case direct_reflection.macro
     when :belongs_to
       :local
@@ -98,6 +140,24 @@ class ViewModel::ActiveRecord::AssociationData
     end
   end
 
+  def indirect_reflection
+    lazy_initialize! unless @initialized
+    @indirect_reflection
+  end
+
+  def direct_reflection_inverse(foreign_class = nil)
+    if direct_reflection.polymorphic?
+      direct_reflection.polymorphic_inverse_of(foreign_class)
+    else
+      direct_reflection.inverse_of
+    end
+  end
+
+  def viewmodel_classes
+    lazy_initialize! unless @initialized
+    @viewmodel_classes
+  end
+
   def viewmodel_class_for_model(model_class)
     model_to_viewmodel[model_class]
   end
@@ -132,47 +192,101 @@ class ViewModel::ActiveRecord::AssociationData
     unless viewmodel_classes.size == 1
       raise ArgumentError.new("More than one possible class for association '#{target_reflection.name}'")
     end
+
     viewmodel_classes.first
   end
 
   def through?
-    @through_to.present?
+    @indirect_association_name.present?
   end
 
   def direct_viewmodel
-    @direct_viewmodel ||= begin
-      raise 'not a through association' unless through?
+    raise ArgumentError.new('not a through association') unless through?
+    lazy_initialize! unless @initialized
+    @direct_viewmodel
+  end
+
+  def collection?
+    through? || direct_reflection.collection?
+  end
 
-      # Join table viewmodel class
+  def indirect_association_data
+    direct_viewmodel._association_data(indirect_reflection.name)
+  end
 
-      # For A has_many B through T; where this association is defined on A
+  private
 
-      # Copy into scope for new class block
-      direct_reflection   = self.direct_reflection    # A -> T
-      indirect_reflection = self.indirect_reflection  # T -> B
-      through_order_attr  = @through_order_attr
-      viewmodel_classes   = self.viewmodel_classes
+  # Through associations must always be to a root viewmodel, via an owned
+  # has_many association to an intermediate model. A synthetic viewmodel is
+  # created to represent this intermediate, but is used only internally by the
+  # deserialization update operations, which directly understands the semantics
+  # of through associations.
+  def load_indirect_reflection(intermediate_model, indirect_association_name)
+    indirect_reflection =
+      intermediate_model.reflect_on_association(ActiveSupport::Inflector.singularize(indirect_association_name))
 
-      Class.new(ViewModel::ActiveRecord) do
-        self.synthetic = true
-        self.model_class = direct_reflection.klass
-        self.view_name = direct_reflection.klass.name
-        association indirect_reflection.name, shared: true, optional: false, viewmodels: viewmodel_classes
-        acts_as_list through_order_attr if through_order_attr
-      end
+    if indirect_reflection.nil?
+      raise InvalidAssociation.new(
+              "Indirect association '#{@indirect_association_name}' not found in "\
+              "intermediate model '#{intermediate_model.name}'")
+    end
+
+    unless direct_reflection.macro == :has_many
+      raise InvalidAssociation.new('Through associations must be `has_many`')
     end
+
+    indirect_reflection
   end
 
-  def indirect_reflection
-    @indirect_reflection ||=
-      direct_reflection.klass.reflect_on_association(ActiveSupport::Inflector.singularize(@through_to))
+  def build_direct_viewmodel(direct_reflection, indirect_reflection, viewmodel_classes, through_order_attr)
+    # Join table viewmodel class. For A has_many B through T; where this association is defined on A
+    # direct_reflection   = A -> T
+    # indirect_reflection = T -> B
+
+    Class.new(ViewModel::ActiveRecord) do
+      self.synthetic = true
+      self.model_class = direct_reflection.klass
+      self.view_name = direct_reflection.klass.name
+      association indirect_reflection.name, viewmodels: viewmodel_classes
+      acts_as_list through_order_attr if through_order_attr
+    end
   end
 
-  def collection?
-    through? || direct_reflection.collection?
+  def resolve_viewmodel_class(v)
+    case v
+    when String, Symbol
+      ViewModel::Registry.for_view_name(v.to_s)
+    when Class
+      v
+    else
+      raise InvalidAssociation.new("Invalid viewmodel class: #{v.inspect}")
+    end
   end
 
-  def indirect_association_data
-    direct_viewmodel._association_data(indirect_reflection.name)
+  def infer_viewmodel_class(model_class)
+    # If we weren't given explicit viewmodel classes, try to work out from the
+    # names. This should work unless the association is polymorphic.
+    if model_class.nil?
+      raise InvalidAssociation.new("Couldn't derive target class for model association '#{target_reflection.name}'")
+    end
+
+    inferred_view_name = ViewModel::Registry.default_view_name(model_class.name)
+    viewmodel_class = ViewModel::Registry.for_view_name(inferred_view_name) # TODO: improve error message to show it's looking for default name
+    [viewmodel_class]
+  end
+
+  def model_to_viewmodel
+    @model_to_viewmodel ||= viewmodel_classes.each_with_object({}) do |vm, h|
+      h[vm.model_class] = vm
+    end
+  end
+
+  def name_to_viewmodel
+    @name_to_viewmodel ||= viewmodel_classes.each_with_object({}) do |vm, h|
+      h[vm.view_name] = vm
+      vm.view_aliases.each do |view_alias|
+        h[view_alias] = vm
+      end
+    end
   end
 end

data/lib/view_model/active_record/association_manipulation.rb

@@ -52,9 +52,7 @@ module ViewModel::ActiveRecord::AssociationManipulation
   def replace_associated(association_name, update_hash, references: {}, deserialize_context: self.class.new_deserialize_context)
     association_data = self.class._association_data(association_name)
 
-    # TODO: structure checking
-
-    if association_data.through? || association_data.shared?
+    if association_data.referenced?
       is_fupdate =
         association_data.collection? &&
         update_hash.is_a?(Hash) &&
@@ -125,10 +123,6 @@ module ViewModel::ActiveRecord::AssociationManipulation
 
           update_context = ViewModel::ActiveRecord::UpdateContext.build!(root_update_data, referenced_update_data, root_type: direct_viewmodel_class)
 
-          # Provide information about what was updated
-          deserialize_context.updated_associations = root_update_data.map(&:updated_associations)
-                                                       .inject({}) { |acc, assocs| acc.deep_merge(assocs) }
-
           # Set new parent
           new_parent = ViewModel::ActiveRecord::UpdateOperation::ParentData.new(direct_reflection.inverse_of, self)
           update_context.root_updates.each { |update| update.reparent_to = new_parent }
@@ -177,15 +171,26 @@ module ViewModel::ActiveRecord::AssociationManipulation
           child_context = self.context_for_child(association_name, context: deserialize_context)
           updated_viewmodels = update_context.run!(deserialize_context: child_context)
 
+          # Propagate changes and finalize the parent
+          updated_viewmodels.each do |child|
+            child_changes = child.previous_changes
+
+            if association_data.nested?
+              nested_children_changed!     if child_changes.changed_nested_tree?
+              referenced_children_changed! if child_changes.changed_referenced_children?
+            elsif association_data.owned?
+              referenced_children_changed! if child_changes.changed_owned_tree?
+            end
+          end
+
+          final_changes = self.clear_changes!
+
           if association_data.through?
             updated_viewmodels.map! do |direct_vm|
               direct_vm._read_association(association_data.indirect_reflection.name)
             end
           end
 
-          # Finalize the parent
-          final_changes = self.clear_changes!
-
           # Could happen if hooks attempted to change the parent, which aren't
           # valid since we're only editing children here.
           unless final_changes.contained_to?(associations: [association_name.to_s])
@@ -269,7 +274,12 @@ module ViewModel::ActiveRecord::AssociationManipulation
           association.delete(child_vm.model)
         end
 
-        self.children_changed!
+        if association_data.nested?
+          nested_children_changed!
+        elsif association_data.owned?
+          referenced_children_changed!
+        end
+
         final_changes = self.clear_changes!
 
         unless final_changes.contained_to?(associations: [association_name.to_s])
@@ -286,7 +296,7 @@ module ViewModel::ActiveRecord::AssociationManipulation
 
   private
 
-  def construct_direct_append_updates(association_data, subtree_hashes, references)
+  def construct_direct_append_updates(_association_data, subtree_hashes, references)
     ViewModel::ActiveRecord::UpdateData.parse_hashes(subtree_hashes, references)
   end