solargraph 0.1.0

data/lib/solargraph/mapper.rb

@@ -0,0 +1,31 @@
+module Solargraph
+  class Mapper
+    def initialize
+      @default_api_map = Solargraph::ApiMap.new
+      stub = Parser::CurrentRuby.parse(Solargraph::LiveParser.parse(nil))
+      @default_api_map.merge(stub)
+      @default_api_map.freeze
+      @require_nodes = {}
+    end
+
+    def get filename, text
+      workspace = find_workspace(filename)
+      CodeMap.new(text, api_map: @default_api_map, workspace: workspace, require_nodes: @require_nodes)
+    end
+
+    def find_workspace filename
+      dirname = filename
+      lastname = nil
+      result = nil
+      until dirname == lastname
+        if File.file?("#{dirname}/Gemfile")
+          result = dirname
+          break
+        end
+        lastname = dirname
+        dirname = File.dirname(dirname)
+      end
+      result || File.dirname(filename)
+    end
+  end
+end

data/lib/solargraph/node_methods.rb

@@ -0,0 +1,48 @@
+module Solargraph
+  module NodeMethods
+    def unpack_name(node)
+      pack_name(node).join("::")
+    end
+    
+    def pack_name(node)
+      parts = []
+      node.children.each { |n|
+        if n.kind_of?(AST::Node)
+          if n.type == :cbase
+            parts = pack_name(n)
+          else
+            parts += pack_name(n)
+          end
+        else
+          parts.push n unless n.nil?
+        end
+      }
+      parts
+    end
+
+    def infer node
+      if node.type == :str
+        return 'String'
+      elsif node.type == :array
+        return 'Array'
+      elsif node.type == :hash
+        return 'Hash'
+      elsif node.type == :int
+        return 'Integer'
+      elsif node.type == :float
+        return 'Float'
+      elsif node.type == :send
+        if node.children[0].nil?
+          # TODO Another local variable or method or something? sheesh
+        else
+          ns = unpack_name(node.children[0])
+          if node.children[1] == :new
+            return ns
+          end
+        end
+      elsif node.type == :cbase or node.type == :const
+        unpack_name node
+      end
+    end
+  end
+end

data/lib/solargraph/server.rb

@@ -0,0 +1,21 @@
+require 'sinatra/base'
+
+module Solargraph
+  class Server < Sinatra::Base
+    set :port, 0
+
+    post '/suggest' do
+      content_type :json
+      begin
+        code_map = CodeMap.new(code: params['text'], filename: params['filename'])
+        offset = code_map.get_offset(params['line'].to_i, params['col'].to_i)
+        sugg = code_map.suggest_at(offset, with_snippets: true, filtered: true)
+        { "status" => "ok", "suggestions" => sugg }.to_json
+      rescue Exception => e
+        STDERR.puts e
+        STDERR.puts e.backtrace.join("\n")
+        { "status" => "err", "message" => e.message }.to_json
+      end
+    end
+  end
+end

data/lib/solargraph/shell.rb

