nil-passer 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6d055dc32bd54aaaaf42bcd4855ed0495a66d90
-  data.tar.gz: a6ebb173920fb8932ea10737597b3a2929c5d5c9
+  metadata.gz: 7d414f7dcb6b414d6ee0187856bbdd4c6c7a5fb2
+  data.tar.gz: e3267e649eba8323f21ee0d98afbae30706337c1
 SHA512:
-  metadata.gz: b8ebd1d43e856966534755ad0b52bd31a037db688039c36da80ae9297a856d9a0c24d03b038ae7690ede4b71ea40118bdabbd78aacd752bfeec2185c68448be1
-  data.tar.gz: 25842a53a205c36958d3460d264f6e657904c7766a92cd494918fff89009af9860116cafb1fe981841e2807dfc43e4d642473df16012483781194fa9ef60caa5
+  metadata.gz: 6407a8c15abdd083f7f1bb12bb0467d091838c950d6a44289568714ed0f2c442d22080d8d91bcb6ed64049586d4b77dc0e7b0e999e24acaeabc7c8bcd37a9f12
+  data.tar.gz: 00cd12932a6610f117b4d105f62daa3f83dd174dc26dfb14e6f7bcdcb4fd5ee16f656308a35439136262875f9562bcf593fface3b29fd8771572b6e079d1efe5

data/lib/gen.rb

@@ -0,0 +1,6 @@
+
+
+# This module provides code and method generation tools
+
+module Gen
+end

data/lib/gen/code.rb

@@ -0,0 +1,73 @@
+require 'gen/method'
+
+module Gen
+  class Gen::Code < Gen::Method
+    attr_accessor :local_var_count, :bound_procs, :bound_constants
+
+    # lambda_block: call on code and (optionally) arguments to generate a lambda
+    def_block_gen :lambda
+
+    # proc_block: call on code and (optionally) arguments to generate a proc
+    def_block_gen :proc
+
+    # local_block: call on code to keep localized during execution
+    def_block_gen :local, "#{self}.wrap_it", nil
+
+    def_block_gen :class_exec
+
+    def initialize(local_var_count=0, bound_procs=[], bound_constants=[])
+      @local_var_count = local_var_count
+      @bound_procs     = bound_procs
+      @bound_constants = bound_constants
+    end
+
+    # Evaluate a string using the locally bound procs and constants
+    def bound_eval(source)
+      self.generate_binding.eval source
+    end
+
+    # Generate a binding containing the locally bound procs and constants
+    def generate_binding(a_binding=binding)
+      a_binding.local_variables do |local_var|
+        a_binding.local_variable_set local_var, nil
+      end
+      @bound_procs.zip(0..Float::INFINITY).each do |bound_proc, num|
+        a_binding.local_variable_set "proc_#{num}",  bound_proc
+      end
+      @bound_constants.zip(0..Float::INFINITY).each do |bound_const, num|
+        a_binding.local_variable_set "const_#{num}", bound_const
+      end
+      a_binding
+    end
+
+    # The current local variable, of form: `"x_#{@local_var_count}"`
+    def local_var
+      "x_#{@local_var_count}"
+    end
+
+    # Assigns a new local variable to its argument (incrementing `@local_var_count`)
+    def new_local_var(other)
+      @local_var_count += 1
+      "#{self.local_var} = #{other}"
+    end
+
+    # Bound within `#bound_eval` as `proc_#{position in @bound_procs}`
+    def bind_proc(a_proc)
+      unless a_proc.is_a? Proc
+        raise ArgumentError, "#{a_proc.inspect} is not a Proc, it is a #{a_proc.class}".freeze
+      end
+      proc_string = "proc_#{@bound_procs.length}"
+      @bound_procs     << a_proc.freeze
+      proc_string
+    end
+
+    # Bound within `#bound_eval` as `const_#{position in @bound_constants}`
+    def bind_const(a_const)
+      const_string = "const_#{@bound_constants.length}"
+      @bound_constants << a_const.freeze
+      const_string
+    end
+  end
+end
+
+

data/lib/gen/if.rb

@@ -0,0 +1,18 @@
+require 'gen/predicate'
+
+# This class is just sugar on Gen::Predicate
+
+module Gen
+  class Gen::If < Gen::Predicate
+    def self.[](*test_hashes)
+      test_hash = {}
+      test_hashes.each do |a_test_hash|
+        test_hash.merge! a_test_hash
+      end
+      a_class = Class.new
+      self.make_test a_class, :a_test, test_hash
+      a_class.freeze
+      a_class.new.method(:a_test).to_proc.freeze
+    end
+  end
+end

