lib/lou/transformer.rb in lou-0.2.3 vs lib/lou/transformer.rb in lou-0.3.0

@@ -1,56 +1,65 @@
-require 'active_support/core_ext/class/attribute'
 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
+        self.transformer_steps = []
+        self.transformer_error_class = Lou::Transformer::NeverError
       end
     end
 
-    def reverse_on(error)
-      self.error_class = error
+    def revert_on(error)
+      self.transformer_error_class = error
     end
 
-    def step
-      Step.new.tap do |t|
-        self.steps += [t]
+    def step(transformer)
+      transformer.tap do |t|
+        self.transformer_steps += [t]
       end
     end
 
-    def apply(input, total_steps = steps.count)
+    def up(&block)
+      Transformer::Step.new.up(&block)
+    end
+
+    def down(&block)
+      Transformer::Step.new.down(&block)
+    end
+
+    def apply(input, total_steps = transformer_steps.count)
       applied_steps = 0
       begin
-        steps.last(total_steps).each do |t|
+        transformer_steps.last(total_steps).each do |t|
           input = t.apply(input)
           applied_steps += 1
         end
-      rescue error_class => e
-        reverse(input, applied_steps) if total_steps == steps.count
+      rescue transformer_error_class => e
+        revert(input, applied_steps) if total_steps == transformer_steps.count
         raise e
       end
       input
     end
 
-    def reverse(output, total_steps = steps.count)
+    def revert(output, total_steps = transformer_steps.count)
       reversed_steps = 0
       begin
-        steps.first(total_steps).reverse_each do |t|
-          output = t.reverse(output)
+        transformer_steps.first(total_steps).reverse_each do |t|
+          output = t.revert(output)
           reversed_steps += 1
         end
-      rescue error_class => e
-        apply(output, reversed_steps) if total_steps == steps.count
+      rescue transformer_error_class => e
+        apply(output, reversed_steps) if total_steps == transformer_steps.count
         raise e
       end
       output
     end
+
+    protected
+
+    attr_accessor :transformer_steps, :transformer_error_class
   end
 end