@@ -0,0 +1,84 @@
+require 'thor'
+require 'json'
+require 'fileutils'
+require 'rubygems/package'
+require 'zlib'
+
+module Solargraph
+  class Shell < Thor
+    desc 'prepare', 'Cache YARD files for the current environment'
+    option :force, type: :boolean, aliases: :f, desc: 'Force download of YARDOC files if they already exist'
+    option :host, type: :string, aliases: :h, desc: 'The host that provides YARDOC files for download', default: 'yardoc.solargraph.org'
+    def prepare
+      cache_dir = File.join(Dir.home, '.solargraph', 'cache')
+      version_dir = File.join(cache_dir, '2.0.0')
+      unless File.exist?(version_dir) or options[:force]
+        FileUtils.mkdir_p cache_dir
+        require 'net/http'
+        puts 'Downloading 2.0.0...'
+        Net::HTTP.start(options[:host]) do |http|
+            resp = http.get("/2.0.0.tar.gz")
+            open(File.join(cache_dir, '2.0.0.tar.gz'), "wb") do |file|
+                file.write(resp.body)
+            end
+            puts 'Uncompressing archives...'
+            FileUtils.rm_rf version_dir if File.exist?(version_dir)
+            tar_extract = Gem::Package::TarReader.new(Zlib::GzipReader.open(File.join(cache_dir, '2.0.0.tar.gz')))
+            tar_extract.rewind
+            tar_extract.each do |entry|
+              if entry.directory?
+                FileUtils.mkdir_p File.join(cache_dir, entry.full_name)
+              else
+                FileUtils.mkdir_p File.join(cache_dir, File.dirname(entry.full_name))
+                File.open(File.join(cache_dir, entry.full_name), 'wb') do |f|
+                  f << entry.read
+                end
+              end
+            end
+            tar_extract.close
+            FileUtils.rm File.join(cache_dir, '2.0.0.tar.gz')
+            puts 'Done.'
+        end
+      end
+    end
+    
+    desc 'bundled', 'Get a list of bundled gems'
+    def bundled
+      Bundler.load.specs.each { |s|
+        puts s.name
+      }
+    end
+    
+    desc 'server', 'Start a Solargraph server'
+    def server
+      Solargraph::Server.run!
+    end
+    
+    desc 'suggest', 'Get code suggestions for the provided input'
+    long_desc <<-LONGDESC
+      Analyze a Ruby file and output a list of code suggestions in JSON format.
+    LONGDESC
+    option :line, type: :numeric, aliases: :l, desc: 'Zero-based line number', required: true
+    option :column, type: :numeric, aliases: [:c, :col], desc: 'Zero-based column number', required: true
+    option :filename, type: :string, aliases: :f, desc: 'File name', required: false
+    def suggest(*filenames)
+      # HACK: The ARGV array needs to be manipulated for ARGF.read to work
+      ARGV.clear
+      ARGV.concat filenames
+      text = ARGF.read
+      filename = options[:filename] || filenames[0]
+      begin
+        code_map = CodeMap.new(code: text, filename: filename)
+        offset = code_map.get_offset(options[:line], options[:column])
+        sugg = code_map.suggest_at(offset, with_snippets: true, filtered: true)
+        result = { "status" => "ok", "suggestions" => sugg }.to_json
+        STDOUT.puts result
+      rescue Exception => e
+        STDERR.puts e
+        STDERR.puts e.backtrace.join("\n")
+        result = { "status" => "err", "message" => e.message }.to_json
+        STDOUT.puts result
+      end
+    end
+  end
+end

data/lib/solargraph/snippets.rb