data/lib/gen/method.rb

@@ -0,0 +1,41 @@
+
+module Gen
+  class Gen::Method
+    # define a method on both the class and the instance
+    def self.def_self(method_name, &block)
+      define_method           method_name, block # defines instance method
+      define_singleton_method method_name, block # defines class method
+    end
+
+    # define a block generator on both the class and the instance
+    def self.def_block_gen(name, initializer=name.to_s, default_args=nil)
+      def_self "#{name}_block".to_sym do |code_lines=nil, args=default_args, &block|
+        code_lines ||= block.call
+        ["#{initializer} do #{args && "|#{args}|"}",
+         indent(code_lines),
+         "end"].join("\n")
+      end
+    end
+
+    # Wrap a code block to keep variables local
+    #   puts (Benchmark.measure do
+    #       1000000.times do
+    #         CodeGen.wrap_it{}
+    #       end
+    #   end)
+    #     0.780000   0.020000   0.800000 (  0.805655)
+    def_self :wrap_it do |&block|
+      block&.call
+    end.freeze
+
+    # indent some lines of code (with two spaces). Accepts a newline seperated string or an array of strings.
+    def_self :indent do |code_lines|
+      if code_lines.is_a? String
+        code_lines.lines.map{|line| "  " + line}.join
+      elsif code_lines.is_a?(Array)
+        code_lines.map{|line| indent line}
+      end
+    end
+  end
+end
+

data/lib/gen/predicate.rb

