RubyGems - interaktor - Versions diffs - 0.5.0 → 0.6.0.pre - Mend

interaktor 0.5.0 → 0.6.0.pre

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

checksums.yaml +4 -4
data/README.md +80 -71
data/interaktor.gemspec +2 -2
data/lib/interaktor/attributes.rb +24 -0
data/lib/interaktor/callable.rb +42 -262
data/lib/interaktor/error/attribute_error.rb +2 -2
data/lib/interaktor/error/attribute_validation_error.rb +20 -0
data/lib/interaktor/error/missing_explicit_success_error.rb +7 -2
data/lib/interaktor/error/organizer_missing_passed_attribute_error.rb +7 -7
data/lib/interaktor/error/organizer_success_attribute_missing_error.rb +4 -4
data/lib/interaktor/error/unknown_attribute_error.rb +4 -4
data/lib/interaktor/interaction.rb +83 -29
data/lib/interaktor/organizer.rb +7 -35
data/lib/interaktor.rb +2 -18
data/spec/interaktor/hooks_spec.rb +357 -363
data/spec/interaktor/organizer_spec.rb +57 -48
data/spec/support/helpers.rb +13 -2
data/spec/support/lint.rb +219 -271
metadata +11 -11
data/lib/interaktor/error/attribute_schema_validation_error.rb +0 -54
data/spec/interaktor/context_spec.rb +0 -187

data/spec/interaktor/hooks_spec.rb CHANGED Viewed

@@ -1,460 +1,454 @@
-# rubocop:disable RSpec/ScatteredSetup
+RSpec.describe Interaktor::Hooks do
+  describe "#with_hooks" do
+    def build_hooked(&block)
+      hooked = Class.new.send(:include, Interaktor::Hooks)
-module Interaktor
-  RSpec.describe Hooks do
-    describe "#with_hooks" do
-      def build_hooked(&block)
-        hooked = Class.new.send(:include, Interaktor::Hooks)
+      hooked.class_eval do
+        attr_reader :steps
-        hooked.class_eval do
-          attr_reader :steps
-          def self.process
-            new.tap(&:process).steps
-          end
-          def initialize
-            @steps = []
-          end
+        def self.process
+          new.tap(&:process).steps
+        end
-          def process
-            with_hooks { steps << :process }
-          end
+        def initialize
+          @steps = []
         end
-        hooked.class_eval(&block) if block
-        hooked
+        def process
+          with_hooks { steps << :process }
+        end
       end
-      context "with an around hook method" do
-        let(:hooked) {
-          build_hooked do
-            around :add_around_before_and_around_after
+      hooked.class_eval(&block) if block
+      hooked
+    end
-            private
+    context "with an around hook method" do
+      let(:hooked) {
+        build_hooked do
+          around :add_around_before_and_around_after
-            def add_around_before_and_around_after(hooked)
-              steps << :around_before
-              hooked.call
-              steps << :around_after
-            end
-          end
-        }
+          private
-        it "runs the around hook method" do
-          expect(hooked.process).to eq([
-            :around_before,
-            :process,
-            :around_after
-          ])
+          def add_around_before_and_around_after(hooked)
+            steps << :around_before
+            hooked.call
+            steps << :around_after
+          end
         end
+      }
+      it "runs the around hook method" do
+        expect(hooked.process).to eq([
+          :around_before,
+          :process,
+          :around_after
+        ])
       end
+    end
-      context "with an around hook block" do
-        let(:hooked) {
-          build_hooked do
-            around do |hooked|
-              steps << :around_before
-              hooked.call
-              steps << :around_after
-            end
-          end
-        }
-        it "runs the around hook block" do
-          expect(hooked.process).to eq([
-            :around_before,
-            :process,
-            :around_after
-          ])
+    context "with an around hook block" do
+      let(:hooked) {
+        build_hooked do
+          around do |hooked|
+            steps << :around_before
+            hooked.call
+            steps << :around_after
+          end
         end
+      }
+      it "runs the around hook block" do
+        expect(hooked.process).to eq([
+          :around_before,
+          :process,
+          :around_after
+        ])
       end