@@ -0,0 +1,186 @@
+require 'json'
+
+module Solargraph
+  module Snippets
+    def self.definitions
+      @definitions ||= JSON.parse('{
+        "Exception block": {
+          "prefix": "begin",
+          "body": [
+            "begin",
+            "\t$1",
+            "rescue => exception",
+            "\t",
+            "end"
+          ]
+        },
+        "Exception block with ensure": {
+          "prefix": "begin ensure",
+          "body": [
+            "begin",
+            "\t$1",
+            "rescue => exception",
+            "\t",
+            "ensure",
+            "\t",
+            "end"
+          ]
+        },
+        "Exception block with else": {
+          "prefix": "begin else",
+          "body": [
+            "begin",
+            "\t$1",
+            "rescue => exception",
+            "\t",
+            "else",
+            "\t",
+            "end"
+          ]
+        },
+        "Exception block with else and ensure": {
+          "prefix": "begin else ensure",
+          "body": [
+            "begin",
+            "\t$1",
+            "rescue => exception",
+            "\t",
+            "else",
+            "\t",
+            "ensure",
+            "\t",
+            "end"
+          ]
+        },
+        "Class definition with initialize": {
+          "prefix": "class init",
+          "body": [
+            "class ${ClassName}",
+            "\tdef initialize",
+            "\t\t$0",
+            "\tend",
+            "end"
+          ]
+        },
+        "Class definition": {
+          "prefix": "class",
+          "body": [
+            "class ${ClassName}",
+            "\t$0",
+            "end"
+          ]
+        },
+        "for loop": {
+          "prefix": "for",
+          "body": [
+            "for ${value} in ${enumerable} do",
+            "\t$0",
+            "end"
+          ]
+        },
+        "if": {
+          "prefix": "if",
+          "body": [
+            "if ${test}",
+            "\t$0",
+            "end"
+          ]
+        },
+        "if else": {
+          "prefix": "if else",
+          "body": [
+            "if ${test}",
+            "\t$0",
+            "else",
+            "\t",
+            "end"
+          ]
+        },
+        "if elsif": {
+          "prefix": "if elsif",
+          "body": [
+            "if ${test}",
+            "\t$0",
+            "elsif ",
+            "\t",
+            "end"
+          ]
+        },
+        "if elsif else": {
+          "prefix": "if elsif else",
+          "body": [
+            "if ${test}",
+            "\t$0",
+            "elsif ",
+            "\t",
+            "else",
+            "\t",
+            "end"
+          ]
+        },
+        "forever loop": {
+          "prefix": "loop",
+          "body": [
+            "loop do",
+            "\t$0",
+            "end"
+          ]
+        },
+        "Module definition": {
+          "prefix": "module",
+          "body": [
+            "module ${ModuleName}",
+            "\t$0",
+            "end"
+          ]
+        },
+        "unless": {
+          "prefix": "unless",
+          "body": [
+            "unless ${test}",
+            "\t$0",
+            "end"
+          ]
+        },
+        "until loop": {
+          "prefix": "until",
+          "body": [
+            "until ${test}",
+            "\t$0",
+            "end"
+          ]
+        },
+        "while loop": {
+          "prefix": "while",
+          "body": [
+            "while ${test}",
+            "\t$0",
+            "end"
+          ]
+        },
+        "method definition": {
+          "prefix": "def",
+          "body": [
+            "def ${method_name}",
+            "\t$0",
+            "end"
+          ],
+          "description": "Snippet for method definitions"
+        },
+        "defined?": {
+          "prefix": "defined?",
+          "body": [
+            "defined?"
+          ],
+          "description": "Something silly"
+        }
+      }')
+    end
+
+    def self.keywords
+      @keywords ||= [
+        'begin', 'class', 'for', 'if', 'module', 'unless', 'until', 'while', 'def', 'defined?'
+      ]
+    end
+  end
+end

data/lib/solargraph/suggestion.rb

@@ -0,0 +1,40 @@
+require 'json'
+
+module Solargraph
+
+  class Suggestion
+    CLASS = 'Class'
+    KEYWORD = 'Keyword'
+    MODULE = 'Module'
+    METHOD = 'Method'
+    VARIABLE = 'Variable'
+    SNIPPET = 'Snippet'
+
+    attr_reader :label, :kind, :insert, :detail, :documentation
+
+    def initialize label, kind: KEYWORD, insert: nil, detail: nil, documentation: nil, code_object: nil
+      @label = label.to_s
+      @kind = kind
+      @insert = insert || @label
+      @detail = detail
+      @code_object = code_object
+      @documentation = documentation
+    end
+    
+    def to_s
+      label
+    end
+
+    def to_json args={}
+      {
+        label: @label,
+        kind: @kind,
+        insert: @insert,
+        detail: @detail,
+        #documentation: (@documentation.nil? ? nil : @documentation.all)
+        documentation: (@code_object.nil? ? nil : YARD::Templates::Engine.render(format: :text, object: @code_object))
+      }.to_json(args)
+    end
+  end
+
+end

