robe-server 1.0.2

data/lib/robe/scanners.rb

@@ -0,0 +1,49 @@
+require 'robe/core_ext'
+
+module Robe
+  class Scanner
+    attr_accessor :check_private
+    attr_reader :candidates
+
+    def initialize(sym, check_private)
+      @candidates = []
+      @sym = sym
+      @check_private = check_private
+    end
+
+    def scan(modules, check_instance, check_module)
+      modules.each do |m|
+        if check_module
+          sc = m.__singleton_class__
+          scan_methods(sc, :__instance_methods__)
+          scan_methods(sc, :__private_instance_methods__) if check_private
+        end
+        if check_instance
+          scan_methods(m, :__instance_methods__)
+          scan_methods(m, :__private_instance_methods__) if check_private
+        end
+      end
+    end
+  end
+
+  class ModuleScanner < Scanner
+    def scan_methods(mod, coll)
+      if mod.__send__(coll, false).include?(@sym)
+        candidates << mod.instance_method(@sym)
+      end
+    end
+  end
+
+  class MethodScanner < Scanner
+    def initialize(*args)
+      super
+      @re = /^#{Regexp.escape(@sym || "")}/
+    end
+
+    def scan_methods(mod, coll)
+      mod.__send__(coll, false).grep(@re) do |sym|
+        candidates << mod.instance_method(sym)
+      end
+    end
+  end
+end

data/lib/robe/server.rb

@@ -0,0 +1,87 @@
+require 'json'
+require 'tmpdir'
+require 'socket'
+require 'webrick'
+require 'logger'
+
+module Robe
+  class Server
+    attr_reader :running, :port
+
+    def initialize(handler, port)
+      @handler = handler
+      @server = TCPServer.new("127.0.0.1", port)
+      @running = true
+      @port = @server.addr[1]
+    end
+
+    def start
+      access = File.open("#{Dir.tmpdir}/robe-access-#{@port}.log", "w")
+      access.sync = true
+
+      error_logger = Logger.new($stderr)
+      access_logger = Logger.new(access)
+
+      client = nil
+
+      loop do
+        begin
+          client = @server.accept
+
+          next if client.eof?
+
+          req = WEBrick::HTTPRequest.new(:InputBufferSize => 1024,
+                                         :Logger => error_logger)
+          req.parse(client)
+          access_logger.info "#{req.request_method} #{req.path}"
+
+          begin
+            body = @handler.call(req.path, req.body)
+          rescue Exception => e
+            error_logger.error "Request failed: #{req.path}. Please file an issue."
+            error_logger.error "#{e.message}\n#{e.backtrace.join("\n")}"
+          end
+
+          resp = WEBrick::HTTPResponse.new(:OutputBufferSize => 1024,
+                                           :Logger => error_logger,
+                                           :HTTPVersion => "1.1")
+          resp.status = 200
+          resp.content_type = "application/json; charset=utf-8"
+          resp.body = body
+
+          begin
+            resp.send_response(client)
+            client.close
+          rescue Errno::EPIPE
+            error_logger.error "Connection lost, unsent response:"
+            error_logger.error body
+          end
+        rescue Errno::EINVAL
+          break
+        rescue IOError
+          # Hello JRuby
+          break
+        end
+      end
+    end
+
+    def wait_for_it
+      begin
+        TCPSocket.new("127.0.0.1", @port).close
+      rescue
+        sleep 0.05
+        retry
+      end
+    end
+
+    def shutdown
+      @running = false
+      begin
+        @server && @server.shutdown(Socket::SHUT_RDWR)
+      rescue Errno::ENOTCONN
+        # Hello JRuby
+        @server.close
+      end
+    end
+  end
+end

data/lib/robe/type_space.rb

@@ -0,0 +1,57 @@
+require 'robe/sash'
+
+module Robe
+  class TypeSpace
+    attr_reader :visor, :target_type, :instance
+
+    def initialize(visor, target, mod, instance, superc)
+      @visor = visor
+      @instance = instance
+      @superc = superc
+      guess_target_type(target, mod)
+    end
+
+    def scan_with(scanner)
+      return unless obj = target_type
+      modules = obj.ancestors
+      modules -= obj.included_modules unless instance
+
+      if @superc
+        modules -= [obj]
+      else
+        modules += visor.descendants(obj).to_a
+      end
+
+      modules.push(Kernel) if instance && !obj.is_a?(Class)
+
+      if instance
+        if defined? ActiveSupport::Concern and obj.is_a?(ActiveSupport::Concern)
+          deps = obj.instance_variable_get("@_dependencies")
+          modules += deps if deps
+        end
+      end
+
+      scanner.scan(modules, instance, !instance)
+
+      unless instance
+        singleton_ancestors = obj.singleton_class.ancestors
+
+        if RUBY_VERSION >= "2.1.0"
+          # Ruby 2.1 includes all singletons in the ancestors chain
+          singleton_ancestors.reject!(&:__singleton_class__?)
+        end
+
+        scanner.scan(singleton_ancestors, true, false)
+      end
+    end
+
+    private
+
+    def guess_target_type(target, mod)
+      @target_type = visor.resolve_context(target, mod)
+      if @target_type && !(@target_type.is_a? Module)
+        @target_type, @instance = @target_type.class, true
+      end
+    end
+  end
+end

