ensure we correctly wrap nested classes (#18)

Author: markburns

CHANGELOG.md

@@ -25,3 +25,6 @@
 - All internal restructuring/refactoring into domains. 
 - Add support for organize `self.if(:condition, then: A, else: B)` syntax
 - change location of matchers to `require 'interactify/rspec_matchers/matchers'`
+
+## [0.4.1] - 2023-12-29
+- Fix bug triggered when nesting each and if

lib/interactify/dsl/each_chain.rb

@@ -33,17 +33,15 @@ def klass
           end                                                                           #   end
 
           define_singleton_method(:source_location) do                                  #   def self.source_location
-            const_source_location this.evaluating_receiver.to_s                                     #     [file, line]
+            const_source_location this.evaluating_receiver.to_s                         #     [file, line]
           end                                                                           #   end
 
           define_method(:run!) do                                                       #  def run!
             context.send(this.plural_resource_name).each_with_index do |resource, index|#    context.packages.each_with_index do |package, index|
               context[this.singular_resource_name] = resource                           #       context.package = package
               context[this.singular_resource_index_name] = index                        #       context.package_index = index
 
-              klasses = Wrapper.wrap_many(self, this.each_loop_klasses)
-
-              klasses.each do |interactor|                                              #       [A, B, C].each do |interactor|
+              self.class.klasses.each do |interactor|                                   #       [A, B, C].each do |interactor|
                 interactor.call!(context)                                               #         interactor.call!(context)
               end                                                                       #       end
             end                                                                         #     end
@@ -54,6 +52,14 @@ def klass
             context                                                                     #     context
           end                                                                           #   end
 
+          define_singleton_method(:klasses) do                                          #   def self.klasses
+            klasses = instance_variable_get(:@klasses)                                  #     @klasses ||= Wrapper.wrap_many(self, [A, B, C])
+            return klasses if klasses
+
+            instance_variable_set(:@klasses, Wrapper.wrap_many(self, this.each_loop_klasses))
+          end
+
+          # "<SomeNamespace::EachPackage iterates_over: [A, B, C]>"
           define_method(:inspect) do
             "<#{this.namespace}::#{this.iterator_klass_name} iterates_over: #{this.each_loop_klasses.inspect}>"
           end

spec/fixtures/asdf

@@ -0,0 +1,139 @@
+# This is test code.
+#
+# Avoid using organizers predominantly composed of lambdas. In complex organizers,
+# it's common to have many isolated interactor classes, but maintain some orchestration
+# code for readability and cohesion.
+#
+# For instance, rather than creating an EachProduct interactor or a separate interactor chain
+# for a single boolean flag, it's more efficient to manage the high-level business process
+# in one location. This approach reduces the need to switch between two mindsets:
+#
+# Mode 1 (High-Level Overview): Understanding the business process and identifying where changes fit.
+# Mode 2 (Detailed Implementation): Focusing on the specific logic of a process step.
+#
+# Initially, in Mode 1, a bird's-eye view is essential for grasping the process architecture.
+# Once this overview is clear, you pinpoint the relevant interactor for modifications or additions,
+# transitioning to Mode 2 for implementation.
+#
+# This distinction between modes is crucial. Mode 1 involves more reading, conceptualizing,
+# and questioning, often requiring navigation through multiple files and note-taking.
+# Mode 2 is about active coding and editing. Minimizing context switching between these modes
+# saves time and mental energy. It's also easier to maintain a high-level overview of the process
+# when the code is in one place.
+#
+# Typically this will allow us to move closer towards a one organizer per interaction model.
+# E.g. one Rails action == one organizer. 
+# Even the background job firing can be handled by the organizer via YourClass::Async.
+#
+# An improvement we aim for is automatic diagram generation from the organizers, utilizing
+# contracts for documentation.
+#
+# Note: The conditional structures (`if`, `each`) here are not executed at runtime in the usual
+# sense. They are evaluated when defining the organizer, leading to the creation of discrete
+# classes that handle the respective logic.
+#
+class AllTheThings
+  include Interactify
+
+  expect :things
+  optional :optional_thing
+  promise :a
+
+  organize \
+    self.if(
+      :things, 
+      then: [If::A, If::B], 
+      else: [If::C, If::D]
+    ),
+
+    # test each with lambda
+    self.if(
+      -> (c) { c.things },
+      self.each(
+        :things, 
+        If::A, 
+        If::B, 
+        -> (c) { c.lambda_set = true }
+      ),
+    ),
+
+    # test alternative if syntax
+    self.if(
+      -> (c) { c.a && c.b } ,
+      then: -> (c) { c.both_a_and_b = true },
+      else: -> (c) { c.both_a_and_b = false}
+    ),
+
+    # test setting a value to use later in the chain
+    -> (c) { c.more_things = [1, 2, 3, 4] },
+
+    # test lambdas inside each
+    self.each(
+      :more_things, 
+      -> (c) {
+        if c.more_thing_index.zero? 
+          c.first_more_thing = true
+        end
+      },
+      -> (c) {
+        if c.more_thing_index == 1
+          c.next_more_thing = true 
+        end
+      },
+      # test nested if inside each
+      {if: :not_set_thing, then: -> (c) { c.not_set_thing = true } },
+
+      # test setting a value after an else
+      -> (c) { c.more_thing = true }
+    ),
+
+    self.if(
+      :optional_thing, 
+      then: [
+        -> (c) { c.optional_thing_was_set = true },
+        -> (c) { c.and_then_another_thing = true },
+        -> (c) { c.and_one_more_thing = true },
+        # test nested each inside if
+        self.each(:more_things, 
+                  -> (c) { c.more_things[c.more_thing_index] = c.more_thing + 5 },
+                  -> (c) { c.more_things[c.more_thing_index] = c.more_thing + 5 }
+                 )
+      ],
+      else: -> (c) { c.optional_thing_was_set = false }
+    ),
+
+    # if -> each -> if -> each
+    self.if(:condition, then: [-> {}], else: [
+      self.each(
+        :things,
+        self.if(
+          :thing, 
+          then: self.each(
+            :more_things,
+            -> (c) { 
+              c.counter ||= 0
+              c.counter += 1
+            }
+          )
+        )
+      )
+    ]),
+
+    # each -> each -> each
+    self.each(
+      :more_things,
+      self.each(
+        :more_things,
+        self.each(
+          :more_things,
+          self.each(
+            :more_things,
+            -> (c) { 
+              c.heavily_nested_counter ||= 0
+              c.heavily_nested_counter += 1
+            }
+          )
+        )
+      )
+    )
+end

spec/fixtures/integration_app/app/interactors/all_the_things.rb

@@ -0,0 +1,13 @@
+module Each
+  class A
+    include Interactify
+
+    def call
+      context.a = 'a'
+      return unless context.thing
+
+      context.thing.a = 'a'
+      context.thing.a_index = context.thing_index
+    end
+  end
+end

spec/fixtures/integration_app/app/interactors/each/a.rb

@@ -0,0 +1,13 @@
+module Each
+  class B
+    include Interactify
+
+    def call
+      context.b = 'b'
+      return unless context.thing
+
+      context.thing.b = 'b'
+      context.thing.b_index = context.thing_index
+    end
+  end
+end

spec/fixtures/integration_app/app/interactors/each/b.rb

@@ -0,0 +1,13 @@
+module Each
+  class C
+    include Interactify
+
+    def call
+      context.c = 'c'
+      return unless context.thing
+
+      context.thing.c = 'c'
+      context.thing.c_index = context.thing_index
+    end
+  end
+end

spec/fixtures/integration_app/app/interactors/each/c.rb

@@ -0,0 +1,13 @@
+module Each
+  class D
+    include Interactify
+
+    def call
+      context.d = 'd'
+      return unless context.thing
+
+      context.thing.d = 'd'
+      context.thing.d_index = context.thing_index
+    end
+  end
+end

spec/fixtures/integration_app/app/interactors/each/d.rb

@@ -0,0 +1,10 @@
+module Each
+  class Organizer
+    include Interactify
+    expect :things
+
+    organize \
+      A, B, C, D,
+      self.each(:things, A, B, C, D)
+  end
+end

spec/fixtures/integration_app/app/interactors/each/organizer.rb

@@ -0,0 +1,13 @@
+module If
+  class A
+    include Interactify
+
+    def call
+      context.a = 'a'
+      return unless context.thing
+
+      context.thing.a = 'a'
+      context.thing.a_index = context.thing_index
+    end
+  end
+end

spec/fixtures/integration_app/app/interactors/if/a.rb

@@ -0,0 +1,13 @@
+module If
+  class B
+    include Interactify
+
+    def call
+      context.b = 'b'
+      return unless context.thing
+
+      context.thing.b = 'b'
+      context.thing.b_index = context.thing_index
+    end
+  end
+end

spec/fixtures/integration_app/app/interactors/if/b.rb

@@ -0,0 +1,13 @@
+module If
+  class C
+    include Interactify
+
+    def call
+      context.c = 'c'
+      return unless context.thing
+
+      context.thing.c = 'c'
+      context.thing.c_index = context.thing_index
+    end
+  end
+end

spec/fixtures/integration_app/app/interactors/if/c.rb

@@ -0,0 +1,13 @@
+module If
+  class D
+    include Interactify
+
+    def call
+      context.d = 'd'
+      return unless context.thing
+
+      context.thing.d = 'd'
+      context.thing.d_index = context.thing_index
+    end
+  end
+end

spec/fixtures/integration_app/app/interactors/if/d.rb

@@ -0,0 +1,40 @@
+module If
+  class Anyways
+    include Interactify
+
+    expect :blah, filled: false
+    
+    def call
+      context.anyways = blah
+    end
+  end
+
+  class MethodSyntaxOrganizer
+    include Interactify
+    expect :blah, filled: false
+
+    organize \
+      self.if(:blah, [A, B], [C, D]),
+      Anyways
+  end
+
+  class AlternativeMethodSyntaxOrganizer
+    include Interactify
+    expect :blah, filled: false
+
+    organize(
+      self.if(:blah, then: [A, B], else: [C, D]),
+      Anyways
+    )
+  end
+
+  class HashSyntaxOrganizer
+    include Interactify
+    expect :blah, filled: false
+
+    organize(
+      {if: :blah, then: [A, B], else: [C, D]},
+      Anyways
+    )
+  end
+end

spec/fixtures/integration_app/app/interactors/if/organizer.rb

@@ -0,0 +1 @@
+