private_please 0.0.3 → 0.0.4

data/spec/{01_marking_candidate_methods_to_observe_spec.rb → 01_tracking_candidate_methods/explicitely_with_the_private_please_command_spec.rb}

@@ -1,60 +1,12 @@
 require 'spec_helper'
 
-describe PrivatePlease, 'collecting the details of candidate-methods to observe' do
+describe PrivatePlease, 'collecting the details of selected candidate-methods to observe' do
   module MarkingTest; end
 
   let(:candidates_store) { PrivatePlease.storage }
 
 # ----------------
-  context 'observing with `private_please(<method names>)`' do
-# ----------------
-
-    it('stores the instance methods names in the candidates list, indexed by their owning class') do
-      class MarkingTest::Simple1
-        def foo ; 'foo' end
-        def bar ; 'bar' end
-        def buz ; 'bar' end
-        private_please  :bar, 'buz'    # <<-- what we test
-      end
-
-      assert_instance_methods_candidates 'MarkingTest::Simple1' =>[:bar, :buz]
-    end
-
-
-    it('does not work with class methods') do
-      class MarkingTest::Simple1b
-        def self.found ; 'I am a class method' end
-        private_please  :found    # <<-- class method => not observed
-      end
-
-      assert_instance_methods_candidates ({})
-      assert_class_methods_candidates    ({})
-    end
-
-    it('ignores invalid candidates (method not found in the class)') do
-      class MarkingTest::Simple2
-        def found ; 'foo' end
-        private_please  :found             # <<-- valid
-        private_please  :not_found_method  # <<-- not found => INvalid
-      end
-
-      assert_instance_methods_candidates 'MarkingTest::Simple2' =>[:found]
-    end
-
-    it('ignores duplicates') do
-      class MarkingTest::Simple3
-        def found ; 'foo' end
-        private_please  :found             #
-        private_please  :found             # duplicate -> ignore
-      end
-
-      assert_instance_methods_candidates 'MarkingTest::Simple3' =>[:found]
-    end
-  end
-
-
-# ----------------
-  context 'observing with `private_please()`' do
+  context 'observing with `private_please`' do
 # ----------------
 
     example 'all the instance methods defined after `private_please` are stored as candidates' do
@@ -79,11 +31,10 @@ describe PrivatePlease, 'collecting the details of candidate-methods to observe'
         def self.baz ; end       #    YES
       public                     #    *
         def self.qux ; end       #    YES
-        def self.included ; end  #    * special name, but valid candidate (in classes).
       end
 
       assert_instance_methods_candidates ({})
-      assert_class_methods_candidates    'MarkingTest::Automatic1b' =>[:baz, :qux, :included]
+      assert_class_methods_candidates    'MarkingTest::Automatic1b' =>[:baz, :qux]
     end
 
     example ('already private methods are ignored/not observed') do
@@ -106,8 +57,6 @@ describe PrivatePlease, 'collecting the details of candidate-methods to observe'
 
 
     example 'method coming from an included module are observed too' do
-#TODO : find a better way to instrument modules
-#TODO : find a way to instrument modules automatically (? possible)
 
       module Extra002               ; private_please end  # <<=== Pre-instrument.
       module Extra002::ClassMethods ; private_please end  # <<=== Pre-instrument.
@@ -118,7 +67,7 @@ describe PrivatePlease, 'collecting the details of candidate-methods to observe'
           base.extend ClassMethods                        #
         end                                               #
         module ClassMethods                               #
-          def cm_from_modulex ; end                        #
+          def cm_from_module ; end                        #
         end                                               #
       end                                                 #
       assert_instance_methods_candidates 'Extra002'                 =>[:im_from_module],
@@ -127,27 +76,43 @@ describe PrivatePlease, 'collecting the details of candidate-methods to observe'
     end
   end
 
-
 # ----------------
-  context 'observing with `include PrivatePlease::Tracking::InstrumentsAllBelow`' do
+  describe 'overridden methods are not tracked' do
 # ----------------
+    module ExplOverridingTest ; end
+    
+    example 'overridden methods are NOT marked as candidate' do
+      module ExplOverridingTest::UserClasses
+        class Base                    #  
+          def base_foo        ; end   #
+          def self.c_base_foo ; end   #
+        private_please                # <start tracking>
+          def base_t_bar        ; end # is tracked
+          def self.c_base_t_bar ; end # is tracked
+        private
+          def base_priv         ; end # private => not tracked
+        end
 