data/lib/robe/visor.rb

@@ -0,0 +1,56 @@
+require 'forwardable'
+
+module Robe
+  class Visor
+    extend Forwardable
+
+    def each_object(*args)
+      ObjectSpace.each_object(*args).reject { |m| m.__singleton_class__? }
+    end
+
+    def descendants(cls)
+      each_object(cls.singleton_class).to_a - [cls]
+    end
+
+    def resolve_context(name, mod)
+      return resolve_const(mod) unless name
+      unless name =~ /\A::/
+        nesting = mod ? mod.split("::") : []
+        resolve_path_elems(nesting).reverse.each do |elem|
+          begin
+            return elem.const_get(name)
+          rescue NameError
+          end
+        end
+      end
+      resolve_const(name)
+    end
+
+    def resolve_const(name)
+      resolve_path(name).last
+    end
+
+    def resolve_path(name)
+      return [] unless name
+      return [ARGF.class] if name == "ARGF.class"
+      if %w(IO::readable IO::writable).include?(name)
+        return [StringIO.included_modules.find { |m| m.name == name }]
+      end
+      nesting = name.split("::")
+      nesting.shift if nesting[0].empty?
+      resolve_path_elems(nesting)
+    end
+
+    def resolve_path_elems(nesting, init = Object)
+      c = init; ary = []
+      begin
+        nesting.each do |name|
+          ary << (c = c.const_get(name))
+        end
+        ary
+      rescue NameError
+        []
+      end
+    end
+  end
+end

data/robe-server.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |gem|
+  gem.name = 'robe-server'
+  gem.version = '1.0.2'
+  gem.authors = 'Phil Hagelberg, Dmitry Gutov, Alexsey Ermolaev'
+  gem.email = 'afay.zangetsu@gmail.com'
+  gem.homepage = 'https://github.com/AfsmNGhr/robe-server'
+  gem.description = 'Server for robe'
+  gem.summary = 'Code navigation, documentation lookup and completion for Ruby'
+  gem.license = 'GPL-3.0'
+
+  gem.add_development_dependency 'rake', '~> 10.3'
+  gem.add_development_dependency 'rspec', '~> 2.14'
+
+  gem.files = `git ls-files`.split("\n")
+  gem.require_paths = ['lib']
+  gem.test_files = gem.files.grep(%r{^(test|spec|features)/})
+
+  gem.extra_rdoc_files = ['LICENSE', 'README.md']
+end

data/spec/robe/jvisor_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'robe/jvisor'
+
+describe Robe::JVisor do
+  subject { Robe::JVisor.new }
+
+  it "iterates though all native classes" do
+    res = subject.each_object(Module)
+    expect(res).to include(String)
+    expect(res).to include(Set)
+    expect(res).to include(Enumerable)
+  end
+
+  it "returns only modules responding to :name and :instance_methods" do
+    res = subject.each_object(Module)
+    expect(res.all? { |m| m.respond_to? :name }).to be_true
+    expect(res.all? { |m| m.respond_to? :instance_methods }).to be_true
+  end
+
+  it "returns descendants of a module" do
+    res = subject.descendants(Enumerable)
+    expect(res).to include(Array)
+    expect(res).not_to include(String)
+  end
+
+  it "returns descendants of a class" do
+    res = subject.descendants(Integer)
+    expect(res).to match_array([Bignum, Fixnum])
+  end
+end

