private_please 0.0.5 → 0.1.0

data/lib/private_please/storage/methods_names_bucket.rb

@@ -1,69 +0,0 @@
-# Associates and indexes classes (name) and some of their methods (names).
-# Ex:
-#   +-------------+---------------------------------------+
-#   | class name  => 1+ methods names                     |
-#   +-------------+---------------------------------------+
-#   |    'Foo'    | MethodsNames.new('foo to_baz to_bar') |
-#   |    'Bar'    | MethodsNames.new('qux')               |
-#   +-------------+---------------------------------------+
-
-module PrivatePlease
-  module Storage
-
-    class MethodsNamesBucket < Hash
-
-      def initialize
-        super{|hash, class_name|
-          #hash[class_name] = PrivatePlease::Storage::MethodsNames.new
-          hash.set_methods_names(class_name, MethodsNames.new)
-        }
-      end
-
-      def clone
-        (self.class).new.tap do |klone|
-          classes_names.each do |class_name|
-            klone.set_methods_names(class_name, (self).get_methods_names(class_name))
-          end
-        end
-      end
-
-    #--------------------------------------------------------------------------
-    # QUERIES:
-    #--------------------------------------------------------------------------
-
-      alias_method :classes_names,     :keys
-      alias_method :get_methods_names, :[]
-      # undef :[], :keys    # should be undef-ed, but that complexifies the test    #TODO : undef :[], :keys
-                            # ( => must define ==(other) and cast type of 'other')
-
-    #--------------------------------------------------------------------------
-    # COMMANDS:
-    #--------------------------------------------------------------------------
-
-      alias_method :set_methods_names, :[]=
-      undef :[]=
-
-      def add_method_name(class_name, method_name)
-        self.get_methods_names(class_name).add(method_name)
-      end
-
-      def remove(other)
-        other.classes_names.each do |cn|
-          next if (methods_to_remove = other.get_methods_names(cn)).empty?
-          next if (methods_before    = self .get_methods_names(cn)).empty?
-          difference = methods_before - methods_to_remove
-          self.set_methods_names(cn, difference)
-        end
-        prune!
-        self
-      end
-
-    private
-
-      def prune!
-        self.reject!{|_, v|v.empty?}
-      end
-    end
-
-  end
-end

data/lib/private_please/storage.rb

@@ -1,8 +0,0 @@
-module PrivatePlease
-  module Storage
-  end
-end
-require File.dirname(__FILE__) + '/storage/calls_store'
-require File.dirname(__FILE__) + '/storage/candidates_store'
-require File.dirname(__FILE__) + '/storage/methods_names'
-require File.dirname(__FILE__) + '/storage/methods_names_bucket'

data/lib/private_please/tracking/extension.rb

@@ -1,12 +0,0 @@
-module PrivatePlease ; module Tracking
-
-  module Extension
-
-    def private_please
-      include PrivatePlease::Tracking::InstrumentsAllMethodsBelow
-      set_trace_func PrivatePlease::Tracking::LineChangeTracker::MY_TRACE_FUN
-    end
-
-  end
-
-end end

data/lib/private_please/tracking/instrumentor.rb

@@ -1,49 +0,0 @@
-module PrivatePlease ; module Tracking
-
-  module Instrumentor
-  class << self
-
-    def add_call_tracking_code_to(candidate)
-      return if candidate.already_instrumented?
-      candidate.mark_as_instrumented
-
-      klass, method_name = candidate.klass, candidate.method_name
-      candidate.instance_method? ?
-        add_call_tracking_code_to_instance_method(klass, method_name) :
-        add_call_tracking_code_to_class_method(   klass, method_name)
-    end
-
-
-  private
-
-    def add_call_tracking_code_to_class_method(klass, method_name)
-      orig_method = klass.singleton_class.instance_method(method_name)
-klass.class_eval <<RUBY
-      define_singleton_method(method_name) do |*args, &blk|                 # def self.observed_method_i(..)
-        set_trace_func(nil) #don't track activity while here                #
-        PrivatePlease::Tracking.after_singleton_method_call(method_name, self_class=self)
-        set_trace_func(LineChangeTracker::MY_TRACE_FUN)                     #
-        # make the original call :                                          #
-        orig_method.bind(self).call(*args, &blk)                            #   <call original method>
-      end                                                                   # end
-RUBY
-    end
-
-
-    def add_call_tracking_code_to_instance_method(klass, method_name)
-      orig_method = klass.instance_method(method_name)
-klass.class_eval <<RUBY
-      define_method(method_name) do |*args, &blk|                           # def observed_method_i(..)
-        set_trace_func(nil) #don't track activity while here                #
-        PrivatePlease::Tracking.after_instance_method_call(method_name, self.class)
-        set_trace_func(LineChangeTracker::MY_TRACE_FUN)                     #
-        # make the original call :                                          #
-        orig_method.bind(self).call(*args, &blk)                            #   <call original method>
-      end                                                                   # end
-RUBY
-    end
-
-  end
-  end
-
-end end

