police-dataflow 0.0.1 → 0.0.2

data/test/dataflow/proxy_base_test.rb

@@ -2,144 +2,271 @@ require File.expand_path('../helper.rb', File.dirname(__FILE__))
 
 describe Police::DataFlow::ProxyBase do
   before do
-    @label = AutoFlowFixture.new
-    @label_set = {}
-    @autoflow_set = {}
-    Police::DataFlow::Labeling.add_label_to_set @label, @label_set,
-                                                @autoflow_set
+    Police::DataFlow::Proxies.clear_cache
+
+    @sticky_label = StickyFixture.new
+    @hook_label = HooksFlowFixture.new
+
     @proxied = ProxyingFixture.new
-    @proxy_class = Police::DataFlow::Proxies.for ProxyingFixture, @label_set
-    @proxy = @proxy_class.new @proxied, @proxy_class, @label_set, @autoflow_set
+
+    @sticky_label_set = {}
+    Police::DataFlow::Labeling.add_label_to_set @sticky_label,
+                                                @sticky_label_set
+    @sticky_proxy_class = ::Police::DataFlow::Proxies.for ProxyingFixture,
+                                                          @sticky_label_set
+    @sticky_proxy = @sticky_proxy_class.new @proxied, @sticky_proxy_class,
+                                            @sticky_label_set
+
+    @hook_label_set = {}
+    Police::DataFlow::Labeling.add_label_to_set @hook_label, @hook_label_set
+    @hook_proxy_class = ::Police::DataFlow::Proxies.for ProxyingFixture,
+                                                        @hook_label_set
+    @hook_proxy = @hook_proxy_class.new @proxied, @hook_proxy_class,
+                                                  @hook_label_set
   end
   after { Police::DataFlow::Proxies.clear_cache }
-  
-  it 'proxies public methods' do
-    # NOTE: this test exercises the slow path in method_missing
-    @proxy.route('One', 'Two').must_equal ['One', 'Two']
+
+  it 'proxies public methods through sticky labels' do
+    # NOTE: this test exercises the define-and-call path in method_missing
+    @sticky_proxy.route('One', 'Two').must_equal ['One', 'Two']
   end
-  
-  it 'allows labels to filter the return value of public methods' do
-    # NOTE: this test exercises the slow path in method_missing
-    Police::DataFlow.labels(@proxy.route('One', 'Two')).must_equal [@label]
+
+  it 'proxies public methods through hook labels' do
+    # NOTE: this test exercises the define-and-call path in method_missing
+    @hook_proxy.route('One', 'Two').must_equal ['One', 'Two']
   end
-  
+
+  it 'allows labels to stick to the return value of public methods' do
+    # NOTE: this test exercises the define-and-call path in method_missing
+    Police::DataFlow.labels(@sticky_proxy.route('One', 'Two')).must_equal(
+        [@sticky_label])
+  end
+
+  it 'allows labels to hook into the return value of public methods' do
+    # NOTE: this test exercises the define-and-call path in method_missing
+    Police::DataFlow.labels(@hook_proxy.route('One', 'Two')).must_equal(
+        [@hook_label])
+  end
+
   describe 'after proxying public methods' do
-    before { @proxy.route 'One', 'Two' }
-    
+    before do
+      @sticky_proxy.route 'One', 'Two'
+      @hook_proxy.route 'One', 'Two'
+    end
+
     it 'defines proxied methods on the fly' do
-      @proxy_class.public_method_defined?(:route).must_equal true
-      @proxy_class.instance_method(:route).owner.must_equal @proxy_class
+      @sticky_proxy_class.public_method_defined?(:route).must_equal true
+      @sticky_proxy_class.instance_method(:route).owner.must_equal(
+          @sticky_proxy_class)
+      @hook_proxy_class.public_method_defined?(:route).must_equal true
+      @hook_proxy_class.instance_method(:route).owner.must_equal(
+          @hook_proxy_class)
     end
 
     it 'still proxies public methods' do
       # NOTE: this test exercises the auto-generated proxy method's fast path
-      @proxy.route('One', 'Two').must_equal ['One', 'Two']
+      @sticky_proxy.route('One', 'Two').must_equal ['One', 'Two']
+      @hook_proxy.route('One', 'Two').must_equal ['One', 'Two']
     end
-    
-    it 'still allows labels to filter the return value of public methods' do
+
+    it 'still allows labels to stick to the return value of methods' do
+      # NOTE: this test exercises the auto-generated proxy method's fast path
+      Police::DataFlow.labels(@sticky_proxy.route('One', 'Two')).must_equal(
+          [@sticky_label])
+    end
+
+    it 'still allows labels to hook into the return value of methods' do
       # NOTE: this test exercises the auto-generated proxy method's fast path
-      Police::DataFlow.labels(@proxy.route('One', 'Two')).must_equal [@label]
+      Police::DataFlow.labels(@hook_proxy.route('One', 'Two')).must_equal(
+          [@hook_label])
     end
 
     it 'can still build proxies' do
