pry-doc 0.6.0 → 1.3.0

data/lib/pry-doc/pry_ext/show_source_with_c_internals.rb

@@ -0,0 +1,54 @@
+require_relative "show_source_with_c_internals/code_fetcher"
+
+module Pry::CInternals
+  class ShowSourceWithCInternals < Pry::Command::ShowSource
+    def options(opt)
+      super(opt)
+      opt.on :c, "c-source", "Show source of a C identifier in MRI (rather than Ruby method of same name)"
+    end
+
+    def show_c_source
+      if opts.present?(:all)
+        result, file = CodeFetcher.new(line_number_style: line_number_style)
+                         .fetch_all_definitions(obj_name)
+      else
+        result, file = CodeFetcher.new(line_number_style: line_number_style)
+                         .fetch_first_definition(obj_name)
+      end
+      if result
+        set_file_and_dir_locals(file)
+        pry_instance.pager.page result
+      else
+        raise Pry::CommandError, no_definition_message
+      end
+    end
+
+    def process
+      if opts.present?(:c) && !pry_instance.config.skip_cruby_source
+        show_c_source
+        return
+      else
+        super
+      end
+    rescue Pry::CommandError
+      raise if pry_instance.config.skip_cruby_source
+      show_c_source
+    end
+
+    private
+
+    # We can number lines with their actual line numbers
+    # or starting with 1 (base-one)
+    def line_number_style
+      if opts.present?(:'base-one')
+        :'base-one'
+      elsif opts.present?(:'line-numbers')
+        :'line-numbers'
+      else
+        nil
+      end
+    end
+
+    Pry::Commands.add_command(ShowSourceWithCInternals)
+  end
+end

data/lib/pry-doc/version.rb

@@ -1,3 +1,3 @@
 module PryDoc
-  VERSION = '0.6.0'
+  VERSION = '1.3.0'.freeze
 end

data/lib/pry-doc.rb

@@ -1,232 +1,26 @@
-# pry-doc.rb
-# (C) John Mair (banisterfiend); MIT license
-
-direc = File.dirname(__FILE__)
-
-require "#{direc}/pry-doc/version"
-require "yard"
-
 module PryDoc
-
   def self.load_yardoc(version)