+    end
+    context "with an around hook method and block in one call" do
+      let(:hooked) {
+        build_hooked do
+          around :add_around_before1_and_around_after1 do |hooked|
+            steps << :around_before2
+            hooked.call
+            steps << :around_after2
+          end
-      context "with an around hook method and block in one call" do
-        let(:hooked) {
-          build_hooked do
-            around :add_around_before1_and_around_after1 do |hooked|
-              steps << :around_before2
-              hooked.call
-              steps << :around_after2
-            end
-            private
-            def add_around_before1_and_around_after1(hooked)
-              steps << :around_before1
-              hooked.call
-              steps << :around_after1
-            end
-          end
-        }
-        it "runs the around hook method and block in order" do
-          expect(hooked.process).to eq([
-            :around_before1,
-            :around_before2,
-            :process,
-            :around_after2,
-            :around_after1
-          ])
+          private
+          def add_around_before1_and_around_after1(hooked)
+            steps << :around_before1
+            hooked.call
+            steps << :around_after1
+          end
         end
+      }
+      it "runs the around hook method and block in order" do
+        expect(hooked.process).to eq([
+          :around_before1,
+          :around_before2,
+          :process,
+          :around_after2,
+          :around_after1
+        ])
       end
+    end
-      context "with an around hook method and block in multiple calls" do
-        let(:hooked) {
-          build_hooked do
-            around do |hooked|
-              steps << :around_before1
-              hooked.call
-              steps << :around_after1
-            end
-            around :add_around_before2_and_around_after2
-            private
-            def add_around_before2_and_around_after2(hooked)
-              steps << :around_before2
-              hooked.call
-              steps << :around_after2
-            end
-          end
-        }
-        it "runs the around hook block and method in order" do
-          expect(hooked.process).to eq([
-            :around_before1,
-            :around_before2,
-            :process,
-            :around_after2,
-            :around_after1
-          ])
+    context "with an around hook method and block in multiple calls" do
+      let(:hooked) {
+        build_hooked do
+          around do |hooked|
+            steps << :around_before1
+            hooked.call
+            steps << :around_after1
+          end
+          around :add_around_before2_and_around_after2
+          private
+          def add_around_before2_and_around_after2(hooked)
+            steps << :around_before2
+            hooked.call
+            steps << :around_after2
+          end
         end
+      }
+      it "runs the around hook block and method in order" do
+        expect(hooked.process).to eq([
+          :around_before1,
+          :around_before2,
+          :process,
+          :around_after2,
+          :around_after1
+        ])
       end
+    end
-      context "with a before hook method" do
-        let(:hooked) {
-          build_hooked do
-            before :add_before
+    context "with a before hook method" do
+      let(:hooked) {
+        build_hooked do
+          before :add_before
-            private
+          private
-            def add_before
-              steps << :before
-            end
+          def add_before
+            steps << :before
           end
-        }
-        it "runs the before hook method" do
-          expect(hooked.process).to eq([
-            :before,
-            :process
-          ])
         end
+      }
+      it "runs the before hook method" do
+        expect(hooked.process).to eq([
+          :before,
+          :process
+        ])
       end
+    end
-      context "with a before hook block" do
-        let(:hooked) {
-          build_hooked do
-            before do
-              steps << :before
-            end
+    context "with a before hook block" do
+      let(:hooked) {
+        build_hooked do
+          before do
+            steps << :before
           end
-        }
-        it "runs the before hook block" do
-          expect(hooked.process).to eq([
-            :before,
-            :process
-          ])
         end
+      }
+      it "runs the before hook block" do
+        expect(hooked.process).to eq([
+          :before,
+          :process
+        ])
       end
+    end
-      context "with a before hook method and block in one call" do
-        let(:hooked) {
-          build_hooked do
-            before :add_before1 do
-              steps << :before2
-            end
+    context "with a before hook method and block in one call" do
+      let(:hooked) {
+        build_hooked do
+          before :add_before1 do
+            steps << :before2
+          end
-            private
+          private
-            def add_before1
-              steps << :before1
-            end
+          def add_before1
+            steps << :before1
           end
-        }
-        it "runs the before hook method and block in order" do
-          expect(hooked.process).to eq([
-            :before1,
-            :before2,
-            :process
-          ])
         end
+      }
+      it "runs the before hook method and block in order" do
+        expect(hooked.process).to eq([
+          :before1,
+          :before2,
+          :process
+        ])
       end