-      other_proxy = @proxy_class.new ProxyingFixture.new, @proxy_class, 
-          @label_set, @autoflow_set
-      other_proxy.route('One', 'Two').must_equal ['One', 'Two']
+      other_sticky_proxy = @sticky_proxy_class.new ProxyingFixture.new,
+          @proxy_class, @sticky_label_set
+      other_sticky_proxy.route('One', 'Two').must_equal ['One', 'Two']
+
+      other_hook_proxy = @hook_proxy_class.new ProxyingFixture.new,
+          @proxy_class, @hook_label_set
+      other_hook_proxy.route('One', 'Two').must_equal ['One', 'Two']
     end
   end
-  
-  it 'proxies public methods with blocks' do
+
+  it 'proxies public methods with blocks through sticky labels' do
     # NOTE: this test exercises the slow path in method_missing
     result = []
-    @proxy.route('One', 'Two') { |*args| result << args }
+    @sticky_proxy.route('One', 'Two') { |*args| result << args }
     result.must_equal [['One', 'Two']]
   end
-  
-  it 'allows labels to filter the yielded values of public methods' do
+
+  it 'proxies public methods with blocks through hook labels' do
+    result = []
+    @hook_proxy.route('One', 'Two') { |*args| result << args }
+    result.must_equal [['One', 'Two']]
+  end
+
+  it 'allows labels to stick to the yielded values of public methods' do
+    # NOTE: this test exercises the slow path in method_missing
+    @sticky_proxy.route('One', 'Two') do |*args|
+      args.each do |arg|
+        Police::DataFlow.labels(arg).must_equal [@sticky_label]
+      end
+    end
+  end
+
+  it 'allows labels to hook into the yielded values of public methods' do
     # NOTE: this test exercises the slow path in method_missing
-    @proxy.route('One', 'Two') do |*args|
-      args.each { |arg| Police::DataFlow.labels(arg).must_equal [@label] }
+    @hook_proxy.route('One', 'Two') do |*args|
+      args.each { |arg| Police::DataFlow.labels(arg).must_equal [@hook_label] }
     end
   end
 
   describe 'after proxying public methods with blocks' do
-    before { @proxy.route('One', 'Two') { |*args| } }
-    
+    before do
+      @sticky_proxy.route('One', 'Two') { |*args| }
+      @hook_proxy.route('One', 'Two') { |*args| }
+    end
+
     it 'defines proxied methods on the fly' do
-      @proxy_class.public_method_defined?(:route).must_equal true
-      @proxy_class.instance_method(:route).owner.must_equal @proxy_class
+      @sticky_proxy_class.public_method_defined?(:route).must_equal true
+      @sticky_proxy_class.instance_method(:route).owner.must_equal(
+          @sticky_proxy_class)
+      @hook_proxy_class.public_method_defined?(:route).must_equal true
+      @hook_proxy_class.instance_method(:route).owner.must_equal(
+          @hook_proxy_class)
+    end
+
+    it 'still proxies public methods with blocks through sticky labels' do
+      # NOTE: this test exercises the auto-generated proxy method's fast path
+      result = []
+      @sticky_proxy.route('One', 'Two') { |*args| result << args }
+      result.must_equal [['One', 'Two']]
     end
 
-    it 'still proxies public methods with blocks' do
+    it 'still proxies public methods with blocks through hook labels' do
       # NOTE: this test exercises the auto-generated proxy method's fast path
       result = []
-      @proxy.route('One', 'Two') { |*args| result << args }
+      @hook_proxy.route('One', 'Two') { |*args| result << args }
       result.must_equal [['One', 'Two']]
     end
 
-    it 'still allows labels to filter the yielded values of public methods' do
+    it 'still allows labels to stick to the yielded values of methods' do
+      # NOTE: this test exercises the auto-generated proxy method's fast path
+      @hook_proxy.route('One', 'Two') do |*args|
+        args.each do |arg|
+          Police::DataFlow.labels(arg).must_equal [@hook_label]
+        end
+      end
+    end
+
+    it 'still allows labels to hook into the yielded values of methods' do
       # NOTE: this test exercises the auto-generated proxy method's fast path
-      @proxy.route('One', 'Two') do |*args|
-        args.each { |arg| Police::DataFlow.labels(arg).must_equal [@label] }
+      @hook_proxy.route('One', 'Two') do |*args|
+        args.each do |arg|
+          Police::DataFlow.labels(arg).must_equal [@hook_label]
+        end
       end
     end
-  end  
+  end
 
   it 'proxies protected methods' do
     # NOTE: this test exercises the slow path in method_missing
-    @proxy.__send__(:add, 'One', 'Two').must_equal 'One, Two'
+    @sticky_proxy.__send__(:add, 'One', 'Two').must_equal 'One, Two'
+    @hook_proxy.__send__(:add, 'One', 'Two').must_equal 'One, Two'
   end
 
-  it 'allows labels to filter the return value of protected methods' do
+  it 'allows labels to hook into the return value of protected methods' do
     # NOTE: this test exercises the slow path in method_missing
-    Police::DataFlow.labels(@proxy.__send__(:add, 'One', 'Two')).
-        must_equal [@label]
+    Police::DataFlow.labels(@sticky_proxy.__send__(:add, 'One', 'Two')).
+        must_equal [@sticky_label]
   end
