lib/yaks/runner.rb in yaks-0.7.7 vs lib/yaks/runner.rb in yaks-0.8.0.alpha

@@ -3,22 +3,24 @@
     include Util
     include Anima.new(:object, :config, :options)
     include Adamantium::Flat
     extend Forwardable
 
-    def_delegators :config, :policy, :default_format, :format_options, :primitivize, :serializers
+    def_delegators :config,        :policy, :default_format, :format_options_hash,
+                                   :primitivize, :serializers
+    def_delegators :format_class,  :media_type, :format_name
 
     def call
-      process(steps, object)
+      Pipeline.new(steps).insert_hooks(hooks).call(object, env)
     end
 
-    def map(object)
-      process(insert_hooks([[:map, mapper]]), object)
+    def read
+      Pipeline.new([[:parse, serializer.inverse], [:format, formatter.inverse]]).insert_hooks(hooks).call(object, env)
     end
 
-    def process(operations, input)
-      operations.inject(input) {|memo, (_, step)| step.call(memo, env) }
+    def map
+      Pipeline.new([[:map, mapper]]).insert_hooks(hooks).call(object, env)
     end
 
     def context
       {
         policy: policy,
@@ -39,24 +41,15 @@
         Format.by_name(options.fetch(:format) { default_format })
       }
     end
     memoize :format_class
 
-    def media_type
-      format_class.media_type
-    end
-
-    def format_name
-      format_class.format_name
-    end
-
     def steps
-      insert_hooks(
-        [[ :map, mapper ],
-         [ :format, formatter ],
-         [ :primitivize, primitivizer],
-         [ :serialize, serializer ]])
+      [[ :map, mapper ],
+       [ :format, formatter ],
+       [ :primitivize, primitivizer],
+       [ :serialize, serializer ]]
     end
     memoize :steps
 
     def mapper
       options.fetch(:mapper) do
@@ -64,11 +57,11 @@
       end.new(context)
     end
     memoize :mapper, freezer: :noop
 
     def formatter
-      format_class.new(format_options[format_name])
+      format_class.new(format_options_hash[format_name])
     end
     memoize :formatter
 
     def primitivizer
       proc do |input|
@@ -88,25 +81,7 @@
 
     def hooks
       config.hooks + options.fetch(:hooks, [])
     end
 
-    def insert_hooks(steps)
-      hooks.inject(steps) do |steps, (type, target_step, name, hook)|
-        steps.flat_map do |step_name, callable|
-          if step_name.equal? target_step
-            case type
-            when :before
-              [[name, hook], [step_name, callable]]
-            when :after
-              [[step_name, callable], [name, hook]]
-            when :around
-              [[step_name, ->(x, env) { hook.call(x, env, &callable) }]]
-            when :skip
-              []
-            end
-          end || [[step_name, callable]]
-        end
-      end
-    end
   end
 end