jruby-gradle
/
redstorm
mirror of https://github.com/jruby-gradle/redstorm
1
0
Fork 0
Code Issues Releases Wiki Activity

replaced instance_exec with define_method

This commit is contained in:
Colin Surprenant 2013-06-29 19:09:05 -04:00
parent e91b536297
commit bcfc5d2b5b
4 changed files with 57 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
lib/red_storm/dsl/bolt.rb
View File

@ -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

70
lib/red_storm/dsl/spout.rb
View File

@ -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

2
spec/red_storm/dsl/bolt_spec.rb
View File

@ -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

13
spec/red_storm/dsl/spout_spec.rb
View File

@ -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