+    end
-      context "with a before hook method and block in multiple calls" do
-        let(:hooked) {
-          build_hooked do
-            before do
-              steps << :before1
-            end
+    context "with a before hook method and block in multiple calls" do
+      let(:hooked) {
+        build_hooked do
+          before do
+            steps << :before1
+          end
-            before :add_before2
+          before :add_before2
-            private
+          private
-            def add_before2
-              steps << :before2
-            end
+          def add_before2
+            steps << :before2
           end
-        }
-        it "runs the before hook block and method in order" do
-          expect(hooked.process).to eq([
-            :before1,
-            :before2,
-            :process
-          ])
         end
+      }
+      it "runs the before hook block and method in order" do
+        expect(hooked.process).to eq([
+          :before1,
+          :before2,
+          :process
+        ])
       end
+    end
-      context "with an after hook method" do
-        let(:hooked) {
-          build_hooked do
-            after :add_after
+    context "with an after hook method" do
+      let(:hooked) {
+        build_hooked do
+          after :add_after
-            private
+          private
-            def add_after
-              steps << :after
-            end
+          def add_after
+            steps << :after
           end
-        }
-        it "runs the after hook method" do
-          expect(hooked.process).to eq([
-            :process,
-            :after
-          ])
         end
+      }
+      it "runs the after hook method" do
+        expect(hooked.process).to eq([
+          :process,
+          :after
+        ])
       end
+    end
-      context "with an after hook block" do
-        let(:hooked) {
-          build_hooked do
-            after do
-              steps << :after
-            end
+    context "with an after hook block" do
+      let(:hooked) {
+        build_hooked do
+          after do
+            steps << :after
           end
-        }
-        it "runs the after hook block" do
-          expect(hooked.process).to eq([
-            :process,
-            :after
-          ])
         end
+      }
+      it "runs the after hook block" do
+        expect(hooked.process).to eq([
+          :process,
+          :after
+        ])
       end
+    end
-      context "with an after hook method and block in one call" do
-        let(:hooked) {
-          build_hooked do
-            after :add_after1 do
-              steps << :after2
-            end
+    context "with an after hook method and block in one call" do
+      let(:hooked) {
+        build_hooked do
+          after :add_after1 do
+            steps << :after2
+          end
-            private
+          private
-            def add_after1
-              steps << :after1
-            end
+          def add_after1
+            steps << :after1
           end
-        }
-        it "runs the after hook method and block in order" do
-          expect(hooked.process).to eq([
-            :process,
-            :after2,
-            :after1
-          ])
         end
+      }
+      it "runs the after hook method and block in order" do
+        expect(hooked.process).to eq([
+          :process,
+          :after2,
+          :after1
+        ])
       end
+    end
-      context "with an after hook method and block in multiple calls" do
-        let(:hooked) {
-          build_hooked do
-            after do
-              steps << :after1
-            end
+    context "with an after hook method and block in multiple calls" do
+      let(:hooked) {
+        build_hooked do
+          after do
+            steps << :after1
+          end
-            after :add_after2
+          after :add_after2
-            private
+          private
-            def add_after2
-              steps << :after2
-            end
+          def add_after2
+            steps << :after2
           end
-        }
-        it "runs the after hook block and method in order" do
-          expect(hooked.process).to eq([
-            :process,
-            :after2,
-            :after1
-          ])
         end
+      }
+      it "runs the after hook block and method in order" do
+        expect(hooked.process).to eq([
+          :process,
+          :after2,
+          :after1
+        ])
       end
+    end
-      context "with an ensure_hook method" do
-        let(:hooked) {
-          build_hooked do
-            ensure_hook :add_ensure
+    context "with an ensure_hook method" do
+      let(:hooked) {
+        build_hooked do
+          ensure_hook :add_ensure
-            private
+          private
-            def add_ensure
-              steps << :ensure
-            end
+          def add_ensure
+            steps << :ensure
           end
-        }
+        end
+      }
+      it "runs the after hook method" do
+        expect(hooked.process).to eq([
+          :process,
+          :ensure
+        ])
+      end
+    end
-        it "runs the after hook method" do
-          expect(hooked.process).to eq([
-            :process,
-            :ensure
-          ])
+    context "with an ensure_hook block" do
+      let(:hooked) {
+        build_hooked do
+          ensure_hook do
+            steps << :ensure
+          end
         end
+      }
+      it "runs the after hook block" do
+        expect(hooked.process).to eq([
+          :process,
+          :ensure
+        ])
       end