data/spec/robe/method_scanner_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'robe/scanners'
+
+describe Robe::MethodScanner do
+  include ScannerHelper
+
+  klass = described_class
+
+  let(:a) { new_module(:f, :b, :b, :t) }
+  let(:b) { new_module(:bar, :foo, :baz, :tee) }
+  let(:c) { new_module(:foo, :bar, :baz, :tee) }
+  let(:d) { new_module(:foo, :bar, :tee, :baz) }
+  let(:modules) { [a, b, c, d] }
+
+  it "completes instance methods" do
+    scanner = klass.new(:f, false)
+    scanner.scan(modules, true, false)
+    expect(scanner.candidates).to have_names(:f, :foo, :foo)
+  end
+
+  it "completes module methods" do
+    scanner = klass.new(:b, false)
+    scanner.scan(modules, false, true)
+    expect(scanner.candidates).to have_names(:b, :bar, :bar)
+  end
+
+  it "completes private instance methods" do
+    scanner = klass.new(:baz, true)
+    scanner.scan(modules, true, false)
+    expect(scanner.candidates).to have_names(:baz, :baz)
+  end
+
+  it "completes private module methods" do
+    scanner = klass.new(:tee, true)
+    scanner.scan(modules, false, true)
+    expect(scanner.candidates).to have_names(:tee, :tee)
+  end
+
+  it "completes nothing when shouldn't" do
+    scanner = klass.new(:foo, true)
+    scanner.scan(modules, false, false)
+    expect(scanner.candidates).to be_empty
+  end
+
+  RSpec::Matchers.define :have_names do |*names|
+    match do |candidates|
+      candidates.map(&:name) == names
+    end
+  end
+end

data/spec/robe/module_scanner_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'robe/scanners'
+
+describe Robe::ModuleScanner do
+  include ScannerHelper
+
+  klass = described_class
+
+  let(:a) { new_module(:foo, :bar, :baz, :tee) }
+  let(:b) { new_module(:bar, :foo, :baz, :tee) }
+  let(:c) { new_module(:foo, :bar, :tee, :baz) }
+  let(:d) { new_module(:bar, :foo, :tee, :baz) }
+  let(:e) { Module.new }
+  let(:modules) { [a, b, c, d, e ] }
+
+  it "finds instance methods" do
+    scanner = klass.new(:foo, false)
+    scanner.scan(modules, true, false)
+    expect(scanner.candidates).to eq [a, c].map { |s| s.instance_method(:foo) }
+  end
+
+  it "finds module methods" do
+    scanner = klass.new(:foo, false)
+    scanner.scan(modules, false, true)
+    expect(scanner.candidates).to eq [b, d].map { |s| s.method(:foo).unbind }
+  end
+
+  it "find private instance methods" do
+    scanner = klass.new(:baz, true)
+    scanner.scan(modules, true, false)
+    expect(scanner.candidates).to eq [a, b].map { |s| s.instance_method(:baz) }
+  end
+
+  it "finds private module methods" do
+    scanner = klass.new(:tee, true)
+    scanner.scan(modules, false, true)
+    expect(scanner.candidates).to eq [a, b].map { |s| s.method(:tee).unbind }
+  end
+
+  it "finds nothing when shouldn't" do
+    scanner = klass.new(:foo, true)
+    scanner.scan(modules, false, false)
+    expect(scanner.candidates).to eq []
+  end
+
+  it "finds both types when should" do
+    scanner = klass.new(:foo, false)
+    scanner.scan(modules, true, true)
+    expect(scanner.candidates).to eq([a.instance_method(:foo),
+        b.method(:foo).unbind, c.instance_method(:foo), d.method(:foo).unbind])
+  end
+
+  it "doesn't include methods from Module in module methods" do
+    scanner = klass.new(:attr, true)
+    scanner.scan([Module.new], true, true)
+    expect(scanner.candidates).to be_empty
+  end
+
+  it "doesn't pay attention to overridden [private_]instance_methods" do
+    tiff = new_module(:foo, :bar, :bar, :foo)
+
+    tiff = Module.new do
+      def self.instance_methods(_ign)
+        [:fool, :me, :once]
+      end
+
+      def self.private_instance_methods(_ign)
+        [:fool, :me, :twice]
+      end
+    end
+
+    scanner = klass.new(:fool, true)
+    scanner.scan([tiff], true, true)
+    expect(scanner.candidates).to be_empty
+  end
+end

data/spec/robe/sash/doc_for_spec.rb

