robe-server 1.0.2

data/spec/robe/server_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'robe/server'
+require 'net/http'
+
+describe Robe::Server do
+  it "starts up and serves an empty response" do
+    resp = start_and_send(proc {}, Net::HTTP::Get.new("/"))
+    expect(resp.body).to eq("")
+  end
+
+  it "passes path and body to the handler" do
+    rpath = nil
+    rbody = nil
+
+    handler = proc do |path, body|
+      rpath = path
+      rbody = body
+      ""
+    end
+
+    req = Net::HTTP::Post.new("/foo")
+    req.body = "bar\ntee"
+
+    start_and_send(handler, req)
+    expect(rpath).to eq("/foo")
+    expect(rbody).to eq("bar\ntee")
+  end
+
+  it "responds with whatever the handler returns" do
+    handler = proc { "foobles" }
+
+    resp = start_and_send(handler, Net::HTTP::Get.new("/"))
+    expect(resp.body).to eq("foobles")
+  end
+
+  it "prints out exceptions raised in the handler" do
+    handler = proc { raise Exception.new("down with the king!") }
+
+    begin
+      $stderr = StringIO.new
+      start_and_send(handler, Net::HTTP::Get.new("/"))
+      $stderr.seek(0)
+      expect($stderr.read).to match("down with the king!\n")
+    ensure
+      $stderr = STDERR
+    end
+  end
+
+  def start_and_send(handler, request)
+    server = described_class.new(handler, 0)
+
+    Thread.new do
+      Thread.current.abort_on_exception = true
+      server.start
+    end
+
+    server.wait_for_it
+
+    http = Net::HTTP.new("127.0.0.1", server.port)
+    http.request(request)
+  ensure
+    server.shutdown
+  end
+end

data/spec/robe/type_space_spec.rb

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'support/mocks'
+require 'robe/type_space'
+
+describe Robe::TypeSpace do
+  context "#initialize" do
+    it "resolves simple class" do
+      space = described_class.new(Robe::Visor.new, "String", nil, true, nil)
+      expect(space.target_type).to eq String
+      expect(space.instance).to be_true
+    end
+
+    it "resolves nested class" do
+      space = described_class.new(Robe::Visor.new, "Stat", "File", nil, nil)
+      expect(space.target_type).to eq File::Stat
+      expect(space.instance).to be_nil
+    end
+
+    it "resolves constant to its type" do
+      space = described_class.new(Robe::Visor.new, "E", "Math", nil, nil)
+      expect(space.target_type).to eq Float
+      expect(space.instance).to be_true
+    end
+  end
+
+  context "#scan_with" do
+    let(:scanner) { double("scanner") }
+    let(:m) { Module.new }
+
+    context "instance search" do
+      let(:c) { mod = m; Class.new { include mod } }
+      let(:kids) { [Class.new(c), Class.new(c)] }
+      let(:visor) { ScopedVisor.new(*kids, {"C" => c}) }
+      let(:space) { described_class.new(visor, "C", nil, true, nil) }
+
+      it "passes class and its ancestors" do
+        expect(scanner).to receive(:scan)
+          .with(include(c, Object, BasicObject, Kernel), true, false)
+        expect(scanner).not_to receive(:scan).with(include(Class), any_args())
+        space.scan_with(scanner)
+      end
+
+      it "passes included module" do
+        expect(scanner).to receive(:scan).with(include(m), true, false)
+        space.scan_with(scanner)
+      end
+
+      it "passes the descendants" do
+        expect(scanner).to receive(:scan).with(include(*kids), true, false)
+        space.scan_with(scanner)
+      end
+
+      it "passes Kernel even when scanning a module" do
+        visor = ScopedVisor.new(m, {"M" => m})
+        space = described_class.new(visor, "M", nil, true, nil)
+        expect(scanner).to receive(:scan).with(include(Kernel), true, false)
+        space.scan_with(scanner)
+      end
+
+      context "super search" do
+        let(:visor) { ScopedVisor.new(*kids, {"C" => c}) }
+        let(:space) { described_class.new(visor, "C", nil, true, true) }
+
+        it "does not pass the descendants" do
+          expect(scanner).not_to receive(:scan).with(include(*kids), true, false)
+          space.scan_with(scanner)
+        end
+
+        it "does not pass the class itself" do
+          expect(scanner).not_to receive(:scan).with(include(c), true, false)
+          space.scan_with(scanner)
+        end
+      end
+    end
+
+    context "module search" do
+      let(:n) { Module.new }
+      let(:c) do
+        mod = m;
+        Class.new { include mod }.tap do |c|
+          mod = n
+          c.singleton_class.class_eval { include mod }
+        end
+      end
+      let(:kids) { [Class.new(c), Class.new(c)] }
+      let(:visor) { ScopedVisor.new(*kids, {"C" => c}) }
+      let(:space) { described_class.new(visor, "C", nil, nil, nil) }
+
+      it "passes class and its ancestors, then metaclass ancestors" do
+        expect(scanner).to receive(:scan).with(include(c, Object), be_false, true)
+        expect(scanner).to receive(:scan)
+          .with(include(Class, Module, Kernel, n), true, be_false)
+        space.scan_with(scanner)
+      end
+
+      it "passes the descendants" do
+        expect(scanner).to receive(:scan).with(include(*kids), be_false, true)
+        expect(scanner).to receive(:scan).with(anything, true, be_false)
+        space.scan_with(scanner)
+      end
+
+      it "doesn't pass the included modules" do
+        expect(scanner).not_to receive(:scan).with(include(m), be_false, true)
+        expect(scanner).to receive(:scan).with(anything, be_false, true)
+        expect(scanner).to receive(:scan).with(anything, true, be_false)
+        space.scan_with(scanner)
+      end
+    end
+
+    context "search ActiveSupport::Concern deps" do
+      let(:asc) { Module.new }
+      let(:m) { mod = asc; Module.new { extend mod } }
+      let(:deps) { [Module.new, Module.new] }
+      let(:visor) { ScopedVisor.new("M" => m) }
+      let(:space) { described_class.new(visor, "M", nil, true, false) }
+
+      it "passes the dependencies" do
+        stub_const("ActiveSupport::Concern", asc)
+        m.instance_variable_set("@_dependencies", deps)
+        expect(scanner).to receive(:scan).with(include(*deps), true, false)
+        space.scan_with(scanner)
+      end
+    end
+  end
+end