-    example 'all the methods defined subsequently are stored as candidates' do
-
-      class MarkingTest::Automatic2
-        def foo ; end
-        def bar ; end
-        include PrivatePlease::Tracking::InstrumentsAllBelow # ---> # <start observing>
-        def baz ; end                          #    YES
-        def self.class_m1; end                 #    YES
-      protected                                #
-        def qux ; end                          #    YES
+        class Overrider < Base
+        private_please                  # <start tracking>
+          def base_priv         ; end   # overriding a private method => not tracked
+          def base_yes          ; end   # new -> tracked
+          def self.c_base_yes   ; end   # new -> tracked
+        
+          def base_foo          ; end   # NOT tracked
+          def base_t_bar        ; end   # NOT tracked
+          def self.c_base_foo   ; end   # NOT tracked
+          def self.c_base_t_bar ; end   # NOT tracked
+          
+          def to_s              ; end   # NOT tracked
+        end
       end
 
-      assert_instance_methods_candidates 'MarkingTest::Automatic2' =>[:baz, :qux]
-      assert_class_methods_candidates    'MarkingTest::Automatic2' =>[:class_m1]
+      assert_instance_methods_candidates 'ExplOverridingTest::UserClasses::Base'      => [:base_t_bar],
+                                         'ExplOverridingTest::UserClasses::Overrider' => [:base_yes]
+      assert_class_methods_candidates    'ExplOverridingTest::UserClasses::Base'      => [:c_base_t_bar],
+                                         'ExplOverridingTest::UserClasses::Overrider' => [:c_base_yes]
     end
-
   end
 
 end

data/spec/01_tracking_candidate_methods/systematically_in_auto_mode_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe PrivatePlease, 'in $automatic mode, all the methods are tracked for observation by PP' do
+
+  before { PrivatePlease.pp_automatic_mode_enable }
+  after  { PrivatePlease.pp_automatic_mode_disable}
+
+  let(:candidates_store) { PrivatePlease.storage }
+
+# ----------------
+  context 'in a flat class,' do  # simple class; no module nor inheritance
+# ----------------
+    module AutFlatClass; end
+
+    example 'instance and singleton methods are tracked' do
+      class AutFlatClass::Case1
+        def foo      ; end     #
+        def baz      ; end     #
+        def self.foo ; end     #
+        def self.baz ; end     #
+      end
+
+      assert_instance_methods_candidates    'AutFlatClass::Case1' => [:baz, :foo]
+      assert_singleton_methods_candidates   'AutFlatClass::Case1' => [:baz, :foo]
+    end
+
+
+    example '.included and #included are 2 methods we track in classes.' do
+      class AutFlatClass::Case2
+        def foo           ; end     #
+
+        def self.baz      ; end     # 
+      end
+
+      assert_instance_methods_candidates    'AutFlatClass::Case2' => [:foo]
+      assert_singleton_methods_candidates   'AutFlatClass::Case2' => [:baz]
+    end
+
+
+    example 'already private methods are not tracked' do
+      class AutFlatClass::Case3
+        def foo       ; end                 #    YES
+        def self.baz  ; end                 #    YES
+      private
+        def already_private         ; end   #    NO
+        class << self
+        private
+          def class_already_private ; end   #    NO
+        end
+      end
+
+      assert_instance_methods_candidates    'AutFlatClass::Case3' => [:foo]
+      assert_singleton_methods_candidates   'AutFlatClass::Case3' => [:baz]
+    end
+
+    example 'metaprograpping-related Class methods are not tracked' do
+      class AutFlatClass::Case4
+        def singleton_method_added(_) ; end #    NO
+        def method_added(          _) ; end #    NO
+      end
+
+      assert_instance_methods_candidates    ({})
+      assert_singleton_methods_candidates   ({})
+    end
+  end
+
+# ----------------
+  context 'in a flat module,' do  # no inheritance
+# ----------------
+    module AutFlatModule; end
+
+    example 'instance and singleton methods are tracked' do
+      module AutFlatModule::Case1
+        def foo      ; end     #
+        def self.baz ; end     #
+      end
+
+      assert_instance_methods_candidates    'AutFlatModule::Case1' => [:foo]
+      assert_singleton_methods_candidates   'AutFlatModule::Case1' => [:baz]
+    end
+
+    example 'we track #included but not .included' do
+      module AutFlatModule::Case2
+        def foo           ; end     #
+        def included      ; end     # : not a special name in classes
+
+        def self.baz      ; end     # 
+        def self.included ; end     # : not a special name in classes
+      end
+
+      assert_instance_methods_candidates    'AutFlatModule::Case2' => [:foo, :included]
+      assert_singleton_methods_candidates   'AutFlatModule::Case2' => [:baz]
+    end
+
+
+    example 'already private methods are not tracked' do
+      module AutFlatModule::Case3
+      private
+        def already_private         ; end   #    NO
+        class << self
+        private
+          def class_already_private ; end   #    NO
+        end
+      end
+
+      assert_instance_methods_candidates    ({})
+      assert_singleton_methods_candidates   ({})
+    end
+
+    example 'metaprograpping-related Module methods are not tracked' do
+      module AutFlatModule::Case4
+        def singleton_method_added(_) ; end #    NO
+        def method_added(          _) ; end #    NO
+        def self.included(base)       ; end #    NO
+      end
+
+      assert_instance_methods_candidates    ({})
+      assert_singleton_methods_candidates   ({})
+    end
+
+  end
+
+
+# ----------------
+  context '1 class including 1 module' do
+# ----------------
+    module IncludedModule ; end
+    
+    example 'the tracked module methods are associated to the module, not the class(es) that includes the module' do
+      module IncludedModule
+        module Module1                    #
+          def im_from_module ; end        # YES
+          def self.included(base)         # NO
+            base.extend ClassMethods      #
+          end                             #
+          module ClassMethods             #
+            def cm_from_module ; end      # YES
+          end                             #
+        end                               #
+        class Case1
+          include Module1                 # NO methods are associated to this class. 
+        end
+      end
+      
+      assert_instance_methods_candidates 'IncludedModule::Module1'                  =>[:im_from_module],
+                                         'IncludedModule::Module1::ClassMethods'    =>[:cm_from_module]
+      assert_singleton_methods_candidates    ({})
+    end
+
+  end
+
+
+# ----------------
+  describe 'overridden methods are not tracked in classes' do
+# ----------------
+    module ImplOverridingTest ; end
+    
+    example 'overridden methods are NOT marked as candidate' do
+      module ImplOverridingTest
+        class Base  
+          def base_t_foo        ; end # is tracked
+          def self.c_base_t_foo ; end # is tracked
+        private
+          def base_priv         ; end # private => not tracked
+        end
+
+        class Overrider < Base
+          def base_priv         ; end   # overriding a private method => not tracked
+          def base_yes          ; end   # new -> tracked
+          def self.c_base_yes   ; end   # new -> tracked
+        
+          def base_t_foo        ; end   # NOT tracked
+          def self.c_base_t_foo ; end   # NOT tracked
+          
+          def to_s              ; end   # NOT tracked
+        end
+      end
+
+      assert_instance_methods_candidates 'ImplOverridingTest::Base'      => [:base_t_foo],
+                                         'ImplOverridingTest::Overrider' => [:base_yes]
+      assert_class_methods_candidates    'ImplOverridingTest::Base'      => [:c_base_t_foo],
+                                         'ImplOverridingTest::Overrider' => [:c_base_yes]
+    end
+  end
+
+
+end