data/lib/private_please/tracking/instruments_all_methods_below.rb

@@ -1,28 +0,0 @@
-module PrivatePlease ; module Tracking
-
-  module InstrumentsAllMethodsBelow
-    include PrivatePlease::Tracking::Extension
-
-    def self.included(base)
-
-      def base.singleton_method_added(method_name)
-        return if Utils.private_singleton_method?(self, method_name) \
-               || Utils.singleton_method_defined_by_ancestor?(self, method_name)
-
-        candidate = Candidate.for_class_method(klass = self, method_name)
-        Instrumentor.add_call_tracking_code_to(candidate)
-      end
-
-
-      def base.method_added(method_name)
-        return if Utils.private_instance_method?(self, method_name) \
-               || Utils.instance_method_defined_by_ancestor?(self, method_name)
-
-        candidate = Candidate.for_instance_method(klass = self, method_name)
-        Instrumentor.add_call_tracking_code_to(candidate)
-      end
-    end
-
-  end
-
-end end

data/lib/private_please/tracking/instruments_automatically_all_methods_in_all_classes.rb

@@ -1,68 +0,0 @@
-module Kernel
-
-  alias_method :_orig_require, :require
-
-  def require string
-    prev_val = PrivatePlease.pp_automatic_mode_enabled?
-    if PrivatePlease::Tracking::LoadUtils.standard_lib_or_gem?(string)
-      PrivatePlease.pp_automatic_mode_disable
-    end
-
-    send :_orig_require, string
-
-    PrivatePlease.pp_automatic_mode_enable(prev_val)
-  end
-
-end
-
-class Class
-
-  def singleton_method_added(method_name)
-    return unless PrivatePlease.pp_automatic_mode_enabled?
-
-    return if PrivatePlease::Tracking::Utils.private_singleton_method?(self, method_name) \
-           || PrivatePlease::Tracking::Utils.singleton_method_defined_by_ancestor?(self, method_name)
-
-    candidate = PrivatePlease::Candidate.for_class_method(klass = self, method_name)
-    PrivatePlease::Tracking::Instrumentor.add_call_tracking_code_to(candidate)
-  end
-
-
-  def method_added(method_name)
-    return unless PrivatePlease.pp_automatic_mode_enabled?
-
-    return if [:method_added].include?(method_name)
-    return if PrivatePlease::Tracking::Utils.private_instance_method?(self, method_name) \
-           || PrivatePlease::Tracking::Utils.instance_method_defined_by_ancestor?(self, method_name)
-
-    candidate = PrivatePlease::Candidate.for_instance_method(klass = self, method_name)
-    PrivatePlease::Tracking::Instrumentor.add_call_tracking_code_to(candidate)
-  end
-
-end
-
-
-class Module
-
-  def singleton_method_added(method_name)
-    return unless PrivatePlease.pp_automatic_mode_enabled?
-
-    return if [:included].include?(method_name) #&& !self.is_a?(Class)
-    return if PrivatePlease::Tracking::Utils.private_singleton_method?(self, method_name)
-
-    candidate = PrivatePlease::Candidate.for_class_method(klass = self, method_name)
-    PrivatePlease::Tracking::Instrumentor.add_call_tracking_code_to(candidate)
-  end
-
-
-  def method_added(method_name)
-    return unless PrivatePlease.pp_automatic_mode_enabled?
-
-    return if [:method_added, :singleton_method_added].include?(method_name)
-    return if PrivatePlease::Tracking::Utils.private_instance_method?(self, method_name)
-
-    candidate = PrivatePlease::Candidate.for_instance_method(klass = self, method_name)
-    PrivatePlease::Tracking::Instrumentor.add_call_tracking_code_to(candidate)
-  end
-end
-

