From bcfc5d2b5bcd3d0252fb98c666feed982f35489f Mon Sep 17 00:00:00 2001 From: Colin Surprenant Date: Sat, 29 Jun 2013 19:09:05 -0400 Subject: [PATCH] replaced instance_exec with define_method --- lib/red_storm/dsl/bolt.rb | 33 +++++++-------- lib/red_storm/dsl/spout.rb | 70 +++++++++++++------------------- spec/red_storm/dsl/bolt_spec.rb | 2 + spec/red_storm/dsl/spout_spec.rb | 13 ++++++ 4 files changed, 57 insertions(+), 61 deletions(-) diff --git a/lib/red_storm/dsl/bolt.rb b/lib/red_storm/dsl/bolt.rb index 9957595..00c134f 100644 --- a/lib/red_storm/dsl/bolt.rb +++ b/lib/red_storm/dsl/bolt.rb @@ -30,15 +30,21 @@ module RedStorm method_name = args.first self.receive_options.merge!(options) - @on_receive_block = block_given? ? on_receive_block : lambda {|tuple| self.send(method_name || :on_receive, tuple)} + + # indirecting through a lambda defers the method lookup at invocation time + # and the performance penalty is negligible + body = block_given? ? on_receive_block : lambda{|tuple| self.send((method_name || :on_receive).to_sym, tuple)} + define_method(:on_receive, body) end def self.on_init(method_name = nil, &on_init_block) - @on_init_block = block_given? ? on_init_block : lambda {self.send(method_name || :on_init)} + body = block_given? ? on_init_block : lambda {self.send((method_name || :on_init).to_sym)} + define_method(:on_init, body) end - def self.on_close(method_name = nil, &close_block) - @close_block = block_given? ? close_block : lambda {self.send(method_name || :on_close)} + def self.on_close(method_name = nil, &on_close_block) + body = block_given? ? on_close_block : lambda {self.send((method_name || :on_close).to_sym)} + define_method(:on_close, body) end # DSL instance methods @@ -66,7 +72,7 @@ module RedStorm # Bolt proxy interface def execute(tuple) - output = instance_exec(tuple, &self.class.on_receive_block) + output = on_receive(tuple) if output && self.class.emit? values_list = !output.is_a?(Array) ? [[output]] : !output.first.is_a?(Array) ? [output] : output values_list.each{|values| self.class.anchor? ? anchored_emit(tuple, *values) : unanchored_emit(*values)} @@ -78,11 +84,12 @@ module RedStorm @collector = collector @context = context @config = config - instance_exec(&self.class.on_init_block) + + on_init end def cleanup - instance_exec(&self.class.close_block) + on_close end def declare_output_fields(declarer) @@ -109,18 +116,6 @@ module RedStorm @configure_block ||= lambda {} end - def self.on_receive_block - @on_receive_block ||= lambda {|tuple| self.send(:on_receive, tuple)} - end - - def self.on_init_block - @on_init_block ||= lambda {self.send(:on_init)} - end - - def self.close_block - @close_block ||= lambda {self.send(:on_close)} - end - def self.receive_options @receive_options ||= {:emit => true, :ack => false, :anchor => false} end diff --git a/lib/red_storm/dsl/spout.rb b/lib/red_storm/dsl/spout.rb index 545755a..7c435c9 100644 --- a/lib/red_storm/dsl/spout.rb +++ b/lib/red_storm/dsl/spout.rb @@ -30,31 +30,43 @@ module RedStorm method_name = args.first self.send_options.merge!(options) - @on_send_block = block_given? ? on_send_block : lambda {self.send(method_name || :on_send)} + + # indirecting through a lambda defers the method lookup at invocation time + # and the performance penalty is negligible + body = block_given? ? on_send_block : lambda{self.send((method_name || :on_send).to_sym)} + define_method(:on_send, body) end def self.on_init(method_name = nil, &on_init_block) - @on_init_block = block_given? ? on_init_block : lambda {self.send(method_name || :on_init)} + body = block_given? ? on_init_block : lambda {self.send((method_name || :on_init).to_sym)} + define_method(:on_init, body) end def self.on_close(method_name = nil, &on_close_block) - @on_close_block = block_given? ? on_close_block : lambda {self.send(method_name || :on_close)} + body = block_given? ? on_close_block : lambda {self.send((method_name || :on_close).to_sym)} + define_method(:on_close, body) end def self.on_activate(method_name = nil, &on_activate_block) - @on_activate_block = block_given? ? on_activate_block : lambda {self.send(method_name || :on_activate)} + # @on_activate_block = block_given? ? on_activate_block : lambda {self.send(method_name || :on_activate)} + body = block_given? ? on_activate_block : lambda {self.send((method_name || :on_activate).to_sym)} + define_method(:on_activate, body) end def self.on_deactivate(method_name = nil, &on_deactivate_block) - @on_deactivate_block = block_given? ? on_deactivate_block : lambda {self.send(method_name || :on_deactivate)} + # @on_deactivate_block = block_given? ? on_deactivate_block : lambda {self.send(method_name || :on_deactivate)} + body = block_given? ? on_deactivate_block : lambda {self.send((method_name || :on_deactivate).to_sym)} + define_method(:on_deactivate, body) end def self.on_ack(method_name = nil, &on_ack_block) - @on_ack_block = block_given? ? on_ack_block : lambda {|msg_id| self.send(method_name || :on_ack, msg_id)} + body = block_given? ? on_ack_block : lambda {|msg_id| self.send((method_name || :on_ack).to_sym, msg_id)} + define_method(:on_ack, body) end def self.on_fail(method_name = nil, &on_fail_block) - @on_fail_block = block_given? ? on_fail_block : lambda {|msg_id| self.send(method_name || :on_fail, msg_id)} + body = block_given? ? on_fail_block : lambda {|msg_id| self.send((method_name || :on_fail).to_sym, msg_id)} + define_method(:on_fail, body) end # DSL instance methods @@ -75,7 +87,8 @@ module RedStorm # Spout proxy interface def next_tuple - output = instance_exec(&self.class.on_send_block) + output = on_send + if self.class.emit? if output values = [output].flatten @@ -95,19 +108,20 @@ module RedStorm @collector = collector @context = context @config = config - instance_exec(&self.class.on_init_block) + + on_init end def close - instance_exec(&self.class.on_close_block) + on_close end def activate - instance_exec(&self.class.on_activate_block) + on_activate end def deactivate - instance_exec(&self.class.on_deactivate_block) + on_deactivate end def declare_output_fields(declarer) @@ -115,11 +129,11 @@ module RedStorm end def ack(msg_id) - instance_exec(msg_id, &self.class.on_ack_block) + on_ack(msg_id) end def fail(msg_id) - instance_exec(msg_id, &self.class.on_fail_block) + on_fail(msg_id) end def get_component_configuration @@ -146,34 +160,6 @@ module RedStorm @configure_block ||= lambda {} end - def self.on_send_block - @on_send_block ||= lambda {self.send(:on_send)} - end - - def self.on_init_block - @on_init_block ||= lambda {self.send(:on_init)} - end - - def self.on_close_block - @on_close_block ||= lambda {self.send(:on_close)} - end - - def self.on_activate_block - @on_activate_block ||= lambda {self.send(:on_activate)} - end - - def self.on_deactivate_block - @on_deactivate_block ||= lambda {self.send(:on_deactivate)} - end - - def self.on_ack_block - @on_ack_block ||= lambda {|msg_id| self.send(:on_ack, msg_id)} - end - - def self.on_fail_block - @on_fail_block ||= lambda {|msg_id| self.send(:on_fail, msg_id)} - end - def self.send_options @send_options ||= {:emit => true, :reliable => false} end diff --git a/spec/red_storm/dsl/bolt_spec.rb b/spec/red_storm/dsl/bolt_spec.rb index 4c84296..3389017 100644 --- a/spec/red_storm/dsl/bolt_spec.rb +++ b/spec/red_storm/dsl/bolt_spec.rb @@ -164,7 +164,9 @@ describe RedStorm::SimpleBolt do it "should parse without options" do class Bolt1 < RedStorm::SimpleBolt + def test_method; end on_receive :test_method + end Bolt1.receive_options.should == DEFAULT_RECEIVE_OPTIONS diff --git a/spec/red_storm/dsl/spout_spec.rb b/spec/red_storm/dsl/spout_spec.rb index 9f13cae..ece2a8d 100644 --- a/spec/red_storm/dsl/spout_spec.rb +++ b/spec/red_storm/dsl/spout_spec.rb @@ -7,6 +7,7 @@ describe RedStorm::SimpleSpout do Object.send(:remove_const, "Spout1") if Object.const_defined?("Spout1") Object.send(:remove_const, "Spout2") if Object.const_defined?("Spout2") Object.send(:remove_const, "Spout3") if Object.const_defined?("Spout3") + Object.send(:remove_const, "Spout4") if Object.const_defined?("Spout4") end describe "interface" do @@ -815,6 +816,8 @@ describe RedStorm::SimpleSpout do class Spout3 < RedStorm::SimpleSpout def on_ack(msg_id) trigger(msg_id); end end + class Spout4 < RedStorm::SimpleSpout + end spout = Spout1.new spout.should_receive(:trigger).once.with("test") @@ -827,6 +830,10 @@ describe RedStorm::SimpleSpout do spout = Spout3.new spout.should_receive(:trigger).once.with("test") spout.ack("test") + + spout = Spout4.new + spout.should respond_to :ack + spout.ack("test") end end @@ -842,6 +849,8 @@ describe RedStorm::SimpleSpout do class Spout3 < RedStorm::SimpleSpout def on_fail(msg_id) trigger(msg_id); end end + class Spout4 < RedStorm::SimpleSpout + end spout = Spout1.new spout.should_receive(:trigger).once.with("test") @@ -854,6 +863,10 @@ describe RedStorm::SimpleSpout do spout = Spout3.new spout.should_receive(:trigger).once.with("test") spout.fail("test") + + spout = Spout4.new + spout.should respond_to :fail + spout.fail("test") end end