data/spec/robe/visor_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'robe/visor'
+
+describe Robe::Visor do
+  let(:v) { described_class.new }
+
+  context ".resolve_const" do
+    it "resolves ARGF.class" do
+      expect(v.resolve_const("ARGF.class")).to be(ARGF.class)
+    end
+
+    if RUBY_ENGINE == "ruby" && RUBY_VERSION < "2.1"
+      it "resolves IO::readable and IO::writable" do
+        readable = v.resolve_const("IO::readable")
+        writable = v.resolve_const("IO::writable")
+        expect(readable.method_defined?(:readline)).to be_true
+        expect(writable.method_defined?(:puts)).to be_true
+        expect(writable.method_defined?(:readline)).to be_false
+        expect(readable.method_defined?(:puts)).to be_false
+      end
+    end
+
+    it "silently fails on nil" do
+      expect(v.resolve_const(nil)).to be_nil
+    end
+
+    it "resolves simple constant" do
+      expect(v.resolve_const("Object")).to be(Object)
+    end
+
+    it "resolves explicit global scope" do
+      expect(v.resolve_const("::String")).to be(String)
+    end
+
+    it "resolves nested class" do
+      expect(v.resolve_const("File::Stat")).to be(File::Stat)
+    end
+
+    it "swallows NameError" do
+      expect(v.resolve_const("Foo::Bar")).to be_nil
+    end
+  end
+
+  context ".resolve_context" do
+    it "defaults to the module if no name" do
+      expect(v.resolve_context(nil, "File")).to be(File)
+    end
+
+    it "accepts explicit scope qualifier" do
+      expect(v.resolve_context("::String", "File")).to be(String)
+    end
+
+    it "sees nested constants" do
+      expect(v.resolve_context("Stat", "File")).to be(File::Stat)
+    end
+
+    it "sees constants in containing scopes" do
+      expect(v.resolve_context("Stat", "File::Constants")).to be(File::Stat)
+    end
+
+    it "returns nil when not found" do
+      expect(v.resolve_context("Boo", "File::Constants")).to be_nil
+    end
+
+    it "prioritizes deeper nesting" do
+      m = Module.new do
+        module self::A; end
+        module self::N
+          module self::A
+          end
+        end
+      end
+      stub_const("M", m)
+      expect(v.resolve_context("A", "M::N")).to be(m::N::A)
+    end
+
+    it "swallows NameError" do
+      expect(v.resolve_context("String", "Foo::Bar")).to be(String)
+    end
+  end
+
+  context ".resolve_path_elems" do
+    it "returns an array" do
+      expect(v.resolve_path_elems(["File", "Stat"])).to eq([File, File::Stat])
+    end
+
+    it "swallows NameError" do
+      expect(v.resolve_path_elems(["Foo", "Bar"])).to eq([])
+    end
+  end
+end