data/lib/private_please/tracking/line_change_tracker.rb

@@ -1,26 +0,0 @@
-module PrivatePlease ; module Tracking
-
-  class LineChangeTracker
-    class << self
-
-      attr_accessor :prev_prev_self, :prev_self, :curr_self
-      @@prev_self = @@curr_self = nil
-
-      alias :call_initiator :prev_self
-
-      def reset
-        prev_prev_self = prev_self = curr_self = nil
-      end
-    end
-
-    MY_TRACE_FUN = lambda do |event, file, line, id, binding, klass|
-      return unless 'line'==event
-      LineChangeTracker.prev_prev_self = LineChangeTracker.prev_self
-      LineChangeTracker.prev_self      = LineChangeTracker.curr_self
-      LineChangeTracker.curr_self      = (eval 'self', binding)
-      #puts "my : #{event} in #{file}/#{line} id:#{id} klass:#{klass} - self = #{(eval'self', binding).inspect}"
-    end
-
-  end
-
-end end

data/lib/private_please/tracking/load_utils/gem_utils.rb

@@ -1,49 +0,0 @@
-# OPTIMISATION :
-#     Calls to `$ gem ..` are slow (esp. on jruby!)
-#     => we 1/ pre-perform them asynchronously (Threads) when this file is loaded,
-#           2/ cache the obtained value in a variable,
-#           3/ rewrite the slow method as a noop version that simply returns the cached value.
-
-module PrivatePlease::Tracking::LoadUtils
-
-  module GemUtils
-
-    class << self
-
-      # performs `$ gem env`
-      #
-      def gem_env
-        GEM_ENV_PRELOADER.join
-        gem_env     # call the fast/just rewritten version
-      end
-
-      # performs `$ gem list` + extracts the names
-      #
-      def gems_names
-        GEMS_NAMES_PRELOADER.join
-        gems_names
-      end
-
-    #-------------------------------------------------------------------------------------------------------------------
-    private
-
-      GEM_ENV_PRELOADER = Thread.new do
-        @@_cached_gem_env = `gem env`
-        def GemUtils.gem_env
-          @@_cached_gem_env
-        end
-      end
-
-      GEMS_NAMES_PRELOADER = Thread.new do
-        @@_cached_gems_names = `gem list`.  # very slow on jruby
-            split("\n").
-            map { |l| l.match(/(\S+)\s+.*/)[1]}                # ["bundle", "bundler", "rspec", ..]
-        def GemUtils.gems_names
-          @@_cached_gems_names
-        end
-      end
-
-    end
-  end
-
-end

data/lib/private_please/tracking/load_utils/standard_lib_utils.rb

@@ -1,38 +0,0 @@
-module PrivatePlease::Tracking::LoadUtils
-
-  module StandardLibUtils
-
-    class << self
-
-      def standard_lib?(requiree)
-        path_base   =  "#{std_lib_home}/#{requiree}"
-        if File.exists?(path_base)
-          path_base
-        elsif File.exists?("#{path_base}.rb")
-          "#{path_base}.rb"
-        end
-      end
-
-    #-------------------------------------------------------------------------------------------------------------------
-    private
-
-      # Ex:  "/Users/ara/.rbenv/versions/jruby-1.7.3/bin/jruby"
-      def ruby_executable
-        @@_ruby_executable ||= GemUtils.gem_env.match(/RUBY EXECUTABLE:\s*(.*)/)[1]
-      end
-
-      # Ex: "/Users/ara/.rbenv/versions/jruby-1.7.3/lib/ruby/1.9"
-      def std_lib_home
-        @@_std_lib_home ||= begin
-          basedir      = ruby_executable.gsub(/bin\/[j]?ruby/, 'lib/ruby') # => "/Users/ara/.rbenv/versions/jruby-1.7.3/lib/ruby"
-                                                  # jruby has 2+ directories of std. libs under the basedir : 1.8 and 1.9
-          $:.detect {|path|                       # We choose the one that is also in the load path.
-            path =~ /#{basedir}\/[12][^\/]+$/     #
-          }                                       # => "/Users/ara/.rbenv/versions/jruby-1.7.3/lib/ruby/1.9"
-        end                                       #                                                     ^^^ == the mode
-      end
-
-    end
-  end
-
-end

