magic-help 0.20170204

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 59db211c23ba22dab20b3e5b3e16e3303dcfe1dd
+  data.tar.gz: b50b3dae0566f1807bd297df5d3113c0830f7ef6
+SHA512:
+  metadata.gz: 5523804800dc7e7733e12e775900ce47fb7a568608a27abc3c78ae43157f6f285cb2f1133e0d302360e20da31a21a946b4861328f1047603c0d244679ce2e602
+  data.tar.gz: 101f7ccdfd34ddc90287b470f295c16dcbb2de5fc1041fa6bf861576e5e60d1306a0951f2bc57201455a14e4c38383d8b4cc18ef9b2310a2cba38e2356a75400

data/lib/magic/help.rb

@@ -0,0 +1,104 @@
+require_relative "help/irb"
+require_relative "help/tracepoint"
+
+module Magic
+  module Help
+    def self.help_method_extract(m)
+      unless m.inspect =~ %r[\A#<(?:Unbound)?Method: (.*?)>\Z]
+        raise "Cannot parse result of #{m.class}#inspect: #{m.inspect}"
+      end
+      $1.sub(/\A.*?\((.*?)\)(.*)\Z/){ "#{$1}#{$2}" }.sub(/\./, "::").sub(/#<Class:(.*?)>#/) { "#{$1}::" }
+    end
+
+    # Magic::Help.postprocess is used to postprocess queries in two cases:
+    # * help "Foo.bar" queries - res defined, more hacks
+    # * help { Foo.bar } queries - res not defined, fewer hacks
+    def self.postprocess(m, res=nil)
+      # Kernel#method_missing here means class was found but method wasn't
+      # It is possible that such method exists, it was simply not included.
+      # Example - Time::rfc2822 from time.rb.
+      #
+      # Do not correct it if actual method_missing was called.
+      if res and m == "Kernel#method_missing"
+          m = res unless res =~ /\A(?:.*)(?:\#|::|\.)method_missing\Z/
+      # Most classes do not override Foo::new, but provide new documentation anyway !
+      # Two cases are possible
+      # * Class#new is used
+      # * Bar::new is used, for Bar being some ancestor of Foo
+      elsif res and (m =~ /\A(.*)\#new\Z/ or m =~ /\A(.*)::new\Z/)
+        cls = $1
+        # Do not correct requests for Foo#new
+        # If Foo#new became Class#new, it must have been
+        # by some evil metaclass hackery.
+        #
+        # Foo.new or Foo::new both become Foo::new
+        if res =~ /\A(.*)(::|\.)new\Z/
+          cls_requested, k = $1, $2
+          # Condition just to get "Class#new" working correctly
+          # Otherwise it would be changed to "Class::new"
+          m = "#{cls_requested}::new" unless cls == cls_requested
+        end
+      end
+
+      m
+    end
+
+    def self.resolve_help_res(res)
+      query = case res
+      when Module
+        res.to_s
+      when UnboundMethod, Method
+        help_method_extract(res)
+      when /\A(.*)(#|::|\.)(.*)\Z/
+        cp, k, m = $1, $2, $3
+        begin
+          # For multielement paths like File::Stat const_get must be
+          # called multiple times, that is:
+          # Object.const_get("File").const_get("Stat")
+          cls = cp.split(/::/).inject(Object){|c, path_elem| c.const_get(path_elem) }
+          case k
+          when "#"
+            m = cls.instance_method(m)
+            m = help_method_extract(m)
+          when "::"
+            m = cls.method(m)
+            # Make sure a module method is returned
+            # It fixes `Class::new' resolving to `Class#new'
+            # (Class::new and Class#new are the same thing,
+            # but their documentations are different)
+            m = help_method_extract(m)
+            m = m.sub(/\#/, "::") if cls == Class && m == "Class#new"
+          when "."
+            begin
+              m = cls.instance_method(m)
+            rescue NameError
+              m = cls.method(m)
+            end
+            m = help_method_extract(m)
+          end
+          postprocess(m, res)
+        rescue NameError
+          res
+        end
+      when String
+        res
+      else
+        res.class.to_s
+      end
+      query
+    end
+
+    def self.resolve_help_query(*args, &block)
+      raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" if args.size > 1
+      raise ArgumentError, "help cannot take both arguments and block" if args.size > 0 and block_given?
+      if block_given?
+        resolve_help_block(&block)
+      elsif args.empty?
+        # No block, no arguments
+        nil
+      else
+        resolve_help_res(args[0])
+      end
+    end
+  end
+end

data/lib/magic/help/irb.rb

@@ -0,0 +1,28 @@
+require "irb"
+require "irb/extend-command"
+
+# Now let's hack irb not to alias irb_help -> help
+# It saves us a silly warning at startup:
+#     irb: warn: can't alias help from irb_help.
+module IRB::ExtendCommandBundle # :nodoc:
+  @ALIASES.delete_if{|a| a == [:help, :irb_help, NO_OVERRIDE]}
+end
+
+# help is a Do-What-I-Mean help function.
+# It can be called with either a block or a single argument.
+# When called with single argument, it behaves like normal
+# help function, except for being much smarter:
+#
+#  help "Array"         - help on Array
+#  help "Array#sort"    - help on Array#sort
+#  help "File#sync="    - help on IO#sync=
+#
+#  help { [].sort }     - help on Array#sort
+#  help { obj.foo = 1 } - help on obj.foo=
+#  help { Array }       - help on Array
+#  help { [] }          - help on Array
+#  help { Dir["*"] }    - help on Dir::[]
+def help(*args, &block)
+  query = Magic::Help.resolve_help_query(*args, &block)
+  irb_help(query) if query
+end

data/lib/magic/help/set_trace_func.rb

@@ -0,0 +1,109 @@
+# This is 1.8 API, it's still there in 2.0 but they broke it a bit
+
+module Magic
+  module Help
+    def self.resolve_help_block(&block)
+      call_event = nil
+      res = nil
+      done = false
+      res_mm = nil
+      argument_error = false
+
+      # We want to capture calls to method_missing too
+      original_method_missing = BasicObject.instance_method(:method_missing)
+      BasicObject.class_eval {
+        def method_missing(*args)
+          throw :magically_irb_helped, [self, *args]
+        end
+      }
+
+      tf = lambda{|*xargs|
+        return if done
+        event = xargs[0]
+        if argument_error
+          if event == "return"
+            done = true
+            # For functions called with wrong number of arguments,
+            # call event is not generated (function is never called),
+            # but the return event is !
+            call_event = xargs
+            throw :magically_irb_helped
+          end
+        elsif event == "call" or event == "c-call"
+          call_event = xargs
+          if call_event.values_at(0, 3, 5) == ["c-call", :new, Class] and
+            eval("self", call_event[4]) == ArgumentError
+            argument_error = true
+          else
+            done = true
+            # Let Kernel#method_missing run, otherwise throw
+            unless call_event.values_at(0, 3, 5) == ["call", :method_missing, BasicObject]
+              throw :magically_irb_helped
+            end
+          end
+        end
+      }
+      res_mm = catch(:magically_irb_helped) {
+        set_trace_func tf
+        res = yield()
+        done = true
+        nil
+      }
+      done = true
+      set_trace_func nil
+      BasicObject.instance_eval {
+        define_method(:method_missing, original_method_missing)
+        # It was originally private, restore it as such
+        private :method_missing
+      }
+      # Handle captured method_missing
+
+      if res_mm
+        # This is explicit Foo#method_missing:
+        # It shouldn't really be allowed as it's private.
+        if res_mm.size == 1
+          return "Kernel#method_missing"
+        else
+          bound_self, meth = *res_mm
+          # method_missing is called if:
+          # * there was no such method
+          # * there was a method, but a private one only
+          begin
+            # Surprise ! A private method !
+            m = bound_self.method(meth)
+            query = help_method_extract(m)
+          rescue NameError
+            # No such method
+            if bound_self.is_a? Class
+              query = "#{bound_self}::#{meth}"
+            else
+              query = "#{bound_self.class}.#{meth}"
+            end
+          end
+        end
+        postprocess(query)
+      # Handle normal call events
+      elsif call_event
+        meth, bind, cls = call_event[3], call_event[4], call_event[5]
+        bound_self = bind.receiver
+        if meth == :new
+          cls = bound_self
+        end
+
+        # Foo::bar and Foo#bar look the same
+        # Check whether self == Foo to tell them apart
+        #
+        # Only Class::new is documented as such,
+        # all other Class::foo are really Class#foo
+        if bound_self == cls && (bound_self != Class || meth == :new)
+          query = "#{cls}::#{meth}"
+        else
+          query = "#{cls}##{meth}"
+        end
+        postprocess(query)
+      else
+        resolve_help_res(res)
+      end
+    end
+  end
+end

data/lib/magic/help/tracepoint.rb

@@ -0,0 +1,79 @@
+module Magic
+  module Help
+    def self.resolve_help_block(&block)
+      call_event = nil
+      done = false
+      res = nil
+
+      # We want to capture calls to method_missing too
+      # This should be available via TracePoint but isn't
+      original_method_missing = BasicObject.instance_method(:method_missing)
+      BasicObject.class_eval do
+        define_method(:method_missing) do |*args|
+          if args.empty?
+            # This is presumably called on self, and without arguments
+            throw :done, {cls: method(:method_missing).owner, meth: :method_missing, self: self}
+          end
+
+          if self.is_a?(Class)
+            throw :done, {cls: self.singleton_class, meth: args[0], self: self}
+          else
+            throw :done, {cls: self.class, meth: args[0], self: self}
+          end
+        end
+      end
+
+      trace = TracePoint.new do |ev|
+        next if done
+        case ev.event
+        when :call, :c_call
+          if ev.defined_class == BasicObject and ev.method_id == :method_missing
+            done = true
+            # Let it reach our special handler
+          # elsif ev.self == ArgumentError and ev.method_id == :new
+            # Function was called without full number of arguments
+            # There doesn't seem to be any way to recover from this in ruby 2.x
+            # In 1.8 we'd get extra return event
+            #
+            # It's possible to hack argument name from stack trace,
+            # (with massive hacking)
+            # but not self/class, so it's not most useful
+          else
+            done = true
+            throw :done, {cls: ev.defined_class, meth: ev.method_id, self: ev.self}
+          end
+        else
+          # Ignore everything eles
+        end
+      end
+      call_event = catch(:done) do
+        trace.enable
+        res = yield
+        nil
+      end
+      done = true
+      trace.disable
+
+      BasicObject.instance_eval do
+        define_method(:method_missing, original_method_missing)
+        # It was originally private, restore it as such
+        private :method_missing
+      end
+
+      if call_event
+        cls = call_event[:cls]
+        meth = call_event[:meth]
+        bound_self = call_event[:self]
+        is_singleton = (cls.is_a?(Class) and cls.singleton_class?)
+        if is_singleton or meth == :new
+          query = "#{bound_self}::#{meth}"
+        else
+          query = "#{cls}##{meth}"
+        end
+        postprocess(query)
+      else
+        resolve_help_res(res)
+      end
+    end
+  end
+end

data/lib/magic_help.rb

@@ -0,0 +1 @@
+require_relative "magic/help"

data/test/mass_test.rb

@@ -0,0 +1,206 @@
+#!/usr/bin/env ruby
+
+# This only tests how many items magic/help BREAKS,
+# that is - how many would work otherwise.
+
+require_relative "../lib/magic_help"
+require "rdoc/ri"
+
+# Use fake irb_help for testing
+$irb_help = nil
+
+class Object
+  def irb_help(arg)
+    $irb_help = arg
+  end
+end
+
+# A convenience method
+def try_help(*args, &blk)
+  $irb_help = nil
+  help(*args, &blk)
+  rv, $irb_help = $irb_help, nil
+  rv
+end
+
+# Extract documentation
+
+# FIXME: Hardcoded paths are not cross-platform compatible
+default_ri_root_path = "#{RDoc::RI::Paths::BASE}/system"
+ri_root_path = ARGV.shift || default_ri_root_path
+
+docs = Dir["#{ri_root_path}/**/*"]
+
+docs_class = []
+docs_imeth = []
+docs_cmeth = []
+
+docs.each{|fn|
+  next if File.directory?(fn)
+  raise "Weird path: #{fn}" unless fn[0, ri_root_path.size] == ri_root_path
+  fn = fn[ri_root_path.size..-1].sub(/^\/*/, "")
+  # gsub after split to deal with Fixnum#/ etc.
+  path = fn.split(/\//).map{|x| x.gsub(/%(..)/){$1.hex.chr}}
+  case path[-1]
+  when /\A(.*)-i\.(yaml|ri)\Z/
+    docs_imeth << path[0..-2] + [$1]
+  when /\A(.*)-c\.(yaml|ri)\Z/
+    docs_cmeth << path[0..-2] + [$1]
+  when /\Acdesc-(.*)\.(yaml|ri)\Z/
+    raise "Malformatted file name: #{fn}" unless $1 == path[-2]
+    docs_class << path[0..-2]
+  else
+    # Ignore
+  end
+}
+
+# Go over documentation
+
+cl_nc = []
+cl_ni = []
+cl_fc = []
+cl_fi = []
+
+docs_class.each{|class_path|
+  class_name = class_path.join("::")
+  begin
+    cls = class_path.inject(Object){|c,path_elem| c.const_get(path_elem)}
+  rescue NameError
+    rv = try_help class_name
+    if rv == class_name
+      cl_nc << class_name
+    else
+      cl_ni << [class_name, rv]
+    end
+    next
+  end
+  rv1  = try_help class_name
+  rv2 = try_help cls
+  if rv1 == class_name && rv2 == class_name
+    cl_fc << class_name
+  else
+    cl_fi << [class_name, rv1, rv2]
+  end
+}
+
+print <<EOS
+Class documentation:
+* #{docs_class.size} classes
+* #{cl_fc.size} correct
+* #{cl_fi.size} incorrect
+* #{cl_nc.size} could not be verified (seem ok)
+* #{cl_ni.size} could not be verified (seem bad)
+EOS
+if cl_fi.size != 0
+  puts "\nIncorrect:"
+  cl_fi.each{|ex,rv1,rv2|
+    puts "* #{ex} - #{rv1}/#{rv2}"
+  }
+end
+
+cm_nc = [] # Class not found
+cm_ni = []
+cm_fc = []
+cm_fi = []
+
+docs_cmeth.each{|path|
+  class_path, method_name = path[0..-2], path[-1]
+  class_name = class_path.join("::")
+  begin
+    cls = class_path.inject(Object){|c,path_elem| c.const_get(path_elem)}
+  rescue NameError
+    expected = "#{class_name}::#{method_name}"
+    rv = try_help expected
+    if rv == expected
+      cm_nc << expected
+    else
+      cm_ni << [expected, rv]
+    end
+    next
+  end
+  expected = "#{class_name}::#{method_name}"
+  rv1 = try_help "#{class_name}::#{method_name}"
+  # cls.send(:method_name) would find help for Object#send ...
+  rv2 = eval "try_help { cls.#{method_name}() }"
+  if rv1 == expected && rv2 == expected
+    cm_fc << expected
+  else
+    cm_fi << [expected, rv1, rv2]
+  end
+}
+
+print <<EOS
+
+Class method documentation:
+* #{docs_cmeth.size} class methods
+* #{cm_fc.size} correct
+* #{cm_fi.size} incorrect
+* #{cm_nc.size} could not be verified (seem ok)
+* #{cm_ni.size} could not be verified (seem bad)
+EOS
+if cm_fi.size != 0
+  puts "\nIncorrect:"
+  cm_fi.each{|ex,rv1,rv2|
+    puts "* #{ex} - #{rv1}/#{rv2}"
+  }
+end
+
+# And instance methods
+
+im_nc = [] # Class not found
+im_ni = []
+im_fc = []
+im_fi = []
+
+docs_imeth.each{|path|
+  class_path, method_name = path[0..-2], path[-1]
+  class_name = class_path.join("::")
+  begin
+    cls = class_path.inject(Object){|c,path_elem| c.const_get(path_elem)}
+  rescue NameError
+    expected = "#{class_name}.#{method_name}"
+    rv = try_help expected
+    if rv == expected
+      im_nc << expected
+    else
+      im_ni << [expected, rv]
+    end
+    next
+  end
+  expected = "#{class_name}##{method_name}"
+  rv1 = try_help "#{class_name}##{method_name}"
+  # We don't know how to create a real cls object.
+  # We could try some hacks or mock objects later.
+
+  if rv1 == expected
+    im_fc << expected
+  else
+    im_fi << [expected, rv1]
+  end
+}
+
+print <<EOS
+
+Instance method documentation:
+* #{docs_imeth.size} instance methods
+* #{im_fc.size} correct
+* #{im_fi.size} incorrect
+* #{im_nc.size} could not be verified (seem ok)
+* #{im_ni.size} could not be verified (seem bad)
+EOS
+if im_fi.size != 0
+  puts "\nIncorrect:"
+  im_fi.each{|ex,rv1|
+    puts "* #{ex} - #{rv1}"
+  }
+end
+
+print <<EOS
+
+Summary:
+* #{docs_class.size + docs_cmeth.size  + docs_imeth.size} documentation items
+* #{cl_fc.size + cm_fc.size + im_fc.size} correct
+* #{cl_fi.size + cm_fi.size + im_fi.size} incorrect
+* #{cl_nc.size + cm_nc.size + im_nc.size} could not be verified (seem ok)
+* #{cl_ni.size + cm_ni.size + im_ni.size} could not be verified (seem bad)
+EOS

data/test/tc_magic_help.rb

@@ -0,0 +1,240 @@
+#!/usr/bin/env ruby
+
+require "minitest/autorun"
+require_relative "../lib/magic_help"
+require "fileutils"
+
+class Test_Magic_Help < Minitest::Test
+  def self.test_order
+    :alpha
+  end
+
+  def assert_irb_help(expected, *args, &block)
+    got = Magic::Help.resolve_help_query(*args, &block)
+    if expected == nil
+      assert_nil(got)
+    else
+      assert_equal(expected, got)
+    end
+  end
+
+  # There were ways to make it work in 1.8 set_trace_func,
+  # but TracePoint just doesn't seem to allow it
+  def test_argument_number_mismatch
+    # Correct number of arguments
+    assert_irb_help("FileUtils::compare_file"){ FileUtils.compare_file 1, 2 }
+    # Various incorrect argument counts
+    # assert_irb_help("FileUtils::compare_file"){ FileUtils.compare_file }
+    # assert_irb_help("FileUtils::compare_file"){ FileUtils.compare_file 1 }
+    # assert_irb_help("FileUtils::compare_file"){ FileUtils.compare_file 1, 2, 3 }
+  end
+
+  def test_argumenterror_new
+    assert_irb_help("ArgumentError::new"){ ArgumentError.new }
+  end
+
+  def test_class
+    assert_irb_help("Array"){ Array }
+    assert_irb_help("Array"){ [] }
+    x = [1, 2, 3]
+    assert_irb_help("Array"){ x }
+  end
+
+  def test_method
+    assert_irb_help("Array#sort"){ [].sort }
+    x = [1, 2, 3]
+    assert_irb_help("Array#sort"){ x.sort }
+    im  = Array.instance_method(:sort)
+    assert_irb_help("Array#sort"){ im }
+    m = [].method(:sort)
+    assert_irb_help("Array#sort"){ m }
+    um = [].method(:sort).unbind
+    assert_irb_help("Array#sort"){ um }
+  end
+
+  def test_class_method
+    assert_irb_help("Dir::[]"){ Dir[""] }
+    m  = Dir.method(:[])
+    assert_irb_help("Dir::[]"){ m }
+    um = Dir.method(:[]).unbind
+    assert_irb_help("Dir::[]"){ um }
+  end
+
+  def test_module
+    assert_irb_help("Enumerable", Enumerable)
+    assert_irb_help("Enumerable"){ Enumerable }
+    assert_irb_help("Enumerable", "Enumerable")
+    um = Enumerable.instance_method(:map)
+    assert_irb_help("Enumerable#map"){ um }
+    um2 = Range.instance_method(:any?)
+    assert_irb_help("Enumerable#any?"){ um2 }
+    m = (0..1).method(:any?)
+    assert_irb_help("Enumerable#any?"){ m }
+  end
+
+  def test_method_inherited
+    f = File.open(__FILE__)
+    assert_irb_help("IO#sync"){ f.sync }
+    im = File.instance_method(:sync)
+    assert_irb_help("IO#sync"){ im }
+    m  = f.method(:sync)
+    assert_irb_help("IO#sync"){ m }
+    um = f.method(:sync).unbind
+    assert_irb_help("IO#sync"){ um }
+  end
+
+  def test_string
+    assert_irb_help("Array",    "Array" )
+    assert_irb_help("Array#[]", "Array#[]")
+    assert_irb_help("Dir::[]",  "Dir::[]" )
+    assert_irb_help("Array#[]", "Array.[]")
+    assert_irb_help("Dir::[]",  "Dir.[]" )
+    assert_irb_help("IO#sync",  "File#sync" )
+  end
+
+  def test_string_bogus
+    assert_irb_help("Xyzzy#foo",  "Xyzzy#foo")
+    assert_irb_help("Xyzzy::foo", "Xyzzy::foo")
+    assert_irb_help("Xyzzy.foo",  "Xyzzy.foo")
+
+    assert_irb_help("Array#xyzzy",  "Array#xyzzy")
+    assert_irb_help("Array::xyzzy", "Array::xyzzy")
+    assert_irb_help("Array.xyzzy",  "Array.xyzzy")
+  end
+
+  def test_operators
+    # Ruby apparently optimizes away 2+2, that's awkward...
+    assert_irb_help("Fixnum#**"){ 2 ** 2 }
+    assert_irb_help("Float#**"){ 2.0 ** 2.0 }
+    assert_irb_help("Array#[]"){ [][] }
+    # =~ is instance method of Kernel, but is documented as instance method of Object
+    # assert_irb_help("Kernel#=~"){ [] =~ [] }
+    assert_irb_help("Kernel#=~"){ [] =~ [] }
+  end
+
+  def test_nil
+    assert_irb_help(nil)
+    assert_irb_help("NilClass"){ nil }
+    assert_irb_help("NilClass"){ }
+  end
+
+  def test_superclass
+    # superclass is a method of Class
+    # So Foo::superclass should find Class#superclass
+
+    assert_irb_help("Class#superclass"){ Float.superclass }
+    assert_irb_help("Class#superclass", "Float::superclass")
+    assert_irb_help("Class#superclass", "Float.superclass")
+
+    assert_irb_help("Class#superclass"){ Class.superclass }
+    assert_irb_help("Class#superclass"){ "Class.superclass" }
+    assert_irb_help("Class#superclass"){ "Class::superclass" }
+  end
+
+  def test_class_new
+    # Most classes do not override Class#new, but have
+    # Documentation for Foo.new anyway (it actually documents Foo#initialize)
+
+    # First, handling of Class#new (default creator of instances)
+    # and Class::new (creator of new classses)
+    assert_irb_help("Class::new"){ Class.new }
+    assert_irb_help("Class::new"){ Class::new }
+    assert_irb_help("Class#new",  "Class#new")
+    assert_irb_help("Class::new", "Class::new")
+    assert_irb_help("Class#new",  "Class.new")
+
+    # Module::new is documented and it uses default Class#new
+    assert_irb_help("Module::new"){ Module.new }
+    assert_irb_help("Module::new", "Module.new")
+    assert_irb_help("Module::new", "Module::new")
+
+    # IO::new is documented and it has separate implementation
+    assert_irb_help("IO::new"){ IO.new }
+    assert_irb_help("IO::new", "IO.new")
+    assert_irb_help("IO::new", "IO::new")
+
+    # File::new is documented and it uses IO::new
+    assert_irb_help("File::new"){ File.new }
+    assert_irb_help("File::new", "File.new")
+    assert_irb_help("File::new", "File::new")
+  end
+
+  # This tests work-arounds for bugs in Ruby documentation !!!
+  # In the perfect world it should totally fail !!!
+  def test_object_methods
+    # Documentation mixes some Kernel and Object methods
+
+    # Ruby has Kernel#__id__ but documentation has Object#__id__
+    assert_irb_help("BasicObject#__id__"){ __id__ }
+    assert_irb_help("BasicObject#__id__"){ 42.__id__ }
+    assert_irb_help("BasicObject#__id__", "Object#__id__")
+    assert_irb_help("BasicObject#__id__", "Object.__id__")
+    assert_irb_help("Kernel#__id__", "Kernel#__id__")
+    assert_irb_help("BasicObject#__id__", "Kernel.__id__")
+
+    # Ruby has Kernel#sprintf and documentation has Kernel#sprintf
+    assert_irb_help("Kernel#sprintf"){ sprintf }
+    assert_irb_help("Kernel#sprintf", "Object#sprintf")
+    assert_irb_help("Kernel#sprintf", "Object.sprintf")
+    assert_irb_help("Kernel#sprintf", "Kernel#sprintf")
+    assert_irb_help("Kernel#sprintf", "Kernel.sprintf")
+
+    # TODO: For completion - Object method documented in Object
+    # TODO: For completion - Object method documented in Kernel
+    # TODO: For completion - class methods of both
+  end
+
+  def test_method_missing
+    # Some fake method
+    assert_irb_help("Time::rfc999"){ Time::rfc999 }
+    assert_irb_help("Time::rfc999"){ Time.rfc999 } # is that really best ?
+    assert_irb_help("Time::rfc999", "Time::rfc999")
+    assert_irb_help("Time.rfc999", "Time.rfc999")
+  end
+
+  def test_method_missing_explicit
+    assert_irb_help("Kernel#method_missing", "Kernel#method_missing")
+    assert_irb_help("BasicObject#method_missing", "Kernel.method_missing")
+    assert_irb_help("BasicObject#method_missing", "Float#method_missing")
+    assert_irb_help("BasicObject#method_missing", "Float.method_missing")
+    assert_irb_help("BasicObject#method_missing"){ 42.method_missing }
+    assert_irb_help("BasicObject#method_missing"){ method_missing }
+  end
+
+  def test_longpath
+    assert_irb_help("File::Stat::new", "File::Stat.new")
+    assert_irb_help("File::Stat::new"){ File::Stat.new }
+    assert_irb_help("File::Stat::new"){ File::Stat::new }
+    fs = File::Stat.new(__FILE__)
+    assert_irb_help("File::Stat#size"){ fs.size }
+    assert_irb_help("File::Stat#size", "File::Stat#size")
+    assert_irb_help("File::Stat#size", "File::Stat.size")
+  end
+
+  def test_private
+    # help should ignore public/protected/private
+    # private is a private function of Module
+    assert_irb_help("Module#private", "Module#private")
+    assert_irb_help("Module#private", "Module.private")
+    assert_irb_help("Module#private", "Module::private")
+
+    assert_irb_help("Module#private", "Class#private")
+    assert_irb_help("Module#private", "Class.private")
+    assert_irb_help("Module#private", "Class::private")
+
+    assert_irb_help("Module#private", "Float.private")
+    assert_irb_help("Module#private", "Float::private")
+
+    assert_irb_help("Module::private"){ Module::private }
+    assert_irb_help("Module::private"){ Module.private }
+
+    assert_irb_help("Class::private"){ Class::private }
+    assert_irb_help("Class::private"){ Class.private }
+
+    assert_irb_help("Float::private"){ Float::private }
+    assert_irb_help("Float::private"){ Float.private }
+
+    assert_irb_help("String#singleton_method_added"){ "".singleton_method_added }
+    assert_irb_help("BasicObject#singleton_method_added"){ singleton_method_added }
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: magic-help
+version: !ruby/object:Gem::Version
+  version: '0.20170204'
+platform: ruby
+authors:
+- Tomasz Wegrzanowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: Tomasz.Wegrzanowski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/magic/help.rb
+- lib/magic/help/irb.rb
+- lib/magic/help/set_trace_func.rb
+- lib/magic/help/tracepoint.rb
+- lib/magic_help.rb
+- test/mass_test.rb
+- test/tc_magic_help.rb
+homepage: https://github.com/taw/magic-help
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Plugin for irb providing more intuitive documentation access.
+test_files:
+- test/mass_test.rb
+- test/tc_magic_help.rb