data/spec/robe_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'robe-server'
+require 'net/http'
+
+describe Robe do
+  before do
+    $stderr = File.new(IO::NULL, "w")
+    Robe.start
+  end
+
+  after do
+    Robe.stop if Robe.server
+    $stderr = STDERR
+  end
+
+  it "has a server attribute" do
+    expect(Robe.server).to be_a(Robe::Server)
+  end
+
+  it "has the server running" do
+    expect(Robe.server.running).to be_true
+  end
+
+  it "has a stop method" do
+    expect { Robe.stop }.to stop_it
+  end
+
+  it "proxies 'ping' to Sash" do
+    resp = Net::HTTP.get("127.0.0.1", "/ping", Robe.server.port)
+    expect(resp).to eq("\"pong\"")
+  end
+
+  it "returns 'robe on' when already running" do
+    expect(Robe.start).to start_with("robe on")
+  end
+
+  %w(INT TERM).each do |signal|
+    it "shuts down on #{signal}" do
+      expect { Process.kill(signal, Process.pid) }.to stop_it
+    end
+  end
+
+  RSpec::Matchers.define :stop_it do
+    match do |proc|
+      server = Robe.server
+      proc.call
+      sleep 0.001
+      server.running == false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'simplecov'
+require 'coveralls'
+require 'pry'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+module ScannerHelper
+  def new_module(imethod, method, private_imethod, private_method)
+    Module.new do
+      eval <<-EOS
+        def #{imethod}; end
+        private
+        def #{private_imethod}; end
+        class << self
+          def #{method}; end
+          private
+          def #{private_method}; end
+        end
+      EOS
+    end
+  end
+
+  def named_module(name, *args)
+    new_module(*args).tap do |m|
+      m.instance_eval "def __name__; \"#{name}\" end"
+    end
+  end
+end

data/spec/support/mocks.rb

@@ -0,0 +1,31 @@
+require 'robe/visor'
+
+class ScopedVisor < Robe::Visor
+  def initialize(*modules)
+    if modules.last.is_a? Hash
+      @namespace = modules.pop
+    else
+      @namespace = {}
+    end
+    @modules = modules + @namespace.values
+  end
+
+  def fits?(type, m)
+    m.kind_of? type
+  end
+
+  def each_object(type)
+    @modules.select { |m| fits?(type, m) }.each { |m| yield m if block_given? }
+  end
+
+  def resolve_path_elems(nesting)
+    base = @namespace[nesting.shift]
+    [base] + super(nesting, base)
+  end
+end
+
+class BlindVisor < ScopedVisor
+  def fits?(type, m)
+    true
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: robe-server
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Phil Hagelberg, Dmitry Gutov, Alexsey Ermolaev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: Server for robe
+email: afay.zangetsu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/robe-server.rb
+- lib/robe/core_ext.rb
+- lib/robe/jvisor.rb
+- lib/robe/sash.rb
+- lib/robe/sash/doc_for.rb
+- lib/robe/sash/includes_tracker.rb
+- lib/robe/scanners.rb
+- lib/robe/server.rb
+- lib/robe/type_space.rb
+- lib/robe/visor.rb
+- robe-server.gemspec
+- spec/robe/jvisor_spec.rb
+- spec/robe/method_scanner_spec.rb
+- spec/robe/module_scanner_spec.rb
+- spec/robe/sash/doc_for_spec.rb
+- spec/robe/sash/includes_tracker_spec.rb
+- spec/robe/sash_spec.rb
+- spec/robe/server_spec.rb
+- spec/robe/type_space_spec.rb
+- spec/robe/visor_spec.rb
+- spec/robe_spec.rb
+- spec/spec_helper.rb
+- spec/support/mocks.rb
+homepage: https://github.com/AfsmNGhr/robe-server
+licenses:
+- GPL-3.0
+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.1
+signing_key: 
+specification_version: 4
+summary: Code navigation, documentation lookup and completion for Ruby
+test_files:
+- spec/robe/jvisor_spec.rb
+- spec/robe/method_scanner_spec.rb
+- spec/robe/module_scanner_spec.rb
+- spec/robe/sash/doc_for_spec.rb
+- spec/robe/sash/includes_tracker_spec.rb
+- spec/robe/sash_spec.rb
+- spec/robe/server_spec.rb
+- spec/robe/type_space_spec.rb
+- spec/robe/visor_spec.rb
+- spec/robe_spec.rb
+- spec/spec_helper.rb
+- spec/support/mocks.rb