-    path = "#{File.dirname(__FILE__)}/pry-doc/core_docs_#{ version }"
-    YARD::Registry.load_yardoc(path)
-  end
-
-end
-
-case RUBY_VERSION
-when /\A2\.1/
-  PryDoc.load_yardoc('21')
-when /\A2\.0/
-  PryDoc.load_yardoc('20')
-else
-  PryDoc.load_yardoc('19')
-end
-
-class Pry
-
-  # do not use pry-doc if rbx is active
-  if !Object.const_defined?(:RUBY_ENGINE) || RUBY_ENGINE !~ /rbx/
-    self.config.has_pry_doc = true
-  end
-
-  module MethodInfo
-
-    # Convert a method object into the `Class#method` string notation.
-    # @param [Method, UnboundMethod] meth
-    # @return [String] The method in string receiver notation.
-    # @note This mess is needed in order to support all the modern Rubies. YOU
-    #   must figure out a better way to distinguish between class methods and
-    #   instance methods.
-    def self.receiver_notation_for(meth)
-      match = meth.inspect.match(/\A#<(?:Unbound)?Method: (.+)([#\.].+)>\z/)
-      owner = meth.owner.to_s.sub(/#<.+?:(.+?)>/, '\1')
-      name = match[2]
-      name.sub!('#', '.') if match[1] =~ /\A#<Class:/
-      owner + name
+    path = "#{File.dirname(__FILE__)}/pry-doc/docs/#{version}"
+    unless File.directory?(path)
+      puts "#{RUBY_ENGINE}/#{RUBY_VERSION} isn't supported by this pry-doc version"
     end
 
-    # Retrives aliases of a method
-    # @param [Method, UnboundMethod] meth The method object.
-    # @return [Array] The aliases of a method if it exists
-    #                 otherwise, return empty array
-    def self.aliases(meth)
-      host        = is_singleton?(meth) ? meth.receiver : meth.owner
-      method_type = is_singleton?(meth) ? :method : :instance_method
-
-      methods = Pry::Method.send(:all_from_common, host, method_type, false).
-                            map { |m| m.instance_variable_get(:@method) }
-
-      methods.select { |m| host.send(method_type,m.name) == host.send(method_type,meth.name) }.
-              reject { |m| m.name == meth.name }.
-              map    { |m| host.send(method_type,m.name) }
-    end
+    # Do not use pry-doc if Rubinius is active.
+    Pry.config.has_pry_doc = RUBY_ENGINE !~ /rbx/
 
-    # Checks whether method is a singleton (i.e class method)
-    # @param [Method, UnboundMethod] meth
-    # @param [Boolean] true if singleton
-    def self.is_singleton?(meth)
-      receiver_notation_for(meth).include?('.')
-    end
-
-    # Check whether the file containing the method is already cached.
-    # @param [Method, UnboundMethod] meth The method object.
-    # @return [Boolean] Whether the method is cached.
-    def self.cached?(meth)
-      !!registry_lookup(meth)
-    end
-
-    def self.registry_lookup(meth)
-      obj = YARD::Registry.at(receiver_notation_for(meth))
-      if obj.nil?
-        if !(aliases = aliases(meth)).empty?
-          obj = YARD::Registry.at(receiver_notation_for(aliases.first))
-        elsif meth.owner == Kernel
-          # YARD thinks that some methods are on Object when
-          # they're actually on Kernel; so try again on Object if Kernel fails.
-          obj = YARD::Registry.at("Object##{meth.name}")
-        end
-      end
-      obj
-    end
-
-    # Retrieve the YARD object that contains the method data.
-    # @param [Method, UnboundMethod] meth The method object.
-    # @return [YARD::CodeObjects::MethodObject] The YARD data for the method.
-    def self.info_for(meth)
-      cache(meth)
-      registry_lookup(meth)
-    end
-
-    # Determine whether a method is an eval method.
-    # @return [Boolean] Whether the method is an eval method.
-    def self.is_eval_method?(meth)
-      file, _ = meth.source_location
-      if file =~ /(\(.*\))|<.*>/
-        true
-      else
-        false
-      end
-    end
-
-    # Attempts to find the c source files if method belongs to a gem
-    # and use YARD to parse and cache the source files for display
-    #
-    # @param [Method, UnboundMethod] meth The method object.
-    def self.parse_and_cache_if_gem_cext(meth)
-      if gem_dir = find_gem_dir(meth)
-        if c_files_found?(gem_dir)
-          warn "Scanning and caching *.c files..."
-          YARD.parse("#{gem_dir}/**/*.c")
-        end
-      end
-    end
-
-    # @param [String] root directory path of gem that method belongs to
-    # @return [Boolean] true if c files exist?
-    def self.c_files_found?(gem_dir)
-      Dir.glob("#{gem_dir}/**/*.c").count > 0
-    end
-
-    # @return [Object] The host of the method (receiver or owner).
-    def self.method_host(meth)
-      is_singleton?(meth) && Module === meth.receiver ? meth.receiver : meth.owner
-    end
-
-    # FIXME: this is unnecessarily limited to ext/ and lib/ folders
-    # @return [String] The root folder of a given gem directory.
-    def self.gem_root(dir)
-      if index = dir.rindex(/\/(?:lib|ext)(?:\/|$)/)
-        dir[0..index-1]
-      end
-    end
-
-    # @param [Method, UnboundMethod] meth The method object.
-    # @return [String] root directory path of gem that method belongs to,
-    #                  nil if could not be found
-    def self.find_gem_dir(meth)
-      host = method_host(meth)
-
-      begin
-        host_source_location, _ =  WrappedModule.new(host).source_location
-        break if host_source_location != nil
-        return unless host.name
-        host = eval(host.namespace_name)
-      end while host
-
-      # we want to exclude all source_locations that aren't gems (i.e
-      # stdlib)
-      if host_source_location && host_source_location =~ %r{/gems/}
-        gem_root(host_source_location)
-      else
-
-        # the WrappedModule approach failed, so try our backup approach
-        gem_dir_from_method(meth)
-      end
-    end
-
-    # Try to guess what the gem name will be based on the name of the module.
-    # We try a few approaches here depending on the `guess` parameter.
-    # @param [String] name The name of the module.
-    # @param [Fixnum] guess The current guessing approach to use.
-    # @return [String, nil] The guessed gem name, or `nil` if out of guesses.
-    def self.guess_gem_name_from_module_name(name, guess)
-      case guess
-      when 0
-        name.downcase
-      when 1
-        name.scan(/[A-Z][a-z]+/).map(&:downcase).join('_')
-      when 2
-        name.scan(/[A-Z][a-z]+/).map(&:downcase).join('_').sub("_", "-")
-      when 3
-        name.scan(/[A-Z][a-z]+/).map(&:downcase).join('-')
-      when 4
-        name
-      else
-        nil
-      end
-    end
-
-    # Try to recover the gem directory of a gem based on a method object.
-    # @param [Method, UnboundMethod] meth The method object.
-    # @return [String, nil] The located gem directory.
-    def self.gem_dir_from_method(meth)
-      guess = 0
-
-      host = method_host(meth)
-      return unless host.name
-      root_module_name = host.name.split("::").first
-      while gem_name = guess_gem_name_from_module_name(root_module_name, guess)
-        matches = $LOAD_PATH.grep %r{/gems/#{gem_name}} if !gem_name.empty?
-        if matches && matches.any?
-          return gem_root(matches.first)
-        else
-          guess += 1
-        end
-      end
-
-      nil
-    end
+    YARD::Registry.load_yardoc(path)
+  end
 
-    # Cache the file that holds the method or return immediately if file is
-    # already cached. Return if the method cannot be cached -
-    # i.e is a C stdlib method.
-    # @param [Method, UnboundMethod] meth The method object.
-    def self.cache(meth)
-      file, _ = meth.source_location
+  def self.root
+    @root ||= File.expand_path(File.dirname(__dir__))
+  end
 
-      return if is_eval_method?(meth)
-      return if cached?(meth)
+  root
+end
 
-      if !file
-        parse_and_cache_if_gem_cext(meth)
-        return
-      end
+require 'yard'
+require 'pry'
+require 'pry-doc/version'
+require 'pry-doc/pry_ext/method_info'
 
-      log.enter_level(Logger::FATAL) do
-        YARD.parse(file)
-      end
-    end
-  end
-end
+PryDoc.load_yardoc(RUBY_VERSION[0...3].sub!('.', ''))

data/pry-doc.gemspec

@@ -20,8 +20,11 @@ DESCR
   s.require_paths = ["lib"]
   s.files = `git ls-files`.split("\n")
 
-  s.add_dependency 'yard', "~> 0.8"
-  s.add_dependency 'pry', "~> 0.9"
-  s.add_development_dependency 'latest_ruby', "~> 0.0"
-  s.add_development_dependency 'bacon', "~> 1.1"
+  s.required_ruby_version = '>= 2.0'
+
+  s.add_dependency 'yard', "~> 0.9.11"
+  s.add_dependency 'pry', "~> 0.11"
+  s.add_development_dependency 'latest_ruby', '~> 3.1'
+  s.add_development_dependency 'rspec', '~> 3.5'
+  s.add_development_dependency 'rake', "~> 10.0"
 end

data/spec/fixtures/c_source/TAGS

@@ -0,0 +1,22 @@
+
+goodbye.c,9
+foo(2,5
+
+hello.c,309
+foo(2,4
+#define baby 5,19
+typedef int wassup;9,73
+enum bar 11,94
+  alpha,12,105
+  beta,13,114
+  gamma14,122
+struct baz 17,134
+typedef enum cute_enum_e 22,169
+  lillybing,23,196
+  tote,24,209
+  lilt25,217
+} baby_enum;26,224
+} cutie_pie;31,283
+void tinkywinky(33,297
+void lala(36,324
+po(41,350

data/spec/fixtures/c_source/goodbye.c

@@ -0,0 +1,4 @@
+char
+foo(int*) {
+  return 'a';
+}

data/spec/fixtures/c_source/hello.c

@@ -0,0 +1,43 @@
+int
+foo(void) {
+}
+
+#define baby do { \
+  printf("baby"); \
+  } while(0)
+
+typedef int wassup;
+
+enum bar {
+  alpha,
+  beta,
+  gamma
+};
+
+struct baz {
+  int x;
+  int y;
+};
+
+typedef enum cute_enum_e {
+  lillybing,
+  tote,
+  lilt
+} baby_enum;
+
+typedef struct {
+  int lovely;
+  char horse;
+} cutie_pie;
+
+void tinkywinky(void) {
+}
+
+void lala(void)
+{
+}
+
+int*
+po(void)
+{
+}

data/spec/gem_with_cext/gems/ext/sample.c

@@ -1,8 +1,8 @@
 #include "ruby.h"
 
-static VALUE unlink(VALUE self)
+static VALUE gleezor(VALUE self)
 {
-  return 1;
+  return INT2FIX(1);
 }
 
 void Init_sample(void)
@@ -11,9 +11,7 @@ void Init_sample(void)
   VALUE A = rb_define_module_under(klass, "A");
   VALUE B = rb_define_module_under(A, "B");
 
-  rb_define_method(klass, "unlink", unlink, 0);
-  rb_define_method(B, "unlink", unlink, 0);
-  rb_define_singleton_method(B, "unlink", unlink, 0);
+  rb_define_method(klass, "gleezor", gleezor, 0);
+  rb_define_method(B, "gleezor", gleezor, 0);
+  rb_define_singleton_method(B, "gleezor", gleezor, 0);
 }
-
-

data/spec/gem_with_cext/gems/lib/sample.rb

@@ -3,16 +3,16 @@ class Sample
   def some_meth; end
 
   # aliasing a C method
-  alias :remove :unlink
+  alias :remove :gleezor
 
   protected
 
-  def unlink_1; end
-  alias :remove_1 :unlink_1
+  def gleezor_1; end
+  alias :remove_1 :gleezor_1
 
   private
 
-  def unlink_2; end
+  def gleezor_2; end
 
-  alias :remove_2 :unlink_2
+  alias :remove_2 :gleezor_2
 end

data/spec/helper.rb

@@ -1,3 +1,11 @@
+require 'pry-doc'
+
+RSpec.configure do |c|
+  c.order = 'random'
+  c.color = true
+  c.disable_monkey_patching!
+end
+
 direc = File.dirname(__FILE__)
 
 class C
@@ -8,4 +16,3 @@ puts
 puts "Building Sample Gem with C Extensions for testing.."
 system("cd #{direc}/gem_with_cext/gems/ext/ && ruby extconf.rb && make")
 puts
-