-  
-  
+
+  it 'allows labels to hook into the return value of protected methods' do
+    # NOTE: this test exercises the slow path in method_missing
+    Police::DataFlow.labels(@hook_proxy.__send__(:add, 'One', 'Two')).
+        must_equal [@hook_label]
+  end
+
   describe 'after proxying protected methods' do
-    before { @proxy.__send__ :add, 'One', 'Two' }
-    
+    before do
+      @sticky_proxy.__send__ :add, 'One', 'Two'
+      @hook_proxy.__send__ :add, 'One', 'Two'
+    end
+
     it 'defines proxied methods on the fly' do
-      @proxy_class.protected_method_defined?(:add).must_equal true
-      @proxy_class.instance_method(:add).owner.must_equal @proxy_class
+      @sticky_proxy_class.protected_method_defined?(:add).must_equal true
+      @sticky_proxy_class.instance_method(:add).owner.must_equal(
+          @sticky_proxy_class)
+      @hook_proxy_class.protected_method_defined?(:add).must_equal true
+      @hook_proxy_class.instance_method(:add).owner.must_equal(
+          @hook_proxy_class)
     end
 
     it 'still proxies protected methods' do
       # NOTE: this test exercises the auto-generated proxy method's fast path
-      @proxy.__send__(:add, 'One', 'Two').must_equal 'One, Two'
+      @sticky_proxy.__send__(:add, 'One', 'Two').must_equal 'One, Two'
+      @hook_proxy.__send__(:add, 'One', 'Two').must_equal 'One, Two'
+    end
+
+    it 'still allows labels to sticky into protected methods' do
+      Police::DataFlow.labels(@sticky_proxy.__send__(:add, 'One', 'Two')).
+          must_equal [@sticky_label]
     end
 
-    it 'still allows labels to filter the return value of protected methods' do
+    it 'still allows labels to hook into protected methods' do
       # NOTE: this test exercises the auto-generated proxy method's fast path
-      Police::DataFlow.labels(@proxy.__send__(:add, 'One', 'Two')).
-          must_equal [@label]
+      Police::DataFlow.labels(@hook_proxy.__send__(:add, 'One', 'Two')).
+          must_equal [@hook_label]
     end
   end
-  
-  it 'proxies magic methods' do
-    @proxy.magic_meth('One', 'Two').must_equal ['meth', 'One', 'Two']
+
+  it 'proxies method_missing methods' do
+    # NOTE: this test exercises the method_missing+send slow proxying path.
+    @sticky_proxy.magic_meth('One', 'Two').must_equal ['meth', 'One', 'Two']
+    @hook_proxy.magic_meth('One', 'Two').must_equal ['meth', 'One', 'Two']
   end
 
-  it 'allows labels to filter the return value of magic methods' do
-    Police::DataFlow.labels(@proxy.magic_meth('One', 'Two')).must_equal [@label]
+  it 'proxies method_missing methods with blocks' do
+    # NOTE: this test exercises the method_missing+send slow proxying path.
+    @sticky_proxy.magic_meth('One', 'Two') { |*args|
+      args.must_equal ['One', 'Two']
+      args
+    }.must_equal ['meth', ['One', 'Two']]
+    @hook_proxy.magic_meth('One', 'Two') { |*args|
+      args.must_equal ['One', 'Two']
+      args
+    }.must_equal ['meth', ['One', 'Two']]
   end
 
-  describe 'after proxying magic methods' do
+  it 'allows labels to stick to method_missing methods return values' do
+    Police::DataFlow.labels(@sticky_proxy.magic_meth('One', 'Two')).
+                     must_equal [@sticky_label]
+  end
+
+  it 'allows labels to hook into method_missing methods' do
+    Police::DataFlow.labels(@hook_proxy.magic_meth('One', 'Two')).
+                     must_equal [@hook_label]
+  end
+
+  describe 'after proxying method_missing methods' do
     before do
-      @proxy.magic_meth 'One', 'Two'
+      @sticky_proxy.magic_meth 'One', 'Two'
+      @hook_proxy.magic_meth 'One', 'Two'
     end
 
-    it 'does not define magic proxied methods' do
-      @proxy_class.public_method_defined?(:magic_meth).must_equal false
-    end    
+    it 'does not define proxied methods' do
+      @sticky_proxy_class.public_method_defined?(:magic_meth).must_equal false
+      @hook_proxy_class.public_method_defined?(:magic_meth).must_equal false
+    end
   end
-  
+
   it 'proxies ==' do
-    (@proxy == nil).must_equal '== proxied'
+    (@sticky_proxy == nil).must_equal '== proxied'
+    (@hook_proxy == nil).must_equal '== proxied'
   end
 
   it 'proxies !=' do
-    (@proxy != nil).must_equal '!= proxied'
-  end  
+    (@sticky_proxy != nil).must_equal '!= proxied'
+    (@hook_proxy != nil).must_equal '!= proxied'
+  end
 end