data/spec/{02_logging_calls_on_candidate_methods_spec.rb → 03_logging_calls_on_candidate_methods_spec.rb}

@@ -4,12 +4,10 @@ describe PrivatePlease, 'calling observed methods and logging calls in 2 categor
 
   before do
 #-----------------------------------------------------------------------------------------------------------------------
-    require File.dirname(__FILE__) + '/fixtures/sample_class_with_all_calls_combinations'
+    load File.dirname(__FILE__) + '/fixtures/sample_class_with_all_calls_combinations.rb'
 #-----------------------------------------------------------------------------------------------------------------------
   end
-
-
-  NO_CALLS_OBSERVED = {}
+  after { Object.send(:remove_const, :CallsSample) }
 
   example ('pure internal calls are categorized correctly') do
     CallsSample::Simple.new.make_internal_calls

data/spec/04_instrumented_program_activity_observation_result_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'PrivatePlease.report', 'observing an instrumented program activity' do
+describe 'PrivatePlease.reporter', 'observing an instrumented program activity' do
 
   def run_the_instrumented_program
     ActivityTest::Simple.new.tap do |o|
@@ -49,7 +49,7 @@ describe 'PrivatePlease.report', 'observing an instrumented program activity' do
   # Note: test all in 1 go because testing in bits would fail, and it differs from real usage.
   it 'obtains the right info by observing the program activity' do
     run_the_instrumented_program
-    the_report = PrivatePlease.report
+    the_report = PrivatePlease::Reporter::SimpleText.new(PrivatePlease.candidates_store, PrivatePlease.calls_store)
     {
         :good_candidates  => the_report.good_candidates,
         :good_candidates_c => the_report.good_candidates_c,
@@ -81,9 +81,6 @@ describe 'PrivatePlease.report', 'observing an instrumented program activity' do
             'ActivityTest::Simple2'  =>  mnames_for([:ignored_c3])
         }
     }
-    puts the_report.to_s
-    puts "\n***report building time : #{the_report.building_time} sec."
-
   end
 
 end

