lib/temple/mixins/engine_dsl.rb in temple-0.7.2 vs lib/temple/mixins/engine_dsl.rb in temple-0.7.3

@@ -15,68 +15,37 @@
         chain_modified!
       end
 
       def remove(name)
         name = chain_name(name)
-        found = false
-        chain.reject! do |i|
-          if i.first == name
-            found = true
-          else
-            false
-          end
-        end
-        raise "#{name} not found" unless found
+        raise "#{name} not found" unless chain.reject! {|i| i.first == name }
         chain_modified!
       end
 
       alias use append
 
       def before(name, *args, &block)
         name = chain_name(name)
         e = chain_element(args, block)
-        found, i = false, 0
-        while i < chain.size
-          if chain[i].first == name
-            found = true
-            chain.insert(i, e)
-            i += 2
-          else
-            i += 1
-          end
-        end
-        raise "#{name} not found" unless found
+        chain.map! {|f| f.first == name ? [e, f] : [f] }.flatten!(1)
+        raise "#{name} not found" unless chain.include?(e)
         chain_modified!
       end
 
       def after(name, *args, &block)
         name = chain_name(name)
         e = chain_element(args, block)
-        found, i = false, 0
-        while i < chain.size
-          if chain[i].first == name
-            found = true
-            i += 1
-            chain.insert(i, e)
-          end
-          i += 1
-        end
-        raise "#{name} not found" unless found
+        chain.map! {|f| f.first == name ? [f, e] : [f] }.flatten!(1)
+        raise "#{name} not found" unless chain.include?(e)
         chain_modified!
       end
 
       def replace(name, *args, &block)
         name = chain_name(name)
         e = chain_element(args, block)
-        found = false
-        chain.each_with_index do |c, i|
-          if c.first == name
-            found = true
-            chain[i] = e
-          end
-        end
-        raise "#{name} not found" unless found
+        chain.map! {|f| f.first == name ? e : f }
+        raise "#{name} not found" unless chain.include?(e)
         chain_modified!
       end
 
       # Shortcuts to access namespaces
       { filter: Temple::Filters,
@@ -106,34 +75,15 @@
       end
 
       def chain_proc_constructor(name, filter)
         raise(ArgumentError, 'Proc or blocks must have arity 0 or 1') if filter.arity > 1
         method_name = "FILTER #{name}"
-        if Class === self
-          define_method(method_name, &filter)
-          filter = instance_method(method_name)
-          if filter.arity == 1
-            proc {|engine| filter.bind(engine) }
-          else
-            proc do |engine|
-              f = filter.bind(engine).call
-              raise 'Constructor must return callable object' unless f.respond_to?(:call)
-              f
-            end
-          end
-        else
-          (class << self; self; end).class_eval { define_method(method_name, &filter) }
-          filter = method(method_name)
-          proc {|engine| filter }
-        end
+        c = Class === self ? self : singleton_class
+        filter = c.class_eval { define_method(method_name, &filter); instance_method(method_name) }
+        proc {|engine| filter.arity == 1 ? filter.bind(engine) : filter.bind(engine).call }
       end
 
-      def chain_callable_constructor(filter)
-        raise(ArgumentError, 'Class or callable argument is required') unless filter.respond_to?(:call)
-        proc {|engine| filter }
-      end
-
       def chain_element(args, block)
         name = args.shift
         if Class === name
           filter = name
           name = filter.name.to_sym
@@ -162,10 +112,11 @@
           [name, chain_class_constructor(filter, args.first)]
         else
           # Other callable argument (e.g. Object of class which implements #call or Method)
           # The callable has no access to the option hash of the engine.
           raise(ArgumentError, 'Too many arguments') unless args.empty?
-          [name, chain_callable_constructor(filter)]
+          raise(ArgumentError, 'Class or callable argument is required') unless filter.respond_to?(:call)
+          [name, proc { filter }]
         end
       end
     end
   end
 end