robe-server 1.0.2

data/README.md

@@ -0,0 +1,21 @@
+## Robe server
+
+[![Gem Version](https://badge.fury.io/rb/robe-server.svg)](https://badge.fury.io/rb/robe-server)
+[![Build Status](https://travis-ci.org/AfsmNGhr/robe-server.svg?branch=master)](https://travis-ci.org/AfsmNGhr/robe-server "Build status from Travis CI")
+[![Coverage Status](https://coveralls.io/repos/github/AfsmNGhr/robe-server/badge.svg?branch=master)](https://coveralls.io/github/AfsmNGhr/robe-server?branch=master)
+
+Server for [robe](https://github.com/dgutov/robe)
+
+## Install
+
+```.ruby
+# Gemfile
+
+gem 'robe-server'
+```
+
+or
+
+```.bash
+$ gem install robe-server
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = false
+  t.fail_on_error = false
+end
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/lib/robe-server.rb

@@ -0,0 +1,39 @@
+require 'robe/sash'
+require 'robe/server'
+
+module Robe
+  class << self
+    attr_accessor :server
+
+    def start(port = 0)
+      return running_string if @server
+
+      @server = Server.new(Sash.new, port)
+
+      ['INT', 'TERM'].each do |signal|
+        trap(signal) { stop }
+      end
+      Thread.new do
+        unless Thread.current[:__yard_registry__]
+          Thread.current[:__yard_registry__] = Thread.main[:__yard_registry__]
+        end
+        @server.start
+      end
+
+      @server.wait_for_it
+
+      running_string
+    end
+
+    def stop
+      @server.shutdown
+      @server = nil
+    end
+
+    private
+
+    def running_string
+      "robe on #{@server.port}"
+    end
+  end
+end

data/lib/robe/core_ext.rb

@@ -0,0 +1,37 @@
+class Module
+  unless method_defined?(:__name__)
+    alias_method :__name__, :name
+  end
+
+  if method_defined?(:singleton_class?)
+    alias_method :__singleton_class__?, :singleton_class?
+  else
+    def __singleton_class__?
+      self != Class && ancestors.first != self
+    end
+  end
+
+  unless method_defined?(:__singleton_class__)
+    alias_method :__singleton_class__, :singleton_class
+  end
+
+  unless method_defined?(:__include__?)
+    alias_method :__include__?, :include?
+  end
+
+  unless method_defined?(:__instance_methods__)
+    alias_method :__instance_methods__, :instance_methods
+  end
+
+  unless method_defined?(:__public_instance_methods__)
+    alias_method :__public_instance_methods__, :public_instance_methods
+  end
+
+  unless method_defined?(:__protected_instance_methods__)
+    alias_method :__protected_instance_methods__, :protected_instance_methods
+  end
+
+  unless method_defined?(:__private_instance_methods__)
+    alias_method :__private_instance_methods__, :private_instance_methods
+  end
+end

data/lib/robe/jvisor.rb

@@ -0,0 +1,14 @@
+require 'robe/visor'
+
+module Robe
+  class JVisor < Visor
+    def each_object(mod)
+      # http://jira.codehaus.org/browse/JRUBY-7027
+      ObjectSpace.each_object(mod).select { |m| m.respond_to? :name }
+    end
+
+    def descendants(cls)
+      ObjectSpace.each_object(Class).select { |c| c < cls }
+    end
+  end
+end

data/lib/robe/sash.rb

@@ -0,0 +1,215 @@
+require 'robe/sash/doc_for'
+require 'robe/type_space'
+require 'robe/scanners'
+require 'robe/visor'
+require 'robe/jvisor'
+require 'robe/core_ext'
+require 'robe/sash/includes_tracker'
+
+module Robe
+  class Sash
+    attr_accessor :visor, :name_cache
+
+    def initialize(visor = pick_visor)
+      @visor = visor
+      init_name_cache
+    end
+
+    def class_locations(name, mod)
+      locations = {}
+      if (obj = visor.resolve_context(name, mod)) and obj.is_a? Module
+        methods = obj.methods(false).map { |m| obj.method(m) } +
+                  obj.__instance_methods__(false).map { |m| obj.instance_method(m) }
+        methods.each do |m|
+          if loc = m.source_location
+            path = loc[0]
+            locations[path] ||= 0
+            locations[path] += 1
+          end
+        end
+      end
+      if defined? Class.class_attribute and Class != obj
+        locations.delete Class.method(:class_attribute).source_location[0]
+      end
+      locations.keys.sort { |k1, k2| -(locations[k1] <=> locations[k2]) }
+    end
+
+    def modules
+      visor.each_object(Module).map { |mod| name_cache[mod] }.compact
+    end
+
+    def targets(obj)
+      obj = visor.resolve_const(obj)
+      if obj.is_a? Module
+        module_methods = obj.methods.map { |m| method_spec(obj.method(m)) }
+        instance_methods = (obj.__instance_methods__ +
+                            obj.__private_instance_methods__(false))
+          .map { |m| method_spec(obj.instance_method(m)) }
+        [name_cache[obj]] + module_methods + instance_methods
+      else
+        self.targets(obj.class.to_s)
+      end
+    end
+
+    def find_method(mod, inst, sym)
+      mod.__send__(inst ? :instance_method : :method, sym)
+    end
+
+    def find_method_owner(mod, inst, sym)
+      begin
+        find_method(mod, inst, sym).owner
+      rescue NameError
+      end
+    end
+
+    def method_spec(method)
+      owner, inst = method.owner, nil
+      if owner.__singleton_class__?
+        name = owner.to_s[/Class:([A-Z][^\(> ]*)/, 1] # defined in an eigenclass
+      elsif name = name_cache[owner]
+        inst = true
+      elsif !owner.is_a?(Class)
+        name, inst = IncludesTracker.method_owner_and_inst(owner, name_cache)
+      end
+      # XXX: We can speed this up further by only returning the
+      # method's (or owner's) object_id here, and resolve the "real"
+      # host's name only when it's really needed. But that would break
+      # the current 'meta' impl in company-robe, for one thing.
+      [name, inst, method.name, method.parameters] + method.source_location.to_a
+    end
+
+    def doc_for(mod, inst, sym)
+      resolved = visor.resolve_const(mod)
+      DocFor.new(find_method(resolved, inst, sym.to_sym)).format
+    end
+
+    def method_targets(name, target, mod, instance, superc, conservative)
+      sym = name.to_sym
+      space = TypeSpace.new(visor, target, mod, instance, superc)
+      special_method = superc
+
+      scanner = ModuleScanner.new(sym, special_method || !target)
+
+      space.scan_with(scanner)
+      targets = scanner.candidates
+
+      if targets
+        targets.delete(Class.instance_method(:new))
+        filter_targets!(space, targets, instance, sym)
+      end
+
+      sc = space.target_type.singleton_class
+
+      if !instance && (sym == :new) && targets.all? { |t| t.owner < sc }
+        ctor_space   = TypeSpace.new(visor, target, mod, true, superc)
+        ctor_scanner = ModuleScanner.new(:initialize, true)
+        ctor_space.scan_with(ctor_scanner)
+        ctor_targets = ctor_scanner.candidates
+        filter_targets!(ctor_space, ctor_targets, true, :initialize)
+        targets += ctor_targets
+      end
+
+      if targets.empty? && (target || !conservative) && !special_method
+        unless target
+          scanner.scan_methods(Kernel, :__private_instance_methods__)
+        end
+        scanner.check_private = false
+        scanner.scan(visor.each_object(Module), true, true)
+        targets = scanner.candidates
+      end
+
+      targets.map { |method| method_spec(method) }
+        .sort_by { |(mname)| mname ? mname.scan(/::/).length : 99 }
+    end
+
+    def filter_targets!(space, targets, instance, sym)
+      owner = find_method_owner(space.target_type, instance, sym)
+      if owner
+        targets.reject! do |method|
+          !(method.owner <= owner) &&
+            targets.find { |other| other.owner < method.owner }
+        end
+      end
+    end
+
+    def complete_method(prefix, target, mod, instance)
+      space = TypeSpace.new(visor, target, mod, instance, nil)
+      scanner = MethodScanner.new(prefix, !target)
+
+      space.scan_with(scanner)
+
+      if scanner.candidates.empty?
+        scanner.check_private = false
+        scanner.scan(visor.each_object(Module), true, true)
+      end
+
+      scanner.candidates.map { |m| method_spec(m) }
+    end
+
+    def complete_const(prefix, mod)
+      colons = prefix.rindex("::")
+      tail = colons ? prefix[colons + 2..-1] : prefix
+      if !colons
+        path = [Object]
+        path += visor.resolve_path(mod) if mod
+        path.flat_map do |m|
+          complete_const_in_module(tail, m)
+        end
+      else
+        base_name = prefix[0..colons + 1]
+        base = unless colons == 0
+                 if mod
+                   visor.resolve_context(base_name[0..-3], mod)
+                 else
+                   visor.resolve_const(base_name)
+                 end
+               end
+        complete_const_in_module(tail, base || Object)
+      end.map { |c| "#{base_name}#{c}" }
+    end
+
+    def complete_const_in_module(tail, base)
+      base.constants.grep(/^#{Regexp.escape(tail)}/)
+    end
+
+    def rails_refresh
+      if defined?(Rails.application.reloader)
+        Rails.application.reloader.reload!
+      else
+        ActionDispatch::Reloader.cleanup!
+        ActionDispatch::Reloader.prepare!
+      end
+      Rails.application.eager_load!
+      init_name_cache
+    end
+
+    def load_path
+      $LOAD_PATH
+    end
+
+    def ping
+      "pong"
+    end
+
+    def call(path, body)
+      _, endpoint, *args = path.split("/").map { |s| s == "-" ? nil : s }
+      value = public_send(endpoint.to_sym, *args)
+      value.to_json
+    end
+
+    private
+
+    def pick_visor
+      if RUBY_ENGINE == "jruby"
+        JVisor.new
+      else
+        Visor.new
+      end
+    end
+
+    def init_name_cache
+      # https://www.ruby-forum.com/topic/167055
+      @name_cache = Hash.new { |h, mod| h[mod] = mod.__name__ }
+    end
+  end
+end

data/lib/robe/sash/doc_for.rb

@@ -0,0 +1,57 @@
+require 'pry'
+require 'ostruct'
+
+begin
+  require 'pry-doc' if RUBY_ENGINE == "ruby"
+rescue LoadError
+  # Whatever, it's optional.
+end
+
+module Robe
+  class Sash
+    class DocFor
+      def initialize(method)
+        @method = method
+      end
+
+      def format
+        info = self.class.method_struct(@method)
+        {docstring: info.docstring,
+         source: info.source,
+         aliases: info.aliases,
+         visibility: visibility}
+      end
+
+      def visibility
+        owner, name = @method.owner, @method.name
+        if owner.__public_instance_methods__(false).include?(name)
+          :public
+        elsif owner.__protected_instance_methods__(false).include?(name)
+          :protected
+        elsif owner.__private_instance_methods__(false).include?(name)
+          :private
+        end
+      end
+
+      def self.method_struct(method)
+        begin
+          info = Pry::Method.new(method)
+
+          if info.dynamically_defined?
+            doc = ""
+            source = "# This method was defined outside of a source file."
+          else
+            doc = info.doc
+            source = (info.source? ? info.source : "# Not available.")
+          end
+
+          OpenStruct.new(docstring: doc, source: source,
+                         aliases: info.aliases.map(&:to_sym))
+        rescue Pry::CommandError
+          message = $!.message =~ /pry-doc/ ? $!.message : ""
+          return OpenStruct.new(docstring: message)
+        end
+      end
+    end
+  end
+end

data/lib/robe/sash/includes_tracker.rb

@@ -0,0 +1,75 @@
+require 'robe/core_ext'
+
+module Robe
+  class Sash
+    class IncludesTracker
+      def self.method_owner_and_inst(owner, name_cache)
+        includers = maybe_scan
+
+        mod, inst = includers[owner].first
+
+        if mod
+          [name_cache[mod], inst]
+        else
+          [nil, true]
+        end
+      end
+
+      def self.reset!
+        @@hosts = nil
+      end
+
+      private
+
+      def self.maybe_scan
+        includers = @@hosts
+
+        unless includers
+          @@hosts = includers = Hash.new { |h, k| h[k] = [] }
+
+          ObjectSpace.each_object(Module) do |cl|
+            next unless cl.respond_to?(:included_modules)
+            next if cl.__singleton_class__?
+            cl.included_modules.each { |mod| includers[mod] << [cl, true] }
+            sc = cl.__singleton_class__
+            sc.included_modules.each { |mod| includers[mod] << [cl, nil] }
+          end
+        end
+
+        includers
+      end
+
+      if Module.respond_to?(:prepend)
+        module Invalidator
+          def included(other)
+            IncludesTracker.reset!
+            super(other)
+          end
+
+          def extended(other)
+            IncludesTracker.reset!
+            super(other)
+          end
+        end
+
+        Module.send(:prepend, Invalidator)
+      else
+        Module.class_eval do
+          alias_method :__orig_included, :included
+          alias_method :__orig_extended, :extended
+
+          # Cannot hook into this method without :prepend.
+          def included(other)
+            IncludesTracker.reset!
+            __orig_included(other)
+          end
+
+          def extended(other)
+            IncludesTracker.reset!
+            __orig_extended(other)
+          end
+        end
+      end
+    end
+  end
+end