lou 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34aac868cb5bf73797d2b41155f717ee85ffe7fd
-  data.tar.gz: 5cc5bada947c03de042098b226b85179e394ed53
+  metadata.gz: 6c875d55f836118c55dd4e3bedc345fb9839dbb6
+  data.tar.gz: 12c8985d3aaf1bf744a980f0135e456e8a04b860
 SHA512:
-  metadata.gz: c8d9d453b8dfd91ed8ad960a45086d042bedd7678d2231d99a9aa74ca5b587b825aa98c4447833a8672a0048744ac9670123524b0e788a1c5566bc9810a23984
-  data.tar.gz: 2451c3a54ea3c4ba91f5a3d031711882da48d34156e475e18cc1cc59bf9ed140a423630eeae252d4155b6eda5e8f095e2a40fd2721f8fb499f6fa13024310345
+  metadata.gz: 7eb8dedecc8d4589abcb8f83d7e37c00d32689e2710f1f58a6bbea709f198276d2e30c5ab889c3237a39f88e0e9b5691a640c4d3f859542748bfe618b5f9075d
+  data.tar.gz: 38e5554d87650c7df1f439d387091a6b749265b1941fe71edbaa74987ea74efcd4a593dc7521f37a1af0e76bf381325291b5722dbe8a48759d3a011c412e411a

data/README.md

@@ -17,6 +17,9 @@ require 'lou'
 class HashTransformer
   extend Lou::Transformer
 
+  # optional
+  reverse_on RuntimeError
+
   step.up do |x|
     x.merge(a_new_key: 'this is new')
   end.down do |x|
@@ -41,7 +44,9 @@ original = HashTransformer.reverse(result)
 # {:an_old_key=>"this is old"}
 ~~~
 
-The transforms are applied in the order that they're defined using the ~apply~ function, with each transform receiving the result of the previous one. The process can be reversed using the ~reverse~ function. Note that for each step, the input is the result of the previous step.
+The steps are applied in the order that they're defined, when the ~apply~ method is called, with each step receiving the result of the previous one. The process can be reversed using the ~reverse~ method. Note that for each step, the input is the result of the previous step.
+
+If ~reverse_on~ is defined, then any completed steps will be reversed if the exception specified is raised.
 
 Transformers inherit the steps of their parent class, so it's possible to reuse steps by using inheritance.
 

data/lib/lou/transformer.rb

@@ -3,29 +3,50 @@ require 'lou/transformer/step'
 
 module Lou
   module Transformer
+    # never raise this...
+    class NeverError < StandardError; end
+
     def self.extended(base)
       base.class_eval do
         class_attribute(:steps)
         self.steps = []
+        class_attribute(:error_class)
+        self.error_class = Lou::Transformer::NeverError
       end
     end
 
+    def reverse_on(error)
+      self.error_class = error
+    end
+
     def step
       Step.new.tap do |t|
         steps << t
       end
     end
 
-    def apply(input)
-      steps.each do |t|
-        input = t.apply(input)
+    def apply(input, total_steps = steps.count)
+      applied_steps = 0
+      begin
+        steps.last(total_steps).each do |t|
+          input = t.apply(input)
+          applied_steps += 1
+        end
+      rescue error_class => e
+        total_steps == steps.count ? reverse(input, applied_steps) : raise(e)
       end
       input
     end
 
-    def reverse(output)
-      steps.reverse_each do |t|
-        output = t.reverse(output)
+    def reverse(output, total_steps = steps.count)
+      reversed_steps = 0
+      begin
+        steps.first(total_steps).reverse_each do |t|
+          output = t.reverse(output)
+          reversed_steps += 1
+        end
+      rescue error_class => e
+        total_steps == steps.count ? apply(output, reversed_steps) : raise(e)
       end
       output
     end

data/lib/lou/version.rb

@@ -1,3 +1,3 @@
 module Lou
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/spec/lou/transformer_spec.rb

@@ -110,5 +110,93 @@ module Lou
         end
       end
     end
+
+    context 'when an error is raised' do
+      let(:klass) do
+        Class.new do
+          extend Lou::Transformer
+          step.up { |_| fail 'error on up' }.down { |_| fail 'error on down' }
+        end
+      end
+
+      describe '#apply' do
+        it 'raises the exception' do
+          expect { klass.apply('foo') }.to raise_error('error on up')
+        end
+      end
+
+      describe '#reverse' do
+        it 'raises the exception' do
+          expect { klass.reverse('bar') }.to raise_error('error on down')
+        end
+      end
+    end
+
+    context 'when #reverse_on has been set' do
+      let(:parent) do
+        Class.new do
+          extend Lou::Transformer
+
+          class SpecialError < StandardError; end
+
+          reverse_on SpecialError
+        end
+      end
+
+      let(:target) { instance_double('Target') }
+
+      context 'and an error is raised on the first step' do
+        let(:klass) do
+          Class.new(parent) do
+            step.up { |_| fail SpecialError }.down { |x| x.destroy(1); x  }
+            step.up { |x| x.create(2); x }.down { |_| fail SpecialError }
+          end
+        end
+
+        describe '#apply' do
+          it 'reverses no steps when the specified error is raised' do
+            expect(target).to_not receive(:create)
+            expect(target).to_not receive(:destroy)
+            klass.apply(target)
+          end
+        end
+
+        describe '#reverse' do
+          it 'applies no steps when the specified error is raised' do
+            expect(target).to_not receive(:destroy)
+            expect(target).to_not receive(:create)
+            klass.reverse(target)
+          end
+        end
+      end
+
+      context 'and an error is raised part-way through the transform' do
+        let(:klass) do
+          Class.new(parent) do
+            step.up { |x| x.create(1); x }.down { |x| x.destroy(1); x }
+            step.up { |_| fail SpecialError }.down { |_| fail SpecialError }
+            step.up { |x| x.create(3); x }.down { |x| x.destroy(3); x }
+          end
+        end
+
+        let(:target) { instance_double('Target') }
+
+        describe '#apply' do
+          it 'reverses all successfully applied steps when the specified error is raised' do
+            expect(target).to receive(:create).once.with(1).ordered
+            expect(target).to receive(:destroy).once.with(1).ordered
+            klass.apply(target)
+          end
+        end
+
+        describe '#reverse' do
+          it 'reapplies all successfully reversed steps when the specified error is raised' do
+            expect(target).to receive(:destroy).once.with(3).ordered
+            expect(target).to receive(:create).once.with(3).ordered
+            klass.reverse(target)
+          end
+        end
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lou
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Iain Beeston