data/spec/05_reporting/report_table_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe PrivatePlease::Report::Table do
+  let(:col_1) { %w(a b c) }
+  let(:col_2) { %w(X Y Z) }
+
+  def table(col_1, col_2)
+    PrivatePlease::Report::Table.new(col_1, col_2)    
+  end
+#------------------------------------------------------------------------------
+  
+  it 'wraps 2 columns of data' do
+    t = table(col_1, col_2)
+    t.col_1.should == col_1
+    t.col_2.should == col_2
+  end
+
+  it 'pads with nil whichever column is shorter' do
+    table(['1'], %w(a b c)).tap do |t|
+      t.col_1.should == ['1', nil, nil]
+      t.col_2.should == %w(a b c)
+    end
+    table(%w(a b c), ['1']).tap do |t|
+      t.col_1.should == %w(a b c)
+      t.col_2.should == ['1', nil, nil]
+    end
+    
+  end  
+
+  example '#rows returns an array of [String, String]' do
+    t = table(['1', '2'], col_2)
+    t.rows.should == [
+        ['1', 'X'],
+        ['2', 'Y'],
+        [nil, 'Z'],
+    ]
+  end
+
+  example '#empty?' do
+    table(['1', '2'], []).should_not be_empty    
+    table([], ['1', '2']).should_not be_empty    
+    table([], []        ).should     be_empty    
+  end
+
+  example '#longest_value_length' do
+    table(['a', '12345'], ['b', 'c']).longest_value_length.should == '12345'.length     
+    table(['b'], ['a', '12345']     ).longest_value_length.should == '12345'.length     
+    table([], []                    ).longest_value_length.should == 0     
+  end
+  
+end

data/spec/06_at_exit_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'at_exit() behaviour' do
+  
+  it 'prints the PP simpletext report to $stdout (when not in test mode)' do
+    $private_please_tests_are_running = false
+    PrivatePlease::Reporter::SimpleText.stub(:new => stub(:text => '<the-report-text>'))
+    $stdout.
+        should_receive(:puts).
+        with('<the-report-text>')
+    begin
+      PrivatePlease.at_exit
+    ensure
+      $private_please_tests_are_running = true
+    end
+  end
+
+end

data/spec/fixtures/bug_22.rb

@@ -0,0 +1,17 @@
+load File.expand_path File.dirname(__FILE__) + '/../../doc/fixtures/fixture_helper.rb'
+
+module Extra
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  module ClassMethods
+    def a_class_method_via_module_Extra ; end
+  end
+end
+
+
+class Simple
+  include Extra
+end
+Simple.a_class_method_via_module_Extra
+

data/spec/fixtures/sample_class_for_report.rb

@@ -1,3 +1,5 @@
+require 'private_please'
+
 module ReportSample
                                                 ###########################################
   class Simple                                  # Internal calls :                        #

data/spec/sandbox/Gemfile

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gem 'private_please', :path => '../..'

data/spec/sandbox/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: ../..
+  specs:
+    private_please (0.0.4rc)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  private_please!

data/spec/sandbox/README.txt

@@ -0,0 +1,26 @@
+To inspect the program 
+    normal.rb 
+with PrivatePlease, launch it one of these ways :
+
+  $ ruby -rubygems   -e "require 'private_please' ; load 'normal.rb'"
+or
+  $ bundle exec ruby -e "require 'private_please' ; load 'normal.rb'"
+
+You can also insert the     
+   require 'private_please'
+code in the program itself. (see normal_prepended_with_require.rb, line 3)
+
+
+  ruby normal.rb
+->
+  ruby -rubygems -e "require 'private_please' ; load 'normal.rb'"
+  ruby -rubygems simple_with_require.rb
+  
+
+  be ruby normal.rb
+->
+  be ruby -e "require 'private_please' ; load 'normal.rb'"
+  be ruby simple_with_require.rb
+
+
+

data/spec/sandbox/normal.rb

@@ -0,0 +1,7 @@
+puts 'opened: ' + __FILE__
+
+class Foo
+  def self.entry_point; new.entry_point end 
+  def entry_point; end 
+end
+Foo.entry_point

data/spec/sandbox/normal_prepended_with_require.rb

@@ -0,0 +1,8 @@
+puts 'opened: ' + __FILE__
+
+require 'private_please'
+class Foo
+  def self.entry_point; foo ; end 
+  def self.foo; end 
+end
+Foo.entry_point

data/spec/spec_helper.rb

@@ -32,7 +32,7 @@ def assert_class_methods_candidates(raw_expected)
   expected = raw_expected.to_methods_names_bucket if raw_expected.is_a?(Hash)
   PrivatePlease.candidates_store.class_methods.should == expected
 end
-
+alias :assert_singleton_methods_candidates :assert_class_methods_candidates
 
 
 def assert_calls_detected(expected)
@@ -67,8 +67,12 @@ RSpec.configure do |config|
   config.order = 'random'
 
   config.before(:each) do
-    PrivatePlease.reset_before_new_test
+    PrivatePlease.reset
+    PrivatePlease.pp_automatic_mode_disable
   end
 end
 
 require File.dirname(__FILE__) + '/../lib/private_please'
+PrivatePlease.pp_automatic_mode_disable
+
+$private_please_tests_are_running = true