data/test/dataflow/proxy_numeric_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../helper.rb', File.dirname(__FILE__))
+
+describe Police::DataFlow::ProxyNumeric do
+  before do
+    Police::DataFlow::Proxies.clear_cache
+    @label = StickyFixture.new
+    @label_set = {}
+    Police::DataFlow::Labeling.add_label_to_set @label, @label_set
+    @proxied = 21
+    @proxy_class = Police::DataFlow::Proxies.for @proxied.class, @label_set
+    @proxy = @proxy_class.new @proxied, @proxy_class, @label_set
+  end
+  after { Police::DataFlow::Proxies.clear_cache }
+
+  it 'defines coerce' do
+    @proxy_class.instance_methods.must_include :coerce
+  end
+
+  it 'returns a two-element Array from coerce' do
+    coerced = @proxy.coerce 42
+    coerced.class.must_equal Array
+    coerced.length.must_equal 2
+  end
+
+  it 'proxies the argument when coercing' do
+    coerced = @proxy.coerce 42
+    coerced[0].must_equal 42
+    coerced[0].__id__.wont_equal 42.__id__
+  end
+
+  it 'returns self correctly when coercing' do
+    coerced = @proxy.coerce 42
+    coerced[1].__id__.must_equal @proxy.__id__
+  end
+
+  it 'does not double-proxy' do
+    @proxied2 = 22
+    @proxy2 = @proxy_class.new @proxied2, @proxy_class, @label_set
+    coerced = @proxy.coerce @proxy2
+    coerced[0].__id__.must_equal @proxy2.__id__
+    coerced[1].__id__.must_equal @proxy.__id__
+    coerced.class.must_equal Array
+    coerced.length.must_equal 2
+  end
+end

data/test/dataflow/proxying_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../helper.rb', File.dirname(__FILE__))
 
 describe Police::DataFlow::Proxying do
-  describe '#add_class_methods' do
+  describe '#add_instance_methods' do
     before do
       @proxy_class = Class.new BasicObject do
         def self.__police_classes__
@@ -13,9 +13,10 @@ describe Police::DataFlow::Proxying do
       @proxy = @proxy_class.new
       @proxy.instance_exec(@proxied) { |p| @__police_proxied__ = p }
 
-      Police::DataFlow::Proxying.add_class_methods @proxy_class, ProxyingFixture
+      Police::DataFlow::Proxying.add_instance_methods @proxy_class,
+                                                      ProxyingFixture
     end
-    
+
     it 'adds public methods' do
       @proxy_class.public_method_defined?(:length).must_equal true
       @proxy_class.public_method_defined?(:==).must_equal true
@@ -25,13 +26,13 @@ describe Police::DataFlow::Proxying do
     it 'adds a protected method' do
       @proxy_class.protected_method_defined?(:add).must_equal true
     end
-    
+
     it 'adds a private method' do
       @proxy_class.private_method_defined?(:log).must_equal true
     end
   end
-  
-  describe '#add_class_method' do
+
+  describe '#add_instance_method' do
     before do
       @proxy_class = Class.new BasicObject do
         def self.__police_classes__
@@ -42,42 +43,42 @@ describe Police::DataFlow::Proxying do
       @proxy = @proxy_class.new
       @proxy.instance_exec(@proxied) { |p| @__police_proxied__ = p }
     end
-    
+
     describe 'with protected method with arguments' do
       before do
         @method = ProxyingFixture.instance_method :add
-        Police::DataFlow::Proxying.add_class_method @proxy_class, @method,
-                                                    :protected
+        Police::DataFlow::Proxying.add_instance_method @proxy_class, @method,
+                                                       :protected
       end
-      
+
       it 'defines the proxying method' do
-        @proxy_class.protected_method_defined?(:add).must_equal true        
+        @proxy_class.protected_method_defined?(:add).must_equal true
       end
-      
+
       it "has the proxying method's arity match the original" do
-        @proxy_class.instance_method(:add).arity.must_equal @method.arity        
+        @proxy_class.instance_method(:add).arity.must_equal @method.arity
       end
-      
+
       it 'proxies the method' do
         @proxy.__send__(:add, 'One', 'Two').must_equal 'One, Two'
       end
     end
-    
+
     describe 'with public method with variable arguments and blocks' do
       before do
         @method = ProxyingFixture.instance_method :route
-        Police::DataFlow::Proxying.add_class_method @proxy_class, @method,
-                                                    :public
+        Police::DataFlow::Proxying.add_instance_method @proxy_class, @method,
+                                                       :public
       end
-      
+
       it 'defines the proxying method' do
-        @proxy_class.public_method_defined?(:route).must_equal true        
+        @proxy_class.public_method_defined?(:route).must_equal true
       end
-      
+
       it "has the proxying method's arity match the original" do
-        @proxy_class.instance_method(:route).arity.must_equal @method.arity        
+        @proxy_class.instance_method(:route).arity.must_equal @method.arity
       end
-      
+
       it 'proxies the method without a block' do
         @proxy.route('One', 'Two').must_equal ['One', 'Two']
       end
@@ -90,124 +91,171 @@ describe Police::DataFlow::Proxying do
     end
 
     it 'proxies protected methods' do