@@ -0,0 +1,54 @@
+require 'gen/code'
+
+module Gen
+  class Gen::Predicate < Gen::Code
+    # you enter a nested hash where the branches define the execution path and the leaves either have a value 
+    # (which will be compared with the actual value) or a single-argument Proc, which is called on it
+    # e.g.
+    #   pry(main)> make_test({:to_a=> {:length=>5}}).call (1..4)
+    #   => false
+    #   pry(main)> make_test({:to_a=> {:length=>5}}).call (1..5)
+    #   => true
+    def make_test_code(test_hash)
+      input_var = local_var
+      test_hash.map do |method, value|
+        [self.new_local_var("#{input_var}.#{method}"),
+        if value.is_a? Hash
+          make_test_code(value)
+        elsif value.is_a? Proc
+          "return false unless #{bind_proc  value}.call(#{local_var})"
+        else
+          "return false unless #{bind_const value} ==   #{local_var} "
+        end]
+      end.flatten << "return true"
+    end
+
+    # given a class, a name for the test (instance) method, and a test hash, generate a predicate
+    def make_test(klass, test_name, test_hash)
+      test_code = self.make_test_code test_hash
+      test_code = self.proc_block test_code, 'x_0'
+
+      arg_vars  = []
+      args      = []
+      @bound_procs.zip(0..Float::INFINITY).each do |bound_proc, num|
+        arg_vars << "proc_#{num}"
+        args     << bound_proc
+      end
+      @bound_constants.zip(0..Float::INFINITY).each do |bound_const, num|
+        arg_vars << "const_#{num}"
+        args     << bound_const
+      end
+
+      test_code = self.proc_block test_code, arg_vars.to_s.gsub(/[\[\]\"]/, '').freeze
+      klass.class_exec do
+        define_method test_name, eval(test_code).call(*args)
+      end
+    end
+
+    # An alias of `#make_test`
+    def self.make_test(klass, test_name, test_hash)
+      self.new.make_test klass, test_name, test_hash
+    end
+  end
+end
+

data/lib/nil_passer.rb

@@ -109,70 +109,414 @@ class NilPasser
   end
 end
 
-# def generate_nil_passers(klass, methods, no_arg_methods=[])
-#   methods = methods.select do |method|
+
+
+
+# require 'rails'
+# require_relative 'predicate_gen'
+# require_relative 'code_gen'
+# require_relative 'self'
+
+# class Gen::MonitorArgs
+#   attr_accessor :block_given, :in, :only
+# end
+
+# class Gen::MonitorOptions
+#   # recurse the options, replacing convenient options with pedantic ones
+#   def recurse(options)
+#     if options.is_a? Hash
+#       options.map do |k, v|
+#         k2, v2 = if self.respond_to? "options_#{k}"
+#           self.send("options_#{k}", v) || [k, v]
+#         end
+#         v2 ||= self.recurse v2
+#         [k2, v2]
+#       end.to_h
+#     end
+#   end
+
+#   def options_in(x)
+#     if x
+#       if x.is_a?(Proc) && x.arity == 1
+#         # add proc(source_location) as prerequisite
+#         [:source_location, x]
+#       elsif x.is_a? Pathname
+#         if x.extname == ".rb"
+#           [:source_location, Proc.new{|source_location| source_location == x}]
+#         else
+#           [:source_location, Proc.new{|source_location| source_location.start_with?(x)}]
+#         end
+#       elsif x.is_a? String
+#         x = Pathname.new x
+#         if x.extname == ".rb"
+#           [:source_location, Proc.new{|source_location| source_location == x}]
+#         else
+#           [:source_location, Proc.new{|source_location| source_location.start_with?(x)}]
+#         end
+#       else
+#         raise ArgumentError, "Gen::MonitorOptions#in: Expected a single-argument Proc, a Pathname/String of a directory/source file location, or a list of those, got: #{x}"
+#       end
+#     end
+#   end
+
+#   def options_arguments(x)
+#     if x.is_a? Hash
+#       x.map do |k, v|
+#         if /_(?<num>\d+)/ =~ k
+#           if v.is_a? Proc
+#             [k, Proc.new{|y| v.call(y[num.to_i])}]
+#           else
+#             [k, Proc.new{|y| v ==   y[num.to_i] }]
+#           end
+#         elsif "has_defaults" == k.to_s && [false, true].include?(v)
+#           [k, Proc.new{|y| y.parameters.map{|z, _| z}.any?{|w| w == :opt} == v}]
+#         else
+#           [k, v]
+#         end
+#       end
+#     end
+#   end
+
+#   def options_only(x)
+#     if x.respond_to? :to_f
+#       Proc.new{ rand <= x.to_f }
+#     end
+#   end
+# end
+
+# # idea is that if predicate, pass args to a Proc and continue on. used for logging, tests, etc.
+# class Gen::Monitor < Gen::Code
+#   def self.nice_options(options={})
+#     options
+#   end
+
+#   def self.class_method(options={}, &block)
+#   end
+
+#   def self.instance_method(options={}, &block)
+#     arguments_test = make_arguments_test (options[:arguments] || options[:args])
+#     block_test     = make_block_test     options[:block_given]
+#     in_test        = make_in_test        options[:in]
+#     method_test    = make_method_test    options[:method]
+#     only_test      = make_only_test      options[:only]
+#     Proc.new do |method, *args, &block|
+#       in
+#       method
+#       block
+#       arguments
+#       only
+#     end
+#   end
+# end
+
+
+# class NilPasser < MethodMonitor
+#   @@rails_path ||= Rails.root.to_s
+
+#   # instance_method block_given: { arity: 1 }, in: Rails.root, only: 0.5 do |method, args, block|
+#   instance_method block_given: { arity: 1, in: Rails.root } do |method, args, block|
 #     begin
-#       klass.instance_method method
-#       true
-#     rescue NameError
-#       false
+#       block.call nil
+#     rescue Exception => e
+#       puts "found block at #{block.source_location}, error: #{e.inspect}"
+#     end
+#   end
+# end
+
+
+
+
+# class NiceOptions
+#   # here, we reformat a few options to match the format of MethodTester
+
+#   # assume applies to all class/instance variables of given symbol (when called like MethodMonitor.monitor Klass, :sym)
+#   # default monitors do nothing
+#   # only adds the features used to the method (so probably have to generate source to remain fast)
+#   # only: (0..1) adds the monitor with percent probability
+#   # only: Fixnum adds only Fixnum monitors
+# end
+
+
+# class MethodMonitor
+#   def self.test(a_caller, block)
+#     if (block&.arity == 1) && a_caller.first&.start_with?(@@rails_path)
+#       begin
+#         block.call nil
+#       rescue Exception => e
+#         @@rails_logger.tagged("no-nil") { @@rails_logger.info "found a block that can't handle nil at #{block.source_location}, error: #{e.inspect}" }
+#       end
 #     end
 #   end
 
-#   no_arg_methods = no_arg_methods.select do |method|
+#   def self.clone(klass, method_name)
 #     begin
-#       klass.instance_method method
-#       true
+#       # ensure that the method is not recursively redefined
+#       klass.class_variable_get("@@old_#{method_name}".to_sym)
 #     rescue NameError
-#       false
+#       klass.instance_method(method_name).clone
+#     end
+#   end
+
+#   # stuff -> @@old_stuff
+#   def to_old(x)
+#     # need to convert method-only symbols into symbols acceptible for class variables
+#     clean_x = x.to_s.gsub(/[^0-9a-zA-Z_]/) do |y|
+#       y.codepoints.map do |z|
+#         z.to_s
+#       end.join('_')
 #     end
+#     "@@old_#{clean_x}".to_sym
 #   end
 
-#   old_decls = (methods + no_arg_methods).map do |method|
-#     "@@old_#{sane method} = NilPasser.clone #{klass}, :#{method}"
-#   end.map{|str| "  " + str}
 
-#   new_decls = methods.map do |method|
-#     [ "def #{method}(*args, &block)",
-#       "  NilPasser.test caller, block",
-#       "  @@old_#{sane method}.bind(self)&.call(*args, &block)",
-#       "end"
-#     ].map{|str| "  " + str}
+#   def initialize_instance(inst, method_name=nil, accepts_args=true)
+#     if method_name
+#       begin
+#         @obj         = inst
+#         @method_name = method_name
+#         @orig_proc   = inst.method(method_name).to_proc
+#       rescue NameError => e
+#         raise ArgumentError, "The provided method must be a valid method of the provided object, got: #{e}"
+#       end
+#     else
+#       (inst.methods - Object.methods).map do |method|
+#         NilPasser.new(obj, method)
+#       end
+#     end
 #   end
 
-#   new_no_arg_decls = no_arg_methods.map do |method|
-#     [ "def #{method}(&block)",
-#       "  NilPasser.test caller, block",
-#       "  @@old_#{sane method}.bind(self)&.call(&block)",
-#       "end"
-#     ].map{|str| "  " + str}
+#   def call(*args, &block)
+#     NilPasser.test caller, block
+#     @orig_proc.call(*args, &block)
 #   end
 
-#   [ "class #{klass}",
-#     old_decls,
-#     new_decls,
-#     new_no_arg_decls,
-#     "end"
-#   ].flatten.join("\n")
-# end
+#   def teardown
+#     @obj.send(:define_singleton_method, @method_name, @orig_proc)
+#   end
+
+#   def sanitize_options(options)
+#     clean_options = {}
+#     [:arguments_given, :block_given, :in, :has_defaults, :called_on].each do |symbol|
+#       clean_options[symbol] = options[symbol]
+#     end
+#     clean_options
+#   end
+
+#   # at the _where_ point, call predicate and only continue if it returns a truthy value
+#   def add_prerequisite_from_proc_or_equal(where, klass, predicate)
+#   end
+
+#   def singleton_method(*args, &block)
+#     def self.test_singleton_method
+#     end
+#   end
+
+#   def instance_method(*args, &block)
+#     def self.test_instance_method
+#     end
+#   end
+
+#   def class_method(*args, &block)
+#     def self.test_class_method
+#     end
+#   end
+
+#   def monitor_singleton_method(object, method_name=nil, accepts_args=true)
+#   end
 
-# def generate_all_nil_passers(klass)
-#   generate_nil_passers klass, (klass.methods - klass.superclass.methods).select{|x| x.to_s.present?}
+#   def monitor_instance_method(klass, method_name=nil, accepts_args=true)
+#     if method_name
+#       obj.class.class_variable_set(to_old method_name, self.clone(obj, method_name))
+#       if accepts_args
+#         # I don't know how to send this to klass without eval
+#         eval [ "class #{klass}",
+#                "  def #{method_name}(*args, &block)",
+#                "    #{self.class}.test_instance_method caller, block",
+#                "    #{to_old method_name}.bind(self)&.call(*args, &block)",
+#                "  end",
+#                "end"
+#         ].join("\n")
+#       else
+#         eval [ "class #{klass}",
+#                "  def #{method_name}(&block)",
+#                "    #{self.class}.test_instance_method caller, block",
+#                "    #{to_old method_name}.bind(self)&.call(&block)",
+#                "  end",
+#                "end"
+#         ].join("\n")
+#       end
+#     else
+#       klass.instance_methods.each{|method| self.monitor_instance_method method}
+#     end
+#   end
+
+#   def monitor_class_method(klass, method_name=nil, accepts_args=true)
+#     if method_name
+#       obj.class.class_variable_set(to_old(method_name, :class), self.clone(obj, method_name))
+#       if accepts_args
+#         # I don't know how to send this to klass without eval
+#         eval [ "class self.#{klass}",
+#                "  def #{method_name}(*args, &block)",
+#                "    #{self.class}.test_instance_method caller, block",
+#                "    #{to_old method_name}.bind(self)&.call(*args, &block)",
+#                "  end",
+#                "end"
+#         ].join("\n")
+#       else
+#         eval [ "class self.#{klass}",
+#                "  def #{method_name}(&block)",
+#                "    #{self.class}.test_instance_method caller, block",
+#                "    #{to_old method_name}.bind(self)&.call(&block)",
+#                "  end",
+#                "end"
+#         ].join("\n")
+#       end
+#     else
+#       klass.instance_methods.each{|method| self.monitor_instance_method method}
+#     end
+#   end
+
+#   def monitor(object, method_name=nil)
+#     if object.is_a?(Class)
+#       self.monitor_instance_method  object, method_name
+#       self.monitor_class_method     object, method_name
+#     else
+#       self.monitor_singleton_method object, method_name
+#     end
+#   end
 # end
 
-# eval generate_all_nil_passers(ActiveRecord::Relation)
-# eval generate_all_nil_passers(Hash)
-# eval generate_all_nil_passers(Enumerator)
-# eval generate_all_nil_passers(Array)
-# eval generate_all_nil_passers(String)
 
 
-# eval generate_nil_passers(ActiveRecord::Relation, [:select, :find_each], [:each])
-# eval generate_nil_passers(Hash,                   [],                    [:each_key, :each_value])
-# eval generate_nil_passers(Enumerator,             [],                    [:each])
-# eval generate_nil_passers(Array,                  [:collect, :select],   [:each, :map])
-# eval generate_nil_passers(String,                 [:each_line])
 
-# puts "**** loaded nil passer *********"
+# # class NilPasser < MethodMonitor
+# #   @@rails_path ||= Rails.root.to_s
+
+# #   # instance_method block_given: { arity: 1 }, in: Rails.root, only: 0.5 do |method, args, block|
+# #   instance_method block_given: { arity: 1, in: Rails.root } do |method, args, block|
+# #     begin
+# #       block.call nil
+# #     rescue Exception => e
+# #       puts "found block at #{block.source_location}, error: #{e.inspect}"
+# #     end
+# #   end
+# # end
+
+# # Array.monitor
+
+# # Array.monitor(:map)
+
+# # NilPasser.monitor Array, :map
+# # NilPasser.monitor Array
+# # NilPasser.monitor Array.method
+
+
+# class NilPasser
+#   attr_accessor :obj, :method_name, :orig_proc
+#   @@rails_path   ||= Rails.root.to_s
+#   @@rails_logger ||= Rails.logger
+
+#   def self.test(a_caller, block)
+#     if (block&.arity == 1) && a_caller.first&.start_with?(@@rails_path)
+#       begin
+#         block.call nil
+#       rescue Exception => e
+#         @@rails_logger.tagged("no-nil") { @@rails_logger.info "found a block that can't handle nil at #{block.source_location}, error: #{e.inspect}" }
+#       end
+#     end
+#   end
 
+#   def self.clone(klass, method_name)
+#     begin
+#       # ensure that the method is not recursively redefined
+#       klass.class_variable_get("@@old_#{method_name}".to_sym)
+#     rescue NameError
+#       klass.instance_method(method_name).clone
+#     end
+#   end
+
+#   def self.teardown(nil_passers)
+#     nil_passers.each do |nil_passer|
+#       nil_passer.teardown
+#     end
+#   end
+
+#   def initialize(obj, method_name=nil, accepts_args=true)
+#     if obj.is_a? Class
+#       self.initialize_class    obj, method_name, accepts_args
+#     else
+#       self.initialize_instance obj, method_name, accepts_args
+#     end
+#   end
+
+#   # stuff -> @@old_stuff
+#   def to_old(x)
+#     # need to convert method-only symbols into symbols acceptible for class variables
+#     clean_x = x.to_s.gsub(/[^0-9a-zA-Z_]/) do |y|
+#       y.codepoints.map do |z|
+#         z.to_s
+#       end.join('_')
+#     end
+#     "@@old_#{clean_x}".to_sym
+#   end
+
+#   def initialize_class(klass, method_name=nil, accepts_args=true)
+#     if method_name
+#       obj.class.class_variable_set(to_old method_name, NilPasser.clone(obj, method_name))
+#       if accepts_args
+#         # I don't know how to send this to klass without eval
+#         eval [ "class #{klass}",
+#                "  def #{method_name}(*args, &block)",
+#                "    NilPasser.test caller, block",
+#                "    #{to_old method_name}.bind(self)&.call(*args, &block)",
+#                "  end",
+#                "end"
+#         ].join("\n")
+#       else
+#         eval [ "class #{klass}",
+#                "  def #{method_name}(&block)",
+#                "    NilPasser.test caller, block",
+#                "    #{to_old method_name}.bind(self)&.call(&block)",
+#                "  end",
+#                "end"
+#         ].join("\n")
+#       end
+#     else
+#       obj.methods.map do |method|
+#         NilPasser.new(obj, method)
+#       end
+#     end
+#   end
+
+#   def initialize_instance(inst, method_name=nil, accepts_args=true)
+#     if method_name
+#       begin
+#         @obj         = inst
+#         @method_name = method_name
+#         @orig_proc   = inst.method(method_name).to_proc
+#       rescue NameError => e
+#         raise ArgumentError, "The provided method must be a valid method of the provided object, got: #{e}"
+#       end
+#     else
+#       (inst.methods - Object.methods).map do |method|
+#         NilPasser.new(obj, method)
+#       end
+#     end
+#   end
+
+#   def setup
+#     @orig_proc = self.obj.method(@method_name).to_proc.clone
+#     @obj.send(:define_singleton_method, @method_name, self.method(:call).to_proc)
+#     self
+#   end
+
+#   def call(*args, &block)
+#     NilPasser.test caller, block
+#     @orig_proc.call(*args, &block)
+#   end
+
+#   def teardown
+#     @obj.send(:define_singleton_method, @method_name, @orig_proc)
+#   end
+# end
 

data/lib/utils/monitor_method.rb

@@ -0,0 +1,146 @@
+require 'utils/wrap_method'
+
+# Example usage:
+#   instance_monitor Array, :map do |map|
+#     method_monitor nil, If[empty: true], If[args: 1] do |*args, &block|
+#       block.call nil
+#       [args, block]
+#     end
+#   end
+
+
+class MonitorMethod < WrapMethod
+  def self.new
+    raise NoMethodError
+  end
+
+  # return a proc that takes a method
+  # block takes |*args, &block| and returns [new_args, new_block] or falsey
+  def self.method_monitor(args_predicate=nil, block_predicate=nil, &passed_block)
+    unless passed_block.parameters.map(&:first) == [:rest, :block]
+      raise ArgumentError, "must pass a block with arguments of the form: |*args, &block|, was of the form: #{passed_block&.parameters.inspect}".freeze
+    end
+    lambda do |_|
+      lambda do |*args, &block|
+        if !args_predicate || args_predicate.call(args)
+          if !block_predicate || block_predicate.call(block)
+            passed_block.call(*args, &block)
+          end
+        end || [args, block]
+      end
+    end.freeze
+  end
+
+  # return a proc that takes an unbound method
+  # block takes |bound_to, *args, &block| and returns [new_args, new_block] or falsey
+  def self.unbound_method_monitor(bound_predicate=nil, args_predicate=nil, block_predicate=nil, &passed_block)
+    unless passed_block.parameters.map(&:first) == [:opt, :rest, :block]
+      raise ArgumentError, "must pass a block with arguments of the form: |bound_to, *args, &block|, was of the form: #{passed_block&.parameters.inspect}".freeze
+    end
+    lambda do |_|
+      lambda do |bound_to|
+        if !bound_predicate || bound_predicate.call(bound_to)
+          lambda do |*args, &block|
+            if !args_predicate || args_predicate.call(args)
+              if !block_predicate || block_predicate.call(block)
+                passed_block.call(bound_to, *args, &block)
+              end
+            end || [args, block]
+          end
+        else
+          lambda do |*args, &block|
+            [args, block]
+          end.freeze
+        end
+      end
+    end.freeze
+  end
+
+  class << self
+    alias :class_monitor  :class_wrap
+    alias :class_monitor! :class_wrap!
+  end
+
+  def self.class_monitors(klass, method_predicate=nil, &block)
+    if method_predicate
+      klass.public_methods.each do |method|
+        if method_predicate.call klass, method
+          self.class_monitor     klass, method, &block
+        end
+      end
+    else
+      klass.public_methods.each do |method|
+        self.class_monitor       klass, method, &block
+      end
+    end
+  end
+
+  def self.classes_monitors(klass_predicate=nil, method_predicate=nil, &block)
+    if klass_predicate
+      ObjectSpace.each_object(Class) do |klass|
+        if klass_predicate.call klass
+          self.class_monitors   klass, method_predicate, &block
+        end
+      end
+    else
+      ObjectSpace.each_object(Class) do |klass|
+        self.class_monitors     klass, method_predicate, &block
+      end
+    end
+  end
+
+  class << self
+    alias :instance_monitor  :instance_wrap
+    alias :instance_monitor! :instance_wrap
+  end
+
+  def self.instance_monitors(klass, method_predicate=nil, &block)
+    if method_predicate
+      klass.public_instance_methods.each do |method|
+        if method_predicate.call klass, method
+          self.instance_monitor  klass, method, &block
+        end
+      end
+    else
+      klass.public_instance_methods.each do |method|
+        self.instance_monitor    klass, method, &block
+      end
+    end
+  end
+
+  def self.instances_monitors(klass_predicate=nil, method_predicate=nil, &block)
+    if klass_predicate
+      ObjectSpace.each_object(Class) do |klass|
+        if klass_predicate.call  klass
+          self.instance_monitors klass, method_predicate, &block
+        end
+      end
+    else
+      ObjectSpace.each_object(Class) do |klass|
+        self.instance_monitors   klass, method_predicate, &block
+      end
+    end
+  end
+
+  class << self
+    alias :singleton_monitor  :singleton_wrap
+    alias :singleton_monitor! :singleton_wrap!
+  end
+
+  def self.singleton_monitors(object, method_predicate=nil, &block)
+    if method_predicate
+      object.public_methods.each do |method|
+        if method_predicate.call object, method
+          self.instance_monitor  object, method, &block
+        end
+      end
+    else
+      object.public_methods.each do |method|
+        self.singleton_monitor   object, method, &block
+      end
+    end
+  end
+end
+
+MonitorMethod.freeze
+

data/lib/utils/wrap_method.rb

@@ -0,0 +1,134 @@
+
+class WrapMethod
+  def self.oldify_name(method_name)
+    # need to convert method-only symbols into symbols acceptible for class variables
+    clean_method_name = method_name.to_s.gsub(/[^0-9a-zA-Z_]/) do |x|
+      x.codepoints.map do |y|
+        y.to_s
+      end.join('_')
+    end
+    "@@old_#{clean_method_name}".to_sym
+  end
+
+  def self.class_method_exists?(klass, method_name)
+    if method_name.is_a?(Symbol) || method_name.is_a?(String)
+      klass.respond_to? method_name
+    else
+      false
+    end
+  end
+
+  def self.instance_method_exists?(klass, method_name)
+    if method_name.is_a?(Symbol) || method_name.is_a?(String)
+      klass.method_defined? method_name
+    else
+      false
+    end
+  end
+
+  class << self
+    alias :singleton_method_exists? :class_method_exists?
+  end
+
+  # The block is passed the previous method (frozen).
+  # `rewrap=true` means the method will be redefined (safely) if it has already been redefined.
+  # Note that in redefinition, the previous wrapped definition is tossed.
+  def self.raw_class_wrap(klass, method_name, rewrap=false, &block)
+    old_method = nil
+    if self.class_method_exists? klass, self.oldify_name(method_name)
+      if rewrap
+        old_method = klass.method self.oldify_name(method_name)
+      else
+        return nil
+      end
+    else
+      old_method = klass.method(method_name).clone.freeze
+      klass.define_singleton_method self.oldify_name(method_name), old_method
+    end
+    klass.define_singleton_method method_name, block.call(old_method)
+  end
+
+  def self.class_wrap(klass, method_name, &block)
+    unless self.class_method_exists? klass, method_name
+      return nil
+    end
+    self.raw_class_wrap klass, method_name, &block
+  end
+
+  def self.class_wrap!(klass, method_name, &block)
+    unless self.class_method_exists? klass, method_name
+      raise ArgumentError, "WrapMethod::class_wrap!: #{klass}::#{method_name} does not exist".freeze
+    end
+    self.raw_class_wrap klass, method_name, &block
+  end
+
+  # The block is passed the previous unbound method (frozen).
+  # `rewrap=true` means the method will be redefined (safely) if it has already been redefined.
+  # Note that in redefinition, the previous wrapped definition is tossed.
+  def self.raw_instance_wrap(klass, method_name, rewrap=false, &block)
+    old_method = nil
+    if self.instance_method_exists? klass, self.oldify_name(method_name)
+      if rewrap
+        old_method = klass.instance_method self.oldify_name(method_name)
+      else
+        return nil
+      end
+    else
+      old_method = klass.instance_method(method_name).clone.freeze
+      klass.send :define_method, self.oldify_name(method_name), old_method
+    end
+    klass.send :define_method, method_name, block.call(old_method)
+  end
+
+  # See `WrapMethod::raw_instance_wrap`. This adds a check that the method exists and returns `nil` if it doesn't
+  def self.instance_wrap(klass, method_name, rewrap=false, &block)
+    unless self.instance_method_exists? klass, method_name
+      return nil
+    end
+    self.raw_instance_wrap klass, method_name, rewrap, &block
+  end
+
+  # See `WrapMethod::raw_instance_wrap`. This adds a check that the method exists and raises an `ArgumentError` if it doesn't
+  def self.instance_wrap!(klass, method_name, rewrap=false, &block)
+    unless self.instance_method_exists? klass, method_name
+      raise ArgumentError, "WrapMethod::instance_wrap!: #{klass}::#{method_name} does not exist".freeze
+    end
+    self.raw_instance_wrap klass, method_name, rewrap, &block
+  end
+
+  # The block is passed the previous method (frozen).
+  # `rewrap=true` means the method will be redefined (safely) if it has already been redefined.
+  # Note that in redefinition, the previous wrapped definition is tossed.
+  def self.raw_singleton_wrap(object, method_name, rewrap=false, &block)
+    old_method = nil
+    if self.singleton_method_exists? object, self.oldify_name(method_name)
+      if rewrap
+        old_method = object.method self.oldify_name(method_name)
+      else
+        return nil
+      end
+    else
+      old_method = object.method(method_name).clone.freeze
+      object.define_singleton_method self.oldify_name(method_name), old_method
+    end
+    object.define_singleton_method method_name, block.call(old_method)
+  end
+
+  # See `WrapMethod::raw_singleton_wrap`. This adds a check that the method exists and returns `nil` if it doesn't
+  def self.singleton_wrap(object, method_name, rewrap=false, &block)
+    unless self.singleton_method_exists? object, method_name
+      return nil
+    end
+    self.raw_singleton_wrap object, method_name, rewrap=false, &block
+  end
+
+  # See `WrapMethod::raw_singleton_wrap`. This adds a check that the method exists and raises an `ArgumentError` if it doesn't
+  def self.singleton_wrap!(object, method_name, rewrap=false, &block)
+    unless self.singleton_method_exists? object, method_name
+      raise ArgumentError, "WrapMethod::singleton_wrap!: #{object}::#{method_name} does not exist".freeze
+    end
+    self.raw_singleton_wrap object, method_name, rewrap=false, &block
+  end
+
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nil-passer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Michael Klein
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-07 00:00:00.000000000 Z
+date: 2017-04-03 00:00:00.000000000 Z
 dependencies: []
 description: A nil-tester for blocks
 email: lambdamichael@gmail.com
@@ -16,8 +16,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/gen.rb
+- lib/gen/code.rb
+- lib/gen/if.rb
+- lib/gen/method.rb
+- lib/gen/predicate.rb
 - lib/nil_passer.rb
-homepage: http://github.com/michaeljklein/nil-passer
+- lib/utils/monitor_method.rb
+- lib/utils/wrap_method.rb
+homepage: https://michaeljklein.github.io/nil-passer/
 licenses:
 - MIT
 metadata: {}
@@ -37,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Pass nil to all the blocks in an app, catching and logging exceptions