@@ -0,0 +1,165 @@
+require 'robe/sash/doc_for'
+require 'uri'
+require 'active_support/core_ext/kernel' # https://github.com/pry/pry-doc/issues/16
+
+describe Robe::Sash::DocFor do
+  klass = described_class
+
+  it "returns hash for a basic class" do
+    c = Class.new do
+      # Some words.
+      def quux(a, *b, &c); end
+    end
+
+    k = klass.new(c.instance_method(:quux))
+    expect(k.format).to eq({docstring: "Some words.\n",
+                            source: "def quux(a, *b, &c); end\n",
+                            aliases: [],
+                            visibility: :public})
+  end
+
+  it "shows docs for built-in classes" do
+    hash = klass.new(Hash.instance_method(:update)).format
+    expect(hash[:aliases]).to eq([:merge!])
+    if RUBY_ENGINE == "ruby"
+      expect(hash[:docstring]).to include("Adds the contents")
+      expect(hash[:source]).to include("rb_hash_foreach")
+    else
+      expect(hash[:docstring]).to eq("")
+      expect(hash[:source]).to start_with("def merge!(other)\n")
+    end
+  end
+
+  it "shows docs for stdlib classes" do
+    hash = klass.new(URI.method(:parse)).format
+    expect(hash[:docstring]).to include("one of the URI's subclasses")
+  end
+
+  it "returns private visibility for Kernel#puts" do
+    expect(klass.new(Kernel.instance_method(:puts)).format[:visibility])
+      .to eq(:private)
+  end
+
+  it "returns public visibility for Kernel.puts" do
+    # And doesn't do "Scanning and caching *.c files".
+    expect(klass.new(Kernel.method(:puts)).format[:visibility]).to eq(:public)
+  end
+
+  it "returns protected visibility" do
+    method = Class.new.class_exec do
+      protected
+      def foo; end
+      instance_method(:foo)
+    end
+    expect(klass.new(method).format[:visibility]).to be(:protected)
+  end
+
+  it "mentions pry-doc when relevant" do
+    val = Pry.config.has_pry_doc
+    Pry.config.has_pry_doc = false
+    struct = described_class.method_struct(String.instance_method(:gsub))
+    Pry.config.has_pry_doc = val
+
+    if RUBY_ENGINE == "ruby"
+      expect(struct.source).to be_nil
+      expect(struct.docstring).to match(/pry-doc/)
+    else
+      expect(struct.docstring).to eq("")
+      expect(struct.source).to start_with("def gsub(")
+    end
+  end
+
+  context "native methods" do
+    let(:c) { described_class }
+
+    context "String#gsub info fields" do
+      let(:struct) { c.method_struct(String.instance_method(:gsub)) }
+
+      if RUBY_ENGINE == "ruby"
+        it { expect(struct.docstring).to start_with("Returns")}
+        it { expect(struct.source).to start_with("static VALUE") }
+      else
+        it { expect(struct.docstring).to eq("") }
+        it { expect(struct.source).to start_with("def gsub(") }
+      end
+    end
+
+    context "Array#map has an alias" do
+      let(:struct) { c.method_struct(Array.instance_method(:map)) }
+      it { expect(struct.aliases).to eq([:collect])}
+    end
+
+    context "Set#include? has an alias" do
+      let(:struct) { c.method_struct(Set.instance_method(:include?)) }
+      it { expect(struct.aliases).to eq([:member?])}
+    end
+
+    context "Know the appropriate amount about Kernel#is_a?" do
+      let(:struct) { c.method_struct(Kernel.instance_method(:is_a?)) }
+
+      it { expect(struct.visibility).to be_nil }
+
+      if RUBY_ENGINE == "ruby"
+        it { expect(struct.docstring).to include("one of the superclasses") }
+        it { expect(struct.aliases).to eq([:kind_of?]) }
+        it { expect(struct.source).to start_with("VALUE\nrb_obj_is_kind_of") }
+      else
+        it { expect(struct.docstring).to include("class or superclass") }
+        it { expect(struct.aliases).to eq([:kind_of?]) }
+        it { expect(struct.source).to start_with("def kind_of?(") }
+      end
+    end
+  end
+
+  context "pure methods" do
+    let(:c) { described_class }
+
+    context "method quux defined" do
+      # First line,
+      # second line.
+      def quux(n)
+      end
+
+      it "has the docstring" do
+        expect(c.method_struct(method(:quux)).docstring).to eq("First line,\n" +
+                                                               "second line.\n")
+      end
+
+      it "has the source" do
+        expect(c.method_struct(method(:quux)).source).to eq("def quux(n)\nend\n")
+      end
+
+      it "has no aliases" do
+        expect(c.method_struct(method(:quux)).aliases).to eq([])
+      end
+    end
+
+    it "should return the source for one-line methods" do
+      def xuuq(); end
+      expect(c.method_struct(method(:xuuq)).source).to eq("def xuuq(); end\n")
+    end
+
+    it "should return empty docstring when none" do
+      def xuuq(m)
+      end
+
+      struct = c.method_struct(method(:xuuq))
+      expect(struct.docstring).to eq("")
+      expect(struct.source).not_to be_empty
+    end
+  end
+
+  context "dynamically defined" do
+    let(:kls) { eval "Class.new do;def foo;42;end;end" }
+    let(:c) { described_class }
+
+    it "returns no docstring" do
+      expect(c.method_struct(kls.instance_method(:foo)).docstring).to be_empty
+    end
+
+    it "returns comment about dynamic definition as the source" do
+      expect(c.method_struct(kls.instance_method(:foo)).source)
+        .to include("outside of a source file")
+    end
+  end
+end