-      Police::DataFlow::Proxying.add_class_method @proxy_class,
+      Police::DataFlow::Proxying.add_instance_method @proxy_class,
           ProxyingFixture.instance_method(:add), :protected
       @proxy_class.protected_method_defined?(:add).must_equal true
       @proxy.__send__(:add, 'One', 'Two').must_equal 'One, Two'
     end
   end
-  
+
   describe '#proxy_method_definition' do
     it 'returns a non-empty string for a public method' do
-      Police::DataFlow::Proxying.proxy_method_definition([AutoFlowFixture],
+      Police::DataFlow::Proxying.proxy_method_definition([StickyFixture],
           ProxyingFixture.instance_method(:length), :public).length.wont_equal 0
     end
 
     it 'returns a non-empty string for a private method' do
-      Police::DataFlow::Proxying.proxy_method_definition([AutoFlowFixture],
+      Police::DataFlow::Proxying.proxy_method_definition([StickyFixture],
           ProxyingFixture.instance_method(:length), :private).length.
           wont_equal 0
     end
-    
+
     # NOTE: testing the actual behavior would just duplicate the tests for
-    #       add_class_method
+    #       add_instance_method
   end
-  
+
   describe '#proxy_method_call' do
-    it 'works for a public method without a block' do
+    it 'works for a public method' do
       Police::DataFlow::Proxying.proxy_method_call(
-          ProxyingFixture.instance_method(:length), :public, false).
+          ProxyingFixture.instance_method(:length), :public).
           must_equal '@__police_proxied__.length()'
     end
 
-    it 'works for a protected method without a block' do
+    it 'works for a protected method' do
       Police::DataFlow::Proxying.proxy_method_call(
-          ProxyingFixture.instance_method(:add), :protected, false).
+          ProxyingFixture.instance_method(:add), :protected).
           must_equal '@__police_proxied__.__send__(:add, arg1, arg2)'
     end
 
-    it 'works for a public method with a block' do
-      Police::DataFlow::Proxying.proxy_method_call(
-          ProxyingFixture.instance_method(:length), :public, true).
-          must_equal '@__police_proxied__.length(&block)'
-    end
-
-    it 'works for a private method with a block' do
+    it 'works for a private method' do
       Police::DataFlow::Proxying.proxy_method_call(
-          ProxyingFixture.instance_method(:length), :private, true).
-          must_equal '@__police_proxied__.__send__(:length, &block)'
+          ProxyingFixture.instance_method(:length), :private).
+          must_equal '@__police_proxied__.__send__(:length)'
     end
 
-    it 'works for a private method with arguments and a block' do
+    it 'works for a private method with arguments' do
       Police::DataFlow::Proxying.proxy_method_call(
-          ProxyingFixture.instance_method(:log), :private, true).must_equal(
-          '@__police_proxied__.__send__(:log, arg1, arg2, *args, &block)')
+          ProxyingFixture.instance_method(:log), :private).must_equal(
+          '@__police_proxied__.__send__(:log, arg1, arg2, *args)')
     end
   end
-  
+
   describe '#proxy_yield_args_decorating' do
     let(:method) { ProxyingFixture.instance_method(:add) }
-    
-    it 'is empty if no label class is filtering' do
+
+    it 'is empty if no label class is hooking or auto-flowing' do
       Police::DataFlow::Proxying.proxy_yield_args_decorating([NoFlowFixture],
           method).must_equal ''
     end
-    
-    it 'works for one filtering label class' do
+
+    it 'works for one hooking label class' do
+      label2_class = Class.new BasicObject do
+        def self.yield_args_hook(method_name)
+          raise RuntimeError, 'Wrong method name' unless method_name == :add
+          :add_yield_args_hook
+        end
+        def self.sticky?
+          raise RuntimeError, 'sticky? should not be called'
+        end
+      end
+      golden = 'labels = @__police_labels__; ' \
+        "labels[#{label2_class.__id__}].each { |label, _| " \
+          "label.add_yield_args_hook(self, yield_args, arg1, arg2) }"
+      Police::DataFlow::Proxying.proxy_yield_args_decorating(
+          [NoFlowFixture, label2_class], method).must_equal golden
+    end
+
+    it 'works for one sticky label class' do
+      label2_class = Class.new BasicObject do
+        def self.yield_args_hook(method_name)
+          raise RuntimeError, 'Wrong method name' unless method_name == :add
+          nil
+        end
+        def self.sticky?
+          true
+        end
+      end
       golden = 'labels = @__police_labels__; ' \
-        "labels[#{AutoFlowFixture.__id__}].each { |label, _| " \
-          "label.sample_yield_args_hook(self, yield_args, arg1, arg2) }"
+        "labels[#{label2_class.__id__}].each { |label, _| " \
+          "yield_args.map! { |arg| ::Police::DataFlow.label(arg, label) } " \
+        "}"
       Police::DataFlow::Proxying.proxy_yield_args_decorating(
-          [NoFlowFixture, AutoFlowFixture], method).must_equal golden
+          [NoFlowFixture, label2_class], method).must_equal golden
     end
 