+    end
-      context "with an ensure_hook block" do
-        let(:hooked) {
-          build_hooked do
-            ensure_hook do
-              steps << :ensure
-            end
+    context "with an ensure_hook method and block in one call" do
+      let(:hooked) {
+        build_hooked do
+          ensure_hook :add_ensure1 do
+            steps << :ensure2
           end
-        }
-        it "runs the after hook block" do
-          expect(hooked.process).to eq([
-            :process,
-            :ensure
-          ])
+          private
+          def add_ensure1
+            steps << :ensure1
+          end
         end
+      }
+      it "runs the ensure_hook method and block in order" do
+        expect(hooked.process).to eq([
+          :process,
+          :ensure1,
+          :ensure2
+        ])
       end
+    end
-      context "with an ensure_hook method and block in one call" do
-        let(:hooked) {
-          build_hooked do
-            ensure_hook :add_ensure1 do
-              steps << :ensure2
-            end
+    context "with an ensure_hook method and block in multiple calls" do
+      let(:hooked) {
+        build_hooked do
+          ensure_hook do
+            steps << :ensure1
+          end
-            private
+          ensure_hook :add_ensure2
-            def add_ensure1
-              steps << :ensure1
-            end
-          end
-        }
+          private
-        it "runs the ensure_hook method and block in order" do
-          expect(hooked.process).to eq([
-            :process,
-            :ensure1,
-            :ensure2
-          ])
+          def add_ensure2
+            steps << :ensure2
+          end
         end
+      }
+      it "runs the ensure_hook block and method in order" do
+        expect(hooked.process).to eq([
+          :process,
+          :ensure1,
+          :ensure2
+        ])
       end
+    end
+    context "with around, before, after and ensure_hook hooks" do
+      let(:hooked) {
+        build_hooked do
+          around do |hooked|
+            steps << :around_before1
+            hooked.call
+            steps << :around_after1
+          end
+          around do |hooked|
+            steps << :around_before2
+            hooked.call
+            steps << :around_after2
+          end
-      context "with an ensure_hook method and block in multiple calls" do
-        let(:hooked) {
-          build_hooked do
-            ensure_hook do
-              steps << :ensure1
-            end
+          before do
+            steps << :before1
+          end
-            ensure_hook :add_ensure2
+          before do
+            steps << :before2
+          end
-            private
+          after do
+            steps << :after1
+          end
-            def add_ensure2
-              steps << :ensure2
-            end
+          after do
+            steps << :after2
           end
-        }
-        it "runs the ensure_hook block and method in order" do
-          expect(hooked.process).to eq([
-            :process,
-            :ensure1,
-            :ensure2
-          ])
-        end
-      end
+          ensure_hook do
+            steps << :ensure1
+          end
-      context "with around, before, after and ensure_hook hooks" do
-        let(:hooked) {
-          build_hooked do
-            around do |hooked|
-              steps << :around_before1
-              hooked.call
-              steps << :around_after1
-            end
-            around do |hooked|
-              steps << :around_before2
-              hooked.call
-              steps << :around_after2
-            end
-            before do
-              steps << :before1
-            end
-            before do
-              steps << :before2
-            end
-            after do
-              steps << :after1
-            end
-            after do
-              steps << :after2
-            end
-            ensure_hook do
-              steps << :ensure1
-            end
-            ensure_hook do
-              steps << :ensure2
-            end
-          end
-        }
-        it "runs hooks in the proper order" do
-          expect(hooked.process).to eq([
-            :around_before1,
-            :around_before2,
-            :before1,
-            :before2,
-            :process,
-            :after2,
-            :after1,
-            :around_after2,
-            :around_after1,
-            :ensure1,
-            :ensure2
-          ])
+          ensure_hook do
+            steps << :ensure2
+          end
         end
+      }
+      it "runs hooks in the proper order" do
+        expect(hooked.process).to eq([
+          :around_before1,
+          :around_before2,
+          :before1,
+          :before2,
+          :process,
+          :after2,
+          :after1,
+          :around_after2,
+          :around_after1,
+          :ensure1,
+          :ensure2
+        ])
       end
     end
   end
 end
-# rubocop:enable RSpec/ScatteredSetup