data/lib/solargraph/version.rb

@@ -0,0 +1,3 @@
+module Solargraph
+  VERSION = '0.1.0'
+end

data/lib/solargraph/yard_map.rb

@@ -0,0 +1,119 @@
+require 'rubygems'
+require 'parser/current'
+require 'yard'
+
+module Solargraph
+
+  class YardMap
+    def initialize required: [], workspace: nil
+      unless workspace.nil?
+        wsy = File.join(workspace, '.yardoc')
+        yardocs.push wsy if File.exist?(wsy)
+      end
+      required.each { |r|
+        gy = YARD::Registry.yardoc_file_for_gem(r)
+        yardocs.push gy unless gy.nil?
+      }
+      yardocs.push File.join(Dir.home, '.solargraph', 'cache', '2.0.0', 'yardoc')
+      #yardocs.push File.join(Dir.home, '.solargraph', 'cache', '2.0.0', 'yardoc-stdlib')
+    end
+
+    def yardocs
+      @yardocs ||= []
+    end
+
+    def get_constants namespace, scope = ''
+      consts = []
+      result = []
+      yardocs.each { |y|
+        yard = YARD::Registry.load! y
+        unless yard.nil?
+          ns = nil
+          if scope == ''
+            ns = yard.at(namespace)
+          else
+            ns = yard.resolve(P(scope), namespace)
+          end
+          consts += ns.children unless ns.nil?
+        end
+      }
+      consts.each { |c|
+        result.push Suggestion.new(c.to_s.split('::').last, kind: Suggestion::CLASS)
+      }
+      result
+    end
+
+    def at signature
+      yardocs.each { |y|
+        yard = YARD::Registry.load! y
+        unless yard.nil?
+          obj = yard.at(signature)
+          return obj unless obj.nil?
+        end
+      }
+      nil
+    end
+
+    def resolve signature, scope
+      yardocs.each { |y|
+        yard = YARD::Registry.load! y
+        unless yard.nil?
+          obj = yard.resolve(P(scope), signature)
+          return obj unless obj.nil?
+        end
+      }
+      nil
+    end
+
+    def get_methods namespace, scope = ''
+      meths = []
+      yardocs.each { |y|
+        yard = YARD::Registry.load! y
+        unless yard.nil?
+          ns = nil
+          if scope == ''
+            ns = yard.at(namespace)
+          else
+            ns = yard.resolve(P(scope), namespace)
+          end
+          unless ns.nil?
+            ns.meths(scope: :class, visibility: [:public]).each { |m|
+              n = m.to_s.split('.').last
+              meths.push Suggestion.new("#{n}", kind: Suggestion::METHOD) if n.to_s.match(/^[a-z]/i)
+            }
+            if ns.kind_of?(YARD::CodeObjects::ClassObject) and namespace != 'Class'
+              meths += get_instance_methods('Class')
+            end
+          end
+        end
+      }
+      meths
+    end
+
+    def get_instance_methods namespace, scope = ''
+      meths = []
+      yardocs.each { |y|
+        yard = YARD::Registry.load! y
+        unless yard.nil?
+          ns = nil
+          if scope == ''
+            ns = yard.at(namespace)
+          else
+            ns = yard.resolve(P(scope), namespace)
+          end
+          unless ns.nil?
+            ns.meths(scope: :instance, visibility: [:public]).each { |m|
+              n = m.to_s.split('#').last
+              meths.push Suggestion.new("#{n}", kind: Suggestion::METHOD, documentation: m.docstring, code_object: m) if n.to_s.match(/^[a-z]/i) and !m.to_s.start_with?('Kernel#') and !m.docstring.to_s.include?(':nodoc:')
+            }
+            if ns.kind_of?(YARD::CodeObjects::ClassObject) and namespace != 'Object'
+              meths += get_instance_methods('Object')
+            end
+          end
+        end
+      }
+      meths
+    end
+  end
+
+end