-    it 'works for two filtering label classes' do
+    it 'works for two hooking label classes' do
       label2_class = Class.new BasicObject do
         def self.yield_args_hook(method_name)
           :"#{method_name}_ah"
         end
       end
       golden = 'labels = @__police_labels__; ' \
-        "labels[#{AutoFlowFixture.__id__}].each { |label, _| " \
-          "label.sample_yield_args_hook(self, yield_args, arg1, arg2) }; " \
+        "labels[#{HooksFlowFixture.__id__}].each { |label, _| " \
+          "label.generic_yield_args_hook(self, yield_args, arg1, arg2) }; " \
         "labels[#{label2_class.__id__}].each { |label, _| " \
           "label.add_ah(self, yield_args, arg1, arg2) }"
       Police::DataFlow::Proxying.proxy_yield_args_decorating([NoFlowFixture,
-          AutoFlowFixture, label2_class], method).must_equal golden
+          HooksFlowFixture, label2_class], method).must_equal golden
     end
   end
 
   describe '#proxy_return_decorating' do
     let(:method) { ProxyingFixture.instance_method(:add) }
-    
-    it 'is empty if no label class is filtering' do
+
+    it 'is empty if no label class is hooking or auto-flowing' do
       Police::DataFlow::Proxying.proxy_return_decorating([NoFlowFixture],
           method).must_equal ''
     end
-    
-    it 'works for one filtering label class' do
+
+    it 'works for one hooking label class' do
+      label2_class = Class.new BasicObject do
+        def self.return_hook(method_name)
+          raise RuntimeError, 'Wrong method name' unless method_name == :add
+          'add_return_hook'
+        end
+        def self.sticky?(method_name)
+          raise RuntimeError, 'sticky? should not be called'
+        end
+      end
+      golden = 'labels = @__police_labels__; ' \
+        "labels[#{label2_class.__id__}].each { |label, _| " \
+          "return_value = label.add_return_hook(return_value, self, arg1, " \
+                                               "arg2) }"
+      Police::DataFlow::Proxying.proxy_return_decorating(
+          [NoFlowFixture, label2_class], method).must_equal golden
+    end
+
+    it 'works for one sticky label class' do
+      label2_class = Class.new BasicObject do
+        def self.return_hook(method_name)
+          raise RuntimeError, 'Wrong method name' unless method_name == :add
+          nil
+        end
+        def self.sticky?
+          true
+        end
+      end
       golden = 'labels = @__police_labels__; ' \
-        "labels[#{AutoFlowFixture.__id__}].each { |label, _| " \
-          "return_value = label.sample_return_hook(return_value, self, arg1, " \
-                                                  "arg2) }"
+        "labels[#{label2_class.__id__}].each { |label, _| " \
+          "return_value = ::Police::DataFlow.label(return_value, label) }"
       Police::DataFlow::Proxying.proxy_return_decorating(
-          [NoFlowFixture, AutoFlowFixture], method).must_equal golden      
+          [NoFlowFixture, label2_class], method).must_equal golden
     end
 
-    it 'works for two filtering label classes' do
+    it 'works for two hooking label classes' do
       label2_class = Class.new BasicObject do
         def self.return_hook(method_name)
           :"#{method_name}_rh"
         end
       end
       golden = 'labels = @__police_labels__; ' \
-        "labels[#{AutoFlowFixture.__id__}].each { |label, _| " \
-          "return_value = label.sample_return_hook(return_value, self, arg1, " \
-                                                  "arg2) }; " \
+        "labels[#{HooksFlowFixture.__id__}].each { |label, _| " \
+          "return_value = label.generic_return_hook(return_value, self, "\
+                                                   "arg1, arg2) }; " \
         "labels[#{label2_class.__id__}].each { |label, _| " \
           "return_value = label.add_rh(return_value, self, arg1, arg2) }"
       Police::DataFlow::Proxying.proxy_return_decorating([NoFlowFixture,
-          AutoFlowFixture, label2_class], method).must_equal golden      
+          HooksFlowFixture, label2_class], method).must_equal golden
     end
   end
 
@@ -217,29 +265,29 @@ describe Police::DataFlow::Proxying do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:length), false).must_equal ''
       end
-  
+
       it 'works for a one-argument method' do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:==), false).must_equal 'arg1'
       end
-  
+
       it 'works for a two-argument method' do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:add), false).
             must_equal 'arg1, arg2'
       end
-  
+
       it 'works for a variable-argument method' do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:route), false).must_equal '*args'
       end
-  
+
       it 'works for one fixed + variable-argument method' do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:<=>), false).
             must_equal 'arg1, *args'
       end
-      
+
       it 'works for two fixed + variable-argument method' do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:log), false).
@@ -252,31 +300,31 @@ describe Police::DataFlow::Proxying do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:length), true).must_equal '&block'
       end
-  
+
       it 'works for a one-argument method' do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:==), true).
             must_equal 'arg1, &block'
       end
-  
+
       it 'works for a two-argument method' do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:add), true).
             must_equal 'arg1, arg2, &block'
       end
-  
+
       it 'works for a variable-argument method' do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:route), true).
             must_equal '*args, &block'
       end
-  
+
       it 'works for one fixed + variable-argument method' do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:<=>), true).
             must_equal 'arg1, *args, &block'
       end