data/lib/private_please/tracking/load_utils.rb

@@ -1,32 +0,0 @@
-module PrivatePlease::Tracking
-
-  module LoadUtils
-    require File.dirname(__FILE__) + '/load_utils/gem_utils'
-    require File.dirname(__FILE__) + '/load_utils/standard_lib_utils'
-
-    class << self
-
-      def standard_lib_or_gem?(requiree)
-        (@@_standard_lib_or_gem ||= {})[requiree] ||= begin
-          standard_lib?(requiree) || gem?(requiree)
-        end
-      end
-
-      def standard_lib?(requiree)
-        (@@_standard_lib ||= {})[requiree] ||= StandardLibUtils.standard_lib?(requiree)
-      end
-
-      def gem?(requiree)
-        (@@_gems ||= {})[requiree] ||= begin
-          base_name = requiree.include?('/') ?
-              requiree.split('/').first :      #  ex:   require 'rspec/autorun'
-              requiree                         #  ex:   require 'rspec'
-          GemUtils.gems_names.include?(base_name)
-        end
-
-      end
-
-    end
-  end
-
-end

data/lib/private_please/tracking/utils.rb

@@ -1,34 +0,0 @@
-module PrivatePlease::Tracking
-
-  module Utils
-    class << self
-
-      def private_instance_method?(klass, method_name)
-        klass.private_method_defined?(method_name)
-      end
-
-      def private_singleton_method?(klass, method_name)
-        klass.singleton_class.private_method_defined?(method_name)
-      end
-
-      def instance_method_defined_by_ancestor?(klass, method_name)
-        ancestor_of(klass).any? do |a|
-          a.method_defined?(method_name) || a.private_method_defined?(method_name)
-        end
-      end
-
-      def singleton_method_defined_by_ancestor?(klass, method_name)
-        ancestor_of(klass).any? do |a|
-          a.singleton_class.method_defined?(method_name) || a.singleton_class.private_method_defined?(method_name)
-        end
-      end
-
-    private
-      def ancestor_of(klass)
-        klass.ancestors - [klass]
-      end
-
-    end
-  end
-
-end

data/lib/private_please/tracking.rb

@@ -1,49 +0,0 @@
-require 'private_please/tracking/line_change_tracker'
-module PrivatePlease
-  module Tracking
-
-    class << self
-
-      def after_instance_method_call(method_name, zelf_class)
-        store_call_to_tracked_method(
-          candidate       = PrivatePlease::Candidate.for_instance_method(zelf_class, method_name),
-          is_outside_call = (caller_class != zelf_class)
-        )
-      end
-
-      def after_singleton_method_call(method_name, zelf_class)
-        store_call_to_tracked_method(
-          candidate       = PrivatePlease::Candidate.for_class_method(zelf_class, method_name),
-          is_outside_call = (caller_class != zelf_class)
-        )
-      end
-
-    private
-
-      def caller_class
-        call_initiator = LineChangeTracker.call_initiator
-        if call_initiator.nil?
-          #TODO : investigate why and how this happens
-        end
-        (caller_is_class_method = call_initiator.is_a?(Class)) ?
-            call_initiator :
-            call_initiator.class
-      end
-
-      def store_call_to_tracked_method(candidate, is_outside_call)
-        is_outside_call ?
-            PrivatePlease.calls_store.store_outside_call(candidate) :
-            PrivatePlease.calls_store.store_inside_call( candidate)
-      end
-
-    end
-
-  end
-end
-
-require 'private_please/tracking/utils'
-require 'private_please/tracking/load_utils'
-require 'private_please/tracking/instrumentor'
-require 'private_please/tracking/extension'
-require 'private_please/tracking/instruments_all_methods_below'
-require 'private_please/tracking/instruments_automatically_all_methods_in_all_classes'