rsense-server 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d67d9c7640d8e06647ff1f5e708b5a73a1aa28b
+  data.tar.gz: 186fd888eefebaad271af5b2254ffd1e44dcf790
+SHA512:
+  metadata.gz: d06bfae8ea880c507de82e9baeb0d15251bed35c65e0e46709bf1775aea2a3258d670e109ac437bbb010cc5b7768081c0375be57022b5380f7b6145767b9021f
+  data.tar.gz: 11a44d3575f2eb25907bdb76817434f2676fed08996c14d5dd61ceb790ed87e590d0ef638b3e72ff09ee96b596764e6280ee29a9095ad03d175ee5d2bf9178e5

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-version

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rsense.gemspec
+gemspec
+
+gem 'puma', :path => File.join(File.dirname(__FILE__), './vendor/gems/puma-2.8.2-java')
+
+group :linux do
+  gem 'libnotify'
+end
+
+group :darwin do
+  gem 'terminal-notifier-guard'
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard :minitest do
+  watch(%r{^spec/(.*)_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})         { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^spec/spec_helper\.rb}) { 'spec' }
+end

data/LICENSE.txt

@@ -0,0 +1 @@
+RSense is distributed under the term of GPLv3+(http://gplv3.fsf.org/).

data/README.md

@@ -0,0 +1,51 @@
+![rsense](https://cloud.githubusercontent.com/assets/1395968/2978144/51565ee2-dbb5-11e3-9b94-e97a37739d03.png)
+
+# Rsense Can See All
+
+[![Gitter chat](https://badges.gitter.im/rsense/rsense.png)](https://gitter.im/rsense/rsense)
+
+RSense is a tool for doing static analysis of Ruby source code. Rsense is used in conjunction with an editor plugin.
+
+RSense is currently under heavy development and not ready to use yet.  It would be awesome if you helped get things done.
+
+[![Stories in Ready](https://badge.waffle.io/rsense/rsense.png?label=ready&title=Ready)](https://waffle.io/rsense/rsense)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rsense'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rsense
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/rsense/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+RSense is distributed under the term of
+[GPLv3+](http://gplv3.fsf.org/).
+
+## Credits
+
+Rsense was originally designed and implemented by [Matsuyama Tomohiro(@m2ym)](https://github.com/m2ym/), and his hard work is still at the core of rsense today.  All of the algorithms for type-detection were implemented by him, with inspiration from multiple places.  You can read about his original version at [Rsense: A Ruby Development tools for Emacs, Vim and Others](http://cx4a.org/software/rsense/)
+
+In 2013, a major undertaking by @edubkendo to bring it current and improve its usefullness to rubyists was sponsored by the @jruby organization as a Google Summer of Code project.
+
+Special thanks belongs to [Tom Enebo (@enebo)](https://github.com/enebo) who provided excellent mentorship, code, architectural suggestions and more throughout the course of the update.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+end
+

data/bin/_rsense.rb

@@ -0,0 +1,115 @@
+require "rsense/server"
+require "rsense/server/config"
+require "optparse"
+
+SOCKET_PATH = '127.0.0.1:'
+DEFAULT_PORT = 47367
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: rsense start [options]"
+
+  opts.on("-pp", "--path PATH", "project path") do |path|
+    options[:path] = path
+  end
+
+  opts.on("-p", "--port PORT", "Port") do |port|
+    options[:port] = port
+  end
+end.parse!
+
+def config(options)
+  if options[:path]
+    path = Pathname.new(options[:path]).expand_path
+  end
+  conf = Rsense::Server::Config.new
+
+  if path && path.exist?
+    conf.set_up(path)
+  else
+    conf.set_up(Pathname.new("~").expand_path)
+  end
+  conf
+end
+
+def port(options)
+  config = config(options)
+  if options[:port] && options[:port].match(/^\d*$/)
+    options[:port].to_i
+  elsif config.port
+    config.port
+  else
+    DEFAULT_PORT
+  end
+end
+
+PORT = port(options)
+
+require "puma"
+require "sinatra"
+require "json"
+
+class RsenseApp < Sinatra::Base
+  attr_accessor :roptions, :rcommand, :rproject
+
+  configure { set :server, :puma }
+  set :port, PORT
+
+  def setup(jsondata)
+    if @roptions && @roptions.project_path =~ /#{jsondata["project"]}/
+      changed = check_options(jsondata)
+      @rcommand.options = @roptions
+    else
+      @roptions = Rsense::Server::Options.new(jsondata)
+      @rcommand = Rsense::Server::Command::Command.new(@roptions)
+    end
+  end
+
+  def check_options(data)
+    changed = []
+    data.each do |k, v|
+      unless @roptions.send k.to_sym == v
+        @roptions.__send__("#{k}=", v)
+        changed << k
+      end
+    end
+    changed
+  end
+
+  def code_completion
+    if @roptions.code
+      candidates = @rcommand.code_completion(@roptions.file, @roptions.location, @roptions.code)
+    else
+      candidates = @rcommand.code_completion(@roptions.file, @roptions.location)
+    end
+    completions = candidates.map do |c|
+      {c.completion => {
+        qualified_name: c.qualified_name,
+        base_name: c.base_name,
+        kind: c.kind.to_string
+      }}
+    end
+    { :completions => completions }
+  end
+
+  post '/' do
+    content_type :json
+    jsontext = request.body.read
+    if jsontext
+      data = JSON.parse(jsontext)
+      setup(data)
+      __send__(data["command"]).to_json
+    else
+      "No JSON was sent"
+    end
+  end
+
+end
+
+# termination signal
+Signal.trap("TERM") do
+  puts "TERM signal received."
+  RsenseApp.stop!
+end
+
+RsenseApp.run!

data/config/puma.rb

@@ -0,0 +1,2 @@
+OUT_PATH = '/tmp/rsense.log'
+stdout_redirect(OUT_PATH, OUT_PATH, true)

data/lib/rsense/server/code.rb

@@ -0,0 +1,38 @@
+module Rsense
+  module Server
+    class Code
+      attr_accessor :lines
+      TYPE_INFERENCE_METHOD_NAME = Rsense::Server::Command::TYPE_INFERENCE_METHOD_NAME
+      FIND_DEFINITION_METHOD_NAME_PREFIX = Rsense::Server::Command::FIND_DEFINITION_METHOD_NAME_PREFIX
+
+      def initialize(code_str)
+        @lines = code_str.split("\n")
+      end
+
+      def inject_inference_marker(location)
+        row = location["row"] - 1
+        column = location["column"] - 1
+        lines = @lines.clone
+        line = lines[row]
+        if line.slice(column - 1).end_with?(".")
+          line.insert(column, TYPE_INFERENCE_METHOD_NAME)
+        else
+          line.insert(column, ".#{TYPE_INFERENCE_METHOD_NAME}")
+        end
+        lines.join("\n")
+      end
+
+      def inject_definition_marker(injection, location)
+        row = location["row"] - 1
+        column = location["column"] - 1
+        lines = @lines.clone
+        line = lines[row]
+        match = line.slice(0, column).match(/.*(?:\.|::|\s)(\w+?[!?]?)/)
+        start = match.end(0)
+        line.insert(start - 1, injection)
+        lines.join("\n")
+      end
+
+    end
+  end
+end

data/lib/rsense/server/command/completion_result.rb

@@ -0,0 +1,11 @@
+module Rsense
+  module Server
+    module Command
+
+    end
+  end
+end
+
+class Rsense::Server::Command::CompletionResult
+
+end

data/lib/rsense/server/command/special_meth.rb

@@ -0,0 +1,18 @@
+module Rsense
+  module Server
+    module Command
+      class SpecialMeth < Java::org.cx4a.rsense.typing.runtime::SpecialMethod
+        attr_accessor :call_block
+
+        def initialize(&code)
+          @call_block = code
+        end
+
+        def call(*args)
+          @call_block.call(*args)
+        end
+
+      end
+    end
+  end
+end

data/lib/rsense/server/command/type_inference_method.rb

@@ -0,0 +1,24 @@
+module Rsense
+  module Server
+    module Command
+
+    end
+  end
+end
+
+class Rsense::Server::Command::TypeInferenceMethod < Java::org.cx4a.rsense.typing.runtime::SpecialMethod
+  attr_accessor :context
+
+  def initialize
+    super
+  end
+
+  def call(runtime, receivers, args, blcck, result)
+    receivers.each do |receiver|
+      @context.typeSet.add(receiver)
+    end
+    result.setResultTypeSet(receivers)
+    result.setNeverCallAgain(true)
+  end
+
+end

data/lib/rsense/server/command.rb

@@ -0,0 +1,239 @@
+require "pathname"
+require "rsense-core"
+require_relative "./listeners/find_definition_event_listener"
+require_relative "./listeners/where_event_listener"
+require_relative "./command/special_meth"
+require_relative "./command/type_inference_method"
+
+module Rsense
+  module Server
+    Context = Struct.new(:project, :typeSet, :main, :feature, :loadPathLevel) {
+      def clear
+        @project = nil
+        @typeSet = nil
+        @main = false
+        @feature = nil
+        @loadPathLevel = 0
+      end
+    }
+    module Command
+      TYPE_INFERENCE_METHOD_NAME = Rsense::CodeAssist::TYPE_INFERENCE_METHOD_NAME
+      FIND_DEFINITION_METHOD_NAME_PREFIX = Rsense::CodeAssist::FIND_DEFINITION_METHOD_NAME_PREFIX
+      PROJECT_CONFIG_NAME = ".rsense"
+    end
+  end
+end
+
+class Rsense::Server::Command::Command
+  LoadResult = Java::org.cx4a.rsense::LoadResult
+  CompletionCandidate = Struct.new(
+      :completion,
+      :qualified_name,
+      :base_name,
+      :kind
+    )
+
+  attr_accessor :context, :options, :parser, :projects, :sandbox, :definitionFinder, :whereListener, :type_inference_method, :require_method, :require_next_method, :result, :graph
+
+  def initialize(options)
+    @context = Rsense::Server::Context.new
+    @options = options
+
+    @type_inference_method = Rsense::Server::Command::TypeInferenceMethod.new()
+    @type_inference_method.context = @context
+
+    @require_method = Rsense::Server::Command::SpecialMeth.new() do |runtime, receivers, args, blcck, result|
+      if args
+        feature = Java::org.cx4a.rsense.typing.vertex::Vertex.getString(args[0])
+        if feature
+          rrequire(@context.project, feature, "UTF-8")
+        end
+      end
+    end
+
+    @require_next_method = Rsense::Server::Command::SpecialMeth.new() do |runtime, receivers, args, blcck, result|
+      if @context.feature
+        rrequire(@context.project, @context.feature, "UTF-8", @context.loadPathLevel + 1)
+      end
+    end
+
+    clear()
+  end
+
+  def rload(project, file, encoding, prep)
+    return LoadResult.alreadyLoaded() if project.loaded?(file)
+    return if file.extname =~ /(\.so|\.dylib|\.dll|\.java|\.class|\.c$|\.h$|\.m$|\.js|\.html|\.css)/
+    project.loaded << file
+    oldmain = @context.main
+
+    if prep
+      prepare(project)
+    else
+      @context.main = false
+    end
+
+    ast = @parser.parse_string(file.read, file.to_s)
+    project.graph.load(ast)
+    result = LoadResult.new
+    result.setAST(ast)
+    result
+  end
+
+  def rrequire(project, feature, encoding, loadPathLevel=0)
+    return LoadResult.alreadyLoaded() unless project.loaded?(feature)
+    project.loaded << feature
+
+    stubs = stubs_matches(project, feature)
+    stubs.each do |stub|
+      rload(project, Pathname.new(stub), encoding, false)
+    end
+
+    lpmatches = load_path_matches(project, feature)
+    lpmatches.each do |lp|
+      rload(project, lp, encoding, false)
+    end
+
+    dependencies = project.dependencies
+    dpmatches = dependency_matches(dependencies, feature)
+    dpmatches.each do |dp|
+      rload(project, dp, encoding, false)
+    end
+
+    unless lpmatches || dpmatches
+      dep_paths = dependency_paths(dependencies)
+      gem_path = project.gem_path.map {|gp| Pathname.new(gp) }
+
+      checked = deep_check(gem_path, dep_paths, feature)
+      checked.each do |cp|
+        rload(project, cp, encoding, false)
+      end
+    end
+  end
+
+  def load_builtin(project)
+    builtin = builtin_path(project)
+    rload(project, builtin, "UTF-8", false)
+  end
+
+  def builtin_path(project)
+    Pathname.new(project.stubs.select { |stub| stub.match(/builtin/)}.first)
+  end
+
+  def stub_matches(project, feature)
+    project.stubs.select { |stub| stub.to_s =~ /#{feature}/ }
+  end
+
+  def dependency_paths(dependencies)
+    dependencies.map { |d| Pathname.new(d.path.first).parent }.flatten
+  end
+
+  def dependency_matches(dependencies, feature)
+    dmatch = dependencies.select { |d| d.name =~ /#{feature}/ }
+    if dmatch
+      dmatch.map { |dm| Pathname.new(dm.path.first) }
+    end
+  end
+
+  def load_path_matches(project, feature)
+    load_path = project.load_path
+    load_path.map do |lp|
+      Dir.glob(Pathname.new(lp).join("**/*#{feature}*"))
+    end.flatten.compact
+  end
+
+  def deep_check(gem_path, dep_paths, feature)
+    checkpaths = gem_path + dep_paths
+    checkpaths.map do |p|
+      Dir.glob(Pathname.new(p).join("**/*#{feature}*"))
+    end.flatten.compact
+  end
+
+  def open_project(project)
+    @projects[project.name] = project
+  end
+
+  def code_completion(file, location, code_str="")
+    if code_str.empty?
+      code = Rsense::Server::Code.new(Pathname.new(file).read)
+    else
+      code = Rsense::Server::Code.new(code_str)
+      puts code
+    end
+    source = code.inject_inference_marker(location)
+    ast = @parser.parse_string(source, file.to_s)
+    @project.graph.load(ast)
+    result = Java::org.cx4a.rsense::CodeCompletionResult.new
+    result.setAST(ast)
+    candidates = []
+    @receivers = []
+    @context.typeSet.each do |receiver|
+      @receivers << receiver
+      ruby_class = receiver.getMetaClass
+      ruby_class.getMethods(true).each do |name|
+        rmethod = ruby_class.searchMethod(name)
+        candidates << CompletionCandidate.new(name, rmethod.toString(), rmethod.getModule().getMethodPath(nil), method_kind)
+      end
+      if receiver.to_java_object.java_kind_of?(Java::org.cx4a.rsense.ruby::RubyModule)
+        rmodule = receiver
+        rmodule.getConstants(true).each do |name|
+          direct_module = rmodule.getConstantModule(name)
+          constant = direct_module.getConstant(name)
+          base_name = direct_module.toString()
+          qname = "#{base_name}::#{name}"
+          kind = kind_check(constant)
+          candidates << CompletionCandidate.new(name, qname, base_name, kind)
+        end
+      end
+    end
+    candidates
+  end
+
+  def method_kind
+    Java::org.cx4a.rsense::CodeCompletionResult::CompletionCandidate::Kind::METHOD
+  end
+
+  def kind_check(constant)
+    if constant.class == Java::org.cx4a.rsense.ruby::RubyClass
+      Java::org.cx4a.rsense::CodeCompletionResult::CompletionCandidate::Kind::CLASS
+    elsif constant.class == Java::org.cx4a.rsense.ruby::RubyModule
+      Java::org.cx4a.rsense::CodeCompletionResult::CompletionCandidate::Kind::MODULE
+    else
+      Java::org.cx4a.rsense::CodeCompletionResult::CompletionCandidate::Kind::CONSTANT
+    end
+  end
+
+  def prepare(project)
+    @context.project = project
+    @context.typeSet = Java::org.cx4a.rsense.typing::TypeSet.new
+    @context.main = true
+    @type_inference_method.context = @context
+    @graph = project.graph
+    @graph.addSpecialMethod(Rsense::Server::Command::TYPE_INFERENCE_METHOD_NAME, @type_inference_method)
+    @graph.addSpecialMethod("require", @require_method)
+    @graph.addSpecialMethod("require_next", @require_next_method)
+    load_builtin(project)
+  end
+
+  def clear
+    @parser = Rsense::Server::Parser.new
+    @context.clear()
+    @projects = {}
+    @sandbox = Rsense::Server::Project.new("(sandbox)", Pathname.new("."))
+    @definitionFinder = Rsense::Server::Listeners::FindDefinitionEventListener.new(@context)
+    @whereListener = Rsense::Server::Listeners::WhereEventListener.new(@context)
+    open_project(@sandbox)
+    prepare_project()
+  end
+
+  def prepare_project()
+    if @options.name
+      name = @roptions.name
+    else
+      name = "(sandbox)"
+    end
+    file = @options.project_path
+    @project = Rsense::Server::Project.new(name, file)
+    prepare(@project)
+  end
+
+end

data/lib/rsense/server/config.rb

@@ -0,0 +1,70 @@
+require "filetree"
+require "json"
+
+module Rsense
+  module Server
+
+  end
+end
+
+class Rsense::Server::Config
+  attr_accessor :searched, :options, :errors, :port, :ignores
+
+  def initialize
+    @searched = []
+    @ignores = []
+    @errors = []
+  end
+
+  def search(path_str="~")
+    path = FileTree.new(path_str)
+    return if @searched.include?(path)
+    @searched << path
+    conf = path.join(".rsense").expand_path
+    unless conf.exist?
+      unless path.parent == path
+        conf = search(path.parent)
+      end
+    end
+    conf
+  end
+
+  def options(config_path)
+    begin
+      json_str = JSON.parse(config_path.read)
+    rescue JSON::ParserError => e
+      @errors << e
+    end
+    if json_str
+      @options ||= Rsense::Server::Options.new(json_str)
+    else
+      @options ||= Rsense::Server::Options.new({})
+    end
+    @options
+  end
+
+  def port
+    @port ||= check_options("port")
+  end
+
+  def ignores
+    if @ignores.empty?
+      @ignores << check_options("ignores")
+      @ignores.flatten!
+    end
+    @ignores
+  end
+
+  def check_options(name)
+    @options.rest[name] if @options.rest.key?(name)
+  end
+
+  def set_up(path)
+    conf = search(path)
+    if conf
+      options(conf)
+    end
+  end
+
+
+end

data/lib/rsense/server/gem_path.rb

@@ -0,0 +1,18 @@
+module Rsense
+  module Server
+    module GemPath
+
+      module_function
+      def paths
+        fetch.map do |p|
+          p unless p =~ /^file:/
+        end
+      end
+
+      def fetch
+        Gem.path
+      end
+
+    end
+  end
+end