-      
+
       it 'works for two fixed + variable-argument method' do
         Police::DataFlow::Proxying.proxy_argument_list(
             ProxyingFixture.instance_method(:log), true).
@@ -284,4 +332,209 @@ describe Police::DataFlow::Proxying do
       end
     end
   end
+
+  describe '#proxy_call_argument_list' do
+    it 'uses proxy_argument_list for Ruby methods' do
+      Police::DataFlow::Proxying.proxy_call_argument_list(
+          ProxyingFixture.instance_method(:==)).must_equal 'arg1'
+    end
+
+    it 'uses low_level_call_argument_list for native methods' do
+      golden =
+          '(nil == arg1.__police_labels__) ? arg1 : arg1.__police_proxied__'
+      Police::DataFlow::Proxying.proxy_call_argument_list(
+          Object.instance_method(:==)).must_equal golden
+    end
+  end
+
+  describe '#proxy_low_level_call_argument_list' do
+    it 'works for an argument-less method' do
+      Police::DataFlow::Proxying.proxy_low_level_call_argument_list(
+          ProxyingFixture.instance_method(:length)).must_equal ''
+    end
+
+    it 'works for a one-argument method' do
+      golden =
+          '(nil == arg1.__police_labels__) ? arg1 : arg1.__police_proxied__'
+      Police::DataFlow::Proxying.proxy_low_level_call_argument_list(
+          ProxyingFixture.instance_method(:==)).must_equal golden
+    end
+
+    it 'works for a two-argument method' do
+      golden =
+          '(nil == arg1.__police_labels__) ? arg1 : arg1.__police_proxied__, ' +
+          '(nil == arg2.__police_labels__) ? arg2 : arg2.__police_proxied__'
+      Police::DataFlow::Proxying.proxy_low_level_call_argument_list(
+          ProxyingFixture.instance_method(:add)).must_equal golden
+    end
+
+    it 'works for a variable-argument method' do
+      golden = '*(args.map { |a| (nil == a.__police_labels__) ? a : ' +
+          'a.__police_proxied__ })'
+      Police::DataFlow::Proxying.proxy_low_level_call_argument_list(
+          ProxyingFixture.instance_method(:route)).must_equal golden
+    end
+
+    it 'works for one fixed + variable-argument method' do
+      golden =
+          '(nil == arg1.__police_labels__) ? arg1 : arg1.__police_proxied__, ' +
+          '*(args.map { |a| (nil == a.__police_labels__) ? a : ' +
+          'a.__police_proxied__ })'
+      Police::DataFlow::Proxying.proxy_low_level_call_argument_list(
+          ProxyingFixture.instance_method(:<=>)).must_equal golden
+    end
+
+    it 'works for two fixed + variable-argument method' do
+      golden =
+          '(nil == arg1.__police_labels__) ? arg1 : arg1.__police_proxied__, ' +
+          '(nil == arg2.__police_labels__) ? arg2 : arg2.__police_proxied__, ' +
+          '*(args.map { |a| (nil == a.__police_labels__) ? a : ' +
+          'a.__police_proxied__ })'
+      Police::DataFlow::Proxying.proxy_low_level_call_argument_list(
+          ProxyingFixture.instance_method(:log)).must_equal golden
+    end
+  end
+
+  describe '#proxy_sticky_fastpath_check' do
+    it 'works for an argument-less method' do
+      Police::DataFlow::Proxying.proxy_sticky_fastpath_check(
+          ProxyingFixture.instance_method(:length)).must_equal ''
+    end
+
+    it 'works for a one-argument method' do
+      golden =
+          'fast_sticky = (nil == arg1.__police_stickies__)'
+      Police::DataFlow::Proxying.proxy_sticky_fastpath_check(
+          ProxyingFixture.instance_method(:==)).must_equal golden
+    end
+
+    it 'works for a two-argument method' do
+      golden = 'fast_sticky = ' +
+          '(nil == arg1.__police_stickies__) && ' +
+          '(nil == arg2.__police_stickies__)'
+      Police::DataFlow::Proxying.proxy_sticky_fastpath_check(
+          ProxyingFixture.instance_method(:add)).must_equal golden
+    end
+
+    it 'works for a variable-argument method' do
+      golden = 'fast_sticky = (args.all? { |a| nil == a.__police_stickies__ })'
+      Police::DataFlow::Proxying.proxy_sticky_fastpath_check(
+          ProxyingFixture.instance_method(:route)).must_equal golden
+    end
+
+    it 'works for one fixed + variable-argument method' do
+      golden =
+          'fast_sticky = (nil == arg1.__police_stickies__) && ' +
+          '(args.all? { |a| nil == a.__police_stickies__ })'
+      Police::DataFlow::Proxying.proxy_sticky_fastpath_check(
+          ProxyingFixture.instance_method(:<=>)).must_equal golden
+    end
+
+    it 'works for two fixed + variable-argument method' do
+      golden =
+          'fast_sticky = (nil == arg1.__police_stickies__) && ' +
+          '(nil == arg2.__police_stickies__) && ' +
+          '(args.all? { |a| nil == a.__police_stickies__ })'
+      Police::DataFlow::Proxying.proxy_sticky_fastpath_check(
+          ProxyingFixture.instance_method(:log)).must_equal golden
+    end
+  end
+
+  describe '#proxy_sticky_gathering' do
+    it 'works for an argument-less method' do
+      Police::DataFlow::Proxying.proxy_sticky_gathering(
+          ProxyingFixture.instance_method(:length)).must_equal ''
+    end
+
+    it 'works for a one-argument method' do
+      golden = 'unless fast_sticky; sticky_labels = {}; ' +
+          'unless nil == arg1.__police_stickies__; ' +
+            '::Police::DataFlow::Labeling.merge_sets!(sticky_labels, ' +
+                'arg1.__police_stickies__); end; end'
+      Police::DataFlow::Proxying.proxy_sticky_gathering(
+          ProxyingFixture.instance_method(:==)).must_equal golden
+    end
+
+    it 'works for a two-argument method' do
+      golden = 'unless fast_sticky; sticky_labels = {}; ' +
+          'unless nil == arg1.__police_stickies__; ' +
+            '::Police::DataFlow::Labeling.merge_sets!(sticky_labels, ' +
+                'arg1.__police_stickies__); end; ' +
+          'unless nil == arg2.__police_stickies__; ' +
+            '::Police::DataFlow::Labeling.merge_sets!(sticky_labels, ' +
+                'arg2.__police_stickies__); end; end'
+
+      Police::DataFlow::Proxying.proxy_sticky_gathering(
+          ProxyingFixture.instance_method(:add)).must_equal golden
+    end
+
+    it 'works for a variable-argument method' do
+      golden = 'unless fast_sticky; sticky_labels = {}; ' +
+          'args.each do |a|; ' +
+            'unless nil == a.__police_stickies__; ' +
+              '::Police::DataFlow::Labeling.merge_sets!(sticky_labels, ' +
+                  'a.__police_stickies__); end; end; end'
+      Police::DataFlow::Proxying.proxy_sticky_gathering(
+          ProxyingFixture.instance_method(:route)).must_equal golden
+    end
+
+    it 'works for one fixed + variable-argument method' do
+      golden = 'unless fast_sticky; sticky_labels = {}; ' +
+          'unless nil == arg1.__police_stickies__; ' +
+            '::Police::DataFlow::Labeling.merge_sets!(sticky_labels, ' +
+                'arg1.__police_stickies__); end; ' +
+          'args.each do |a|; ' +
+            'unless nil == a.__police_stickies__; ' +
+              '::Police::DataFlow::Labeling.merge_sets!(sticky_labels, ' +
+                  'a.__police_stickies__); end; end; end'
+      Police::DataFlow::Proxying.proxy_sticky_gathering(
+          ProxyingFixture.instance_method(:<=>)).must_equal golden
+    end
+
+    it 'works for two fixed + variable-argument method' do
+      golden = 'unless fast_sticky; sticky_labels = {}; ' +
+          'unless nil == arg1.__police_stickies__; ' +
+            '::Police::DataFlow::Labeling.merge_sets!(sticky_labels, ' +
+                'arg1.__police_stickies__); end; ' +
+          'unless nil == arg2.__police_stickies__; ' +
+            '::Police::DataFlow::Labeling.merge_sets!(sticky_labels, ' +
+                'arg2.__police_stickies__); end; ' +
+          'args.each do |a|; ' +
+            'unless nil == a.__police_stickies__; ' +
+              '::Police::DataFlow::Labeling.merge_sets!(sticky_labels, ' +
+                  'a.__police_stickies__); end; end; end'
+      Police::DataFlow::Proxying.proxy_sticky_gathering(
+          ProxyingFixture.instance_method(:log)).must_equal golden
+    end
+  end
+
+  describe '#proxy_yield_sticky_decorating' do
+    it 'works for an argument-less method' do
+      Police::DataFlow::Proxying.proxy_yield_sticky_decorating(
+          ProxyingFixture.instance_method(:length)).must_equal ''
+    end
+
+    it 'works for a one-argument method' do
+      golden = 'unless fast_sticky; yield_args.map! do |a|; ' +
+          '::Police::DataFlow::Labeling.bulk_sticky_label(' +
+              'a, sticky_labels); end; end'
+      Police::DataFlow::Proxying.proxy_yield_sticky_decorating(
+          ProxyingFixture.instance_method(:==)).must_equal golden
+    end
+  end
+
+  describe '#proxy_return_sticky_decorating' do
+    it 'works for an argument-less method' do
+      Police::DataFlow::Proxying.proxy_return_sticky_decorating(
+          ProxyingFixture.instance_method(:length)).must_equal ''
+    end
+
+    it 'works for a one-argument method' do
+      golden = 'unless fast_sticky; return_value = ' +
+          '::Police::DataFlow::Labeling.bulk_sticky_label(' +
+              'return_value, sticky_labels); end'
+      Police::DataFlow::Proxying.proxy_return_sticky_decorating(
+          ProxyingFixture.instance_method(:==)).must_equal golden
+    end
+  end
 end