lib/hyperstack/internal/callbacks.rb in hyper-state-1.0.alpha1.8 vs lib/hyperstack/internal/callbacks.rb in hyper-state-1.0.0.pre.alpha1

@@ -1,56 +1,47 @@
 module Hyperstack
   module Internal
     module Callbacks
       if RUBY_ENGINE != 'opal'
         class Hyperstack::Hotloader
-          def self.when_file_updates(&block); end
+          def self.record(*args); end
         end
       end
       def self.included(base)
         base.extend(ClassMethods)
       end
 
       def run_callback(name, *args)
-        self.class.callbacks_for(name).flatten.each do |callback|
-          callback = method(callback) unless callback.is_a? Proc
-          args = self.class.send("_#{name}_before_call_hook", name, self, callback, *args)
+        self.class.callbacks_for(name).each do |callback|
+          if callback.is_a?(Proc)
+            instance_exec(*args, &callback)
+          else
+            send(callback, *args)
+          end
         end
-        args
       end
 
       module ClassMethods
-        def define_callback(callback_name, before_call_hook: nil, after_define_hook: nil)
+        def define_callback(callback_name, &after_define_hook)
           wrapper_name = "_#{callback_name}_callbacks"
           define_singleton_method(wrapper_name) do
             Context.set_var(self, "@#{wrapper_name}", force: true) { [] }
           end
-          before_call_hook ||= lambda do |_name, sself, proc, *args|
-            sself.instance_exec(*args, &proc)
-            args
-          end
-          define_singleton_method("_#{callback_name}_before_call_hook", &before_call_hook)
           define_singleton_method(callback_name) do |*args, &block|
-            args << block if block_given?
-            send(wrapper_name).push args
-            Hotloader.when_file_updates do
-              send(wrapper_name).delete_if { |item| item.equal? args }
-            end
-            after_define_hook.call(self) if after_define_hook
+            send(wrapper_name).concat(args)
+            send(wrapper_name).push(block) if block_given?
+            Hotloader.record(self, "@#{wrapper_name}", 4, *args, block)
+            after_define_hook.call(*args, &block) if after_define_hook
           end
         end
 
         def callbacks_for(callback_name)
           wrapper_name = "_#{callback_name}_callbacks"
           if superclass.respond_to? :callbacks_for
             superclass.callbacks_for(callback_name)
           else
             []
           end + send(wrapper_name)
-        end
-
-        def callbacks?(name)
-          callbacks_for(name).any?
         end
       end
     end
   end
 end