yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/model/types.rb

@@ -1,84 +0,0 @@
-require 'parslet'
-
-module Yoda
-  module Model
-    module Types
-      require 'yoda/model/types/base'
-      require 'yoda/model/types/any_type'
-      require 'yoda/model/types/value_type'
-      require 'yoda/model/types/instance_type'
-      require 'yoda/model/types/function_type'
-      require 'yoda/model/types/duck_type'
-      require 'yoda/model/types/module_type'
-      require 'yoda/model/types/sequence_type'
-      require 'yoda/model/types/generic_type'
-      require 'yoda/model/types/union_type'
-      require 'yoda/model/types/unknown_type'
-
-      # @param string [String]
-      # @return [Types::Base]
-      def self.parse(string)
-        Parsing::Generator.new.apply(Parsing::Parser.new.parse(string))
-      rescue Parslet::ParseFailed => failure
-        Types::UnknownType.new(string)
-      end
-
-      # @param strings [Array<String>]
-      # @return [Types::Base]
-      def self.parse_type_strings(strings)
-        Types::UnionType.new(strings.map { |string| parse(string) })
-      end
-
-      module Parsing
-        class Parser < Parslet::Parser
-          rule(:method_name) { match('[a-z]') >> match('[a-zA-Z0-9_]').repeat }
-          rule(:duck_type) { str('#') >> method_name.as(:method_name) }
-          rule(:constant_name) { match('[A-Z]') >> match('[a-zA-Z0-9_]').repeat }
-          rule(:constant_full_name) { str('::').maybe >> (constant_name >> (str('::') | str('.'))).repeat >> constant_name }
-          rule(:value_name) { match('[a-z0-9]') >> match('[a-zA-Z0-9_]').repeat }
-
-          rule(:space) { match('\s').repeat(1) }
-          rule(:space?) { space.maybe }
-
-          rule(:constant_type) { value_name.as(:value) | constant_full_name.as(:instance_type) }
-
-          rule(:key_value_type) { constant_type.as(:base_type) >> str('{') >> space? >> type.as(:key_type) >> space? >> str('=>') >> space? >> type.as(:value_type) >> space? >> str('}') }
-          rule(:sequence_type) { constant_type.as(:base_type) >> str('(') >> space? >> types.as(:value_types) >> space? >> str(')') }
-          rule(:generic_type) { constant_type.as(:base_type) >> (str('<') >> space? >> type >> space? >> str('>')).repeat(1).as(:type_arguments) }
-
-          rule(:shorthand_key_value) { str('{') >> space? >> type.as(:key_type) >> space? >> str('=>') >> space? >> type.as(:value_type) >> space? >> str('}') }
-          rule(:shorthand_sequence) { str('(') >> space? >> types.as(:value_types) >> space? >> str(')') }
-          rule(:shorthand_array) { str('<') >> space? >> type.as(:type_in_array) >> space? >> str('>') }
-
-          rule(:union_type) { types.as(:types) }
-
-          rule(:single_type) { duck_type | shorthand_key_value | shorthand_array | shorthand_sequence | generic_type | key_value_type | sequence_type | constant_type }
-          rule(:types) { (single_type >> str(',') >> space?).repeat >> space? >> single_type }
-
-          rule(:type) { union_type }
-          rule(:base) { space? >> type >> space? }
-          root :base
-        end
-
-        class Generator < Parslet::Transform
-          rule(instance_type: simple(:instance_type)) { Types::InstanceType.new(instance_type.to_s) }
-          rule(value: simple(:value)) { Types::ValueType.new(value.to_s) }
-
-          rule(base_type: simple(:base_type), key_type: simple(:key_type), value_type: simple(:value_type)) { Types::GenericType.from_key_value(base_type, key_type, value_type) }
-          rule(base_type: simple(:base_type), value_types: sequence(:value_types)) { Types::SequenceType.new(base_type, value_types) }
-          rule(base_type: simple(:base_type), value_types: simple(:value_type)) { Types::SequenceType.new(base_type, [value_type]) }
-          rule(base_type: simple(:base_type), type_arguments: sequence(:type_arguments)) { Types::GenericType.new(base_type, type_arguments) }
-
-          rule(method_name: simple(:method_name)) { Types::DuckType.new(method_name) }
-          rule(key_type: simple(:key_type), value_type: simple(:value_type)) { Types::GenericType.from_key_value(Types::InstanceType.new('::Hash'), key_type, value_type) }
-          rule(value_types: sequence(:value_types)) { Types::SequenceType.new(Types::InstanceType.new('::Array'), value_types) }
-          rule(value_types: simple(:value_type)) { Types::SequenceType.new(Types::InstanceType.new('::Array'), [value_type]) }
-          rule(type_in_array: simple(:type)) { Types::GenericType.new(Types::InstanceType.new('::Array'), [type]) }
-
-          rule(types: sequence(:types)) { Types::UnionType.new(types) }
-          rule(types: simple(:type)) { type }
-        end
-      end
-    end
-  end
-end

data/lib/yoda/model/values/module_value.rb

@@ -1,72 +0,0 @@
-module Yoda
-  module Model
-    module Values
-      class ModuleValue < Base
-        attr_reader :registry, :namespace_object
-
-        # @param registry [Registry]
-        # @param namespace_object [::YARD::CodeObjects::NamespaceObject, ::YARD::CodeObjects::Proxy]
-        def initialize(registry, namespace_object)
-          fail ArgumentError, registry unless registry.is_a?(Registry)
-          fail ArgumentError, namespace_object unless namespace_object.is_a?(::YARD::CodeObjects::NamespaceObject) || namespace_object.is_a?(::YARD::CodeObjects::Proxy)
-          @registry = registry
-          @namespace_object = namespace_object
-        end
-
-        # @return [Array<Functions::Base>]
-        def methods(visibility: nil)
-          return [] if namespace_object.type == :proxy
-          @methods ||= begin
-            opts = { scope: :class, visibility: visibility }.compact
-            class_methods = namespace_object.meths(opts).map { |meth| Functions::Method.new(meth) } + constructors
-            class_method_names = Set.new(class_methods.map(&:name))
-            parent_meths = parent_methods(visibility: visibility).reject { |m| class_method_names.include?(m.name) }
-            class_methods + parent_meths
-          end
-        end
-
-        # @return [String]
-        def path
-          "#{namespace.path}.#{namespace.type == :class ? 'class' : 'module'}"
-        end
-
-        def namespace
-          namespace_object
-        end
-
-        # @param [String]
-        def docstring
-          namespace.docstring
-        end
-
-        # @return [Array<[String, Integer]>]
-        def defined_files
-          namespace.files
-        end
-
-        private
-
-        # @return [Array<Functions::Constructor>]
-        def constructors
-          [] unless namespace_object.type == :class
-          [] if namespace.child(name: :new, scope: :class)
-          [namespace.child(name: :initialize, scope: :instance)].map do |method_object|
-            Functions::Constructor.new(method_object)
-          end
-        end
-
-        # @return [Array<Functions::Base>]
-        def parent_methods(visibility: nil)
-          case namespace_object.type
-          when :class
-            InstanceValue.new(registry, registry.find_or_proxy('::Class')).methods(visibility: visibility)
-          when :module
-            InstanceValue.new(registry, registry.find_or_proxy('::Module')).methods(visibility: visibility)
-          else
-            []
-          end
-        end
-      end
-    end
-  end
-end

data/lib/yoda/parsing/source_analyzer.rb

@@ -1,59 +0,0 @@
-module Yoda
-  module Parsing
-    # @deprecated
-    class SourceAnalyzer
-      include AstTraversable
-
-      # @param source   [String]
-      # @param location [Location]
-      # @return [SourceAnalyzer]
-      def self.from_source(source, location)
-        new(Parser.new.parse(source), location)
-      end
-
-      attr_reader :ast, :location
-
-      # @param ast      [::Parser::AST::Node]
-      # @param location [Location]
-      def initialize(ast, location)
-        @ast = ast
-        @location = location
-      end
-
-      # @return [Array<::Parser::AST::Node>]
-      def nodes_to_current_location_from_root
-        @nodes_to_current_location ||= calc_nodes_to_current_location(ast, location)
-      end
-
-      # @return [true, false]
-      def on_method?
-        !!current_method_node
-      end
-
-      # @return [::Parser::AST::Node]
-      def current_method_node
-        nodes_to_current_location_from_root.reverse.find { |node| [:def, :defs].include?(node.type) }
-      end
-
-      # @return [Array<::Parser::AST::Node>]
-      def current_namespace_nodes
-        nodes_to_current_location_from_root.find_all { |node| [:class, :module, :sclass].include?(node.type) }
-      end
-
-      # @return [Namespace]
-      def namespace
-        @namespace ||= NodeObjects::Namespace.new(self.ast)
-      end
-
-      # @return [NodeObjects::Namespace, nil]
-      def current_namespace
-        @current_namespace ||= namespace.calc_current_location_namespace(location)
-      end
-
-      # @return [NodeObjects::MethodDefition, nil]
-      def current_method
-        @current_method ||= namespace.calc_current_location_method(location)
-      end
-    end
-  end
-end

data/lib/yoda/server/file_store.rb

@@ -1,57 +0,0 @@
-require 'concurrent'
-
-module Yoda
-  class Server
-    class FileStore
-      def initialize
-        @cache = Concurrent::Map.new
-      end
-
-      # @param uri_string [String]
-      # @return [String, nil]
-      def get(uri_string)
-        @cache[uri_string]
-      end
-
-      # @param uri_string [String]
-      # @param text [String]
-      def store(uri_string, text)
-        return unless program_file_uri?(uri_string)
-        @cache[uri_string] = text
-      end
-
-      # @param uri_string [String]
-      def load(uri_string)
-        store(uri_string, read(uri_string))
-      end
-
-      # @param uri_string [String]
-      def read(uri_string)
-        path = self.class.path_of_uri(uri_string)
-        fail ArgumentError unless path
-        File.read(path)
-      end
-
-      # @param path [String]
-      def self.uri_of_path(path)
-        "file://#{File.expand_path(path)}"
-      end
-
-      # @param uri_string [String]
-      def self.path_of_uri(uri_string)
-        uri = URI.parse(uri_string)
-        return nil unless uri.scheme == 'file'
-        uri.path
-      rescue URI::InvalidURIError
-        nil
-      end
-
-      # @param uri_string [String]
-      def program_file_uri?(uri_string)
-        %w(.c .rb).include?(File.extname(URI.parse(uri_string).path))
-      rescue URI::InvalidURIError => _e
-        false
-      end
-    end
-  end
-end

data/lib/yoda/store/adapters/leveldb_adapter.rb

@@ -1,80 +0,0 @@
-require 'leveldb'
-require 'json'
-
-module Yoda
-  module Store
-    module Adapters
-      class LeveldbAdapter < Base
-        class << self
-          def for(path)
-            @pool ||= {}
-            @pool[path] || (@pool[path] = new(path))
-          end
-
-          def type
-            :leveldb
-          end
-        end
-
-        # @param path [String] represents the path to store db.
-        def initialize(path)
-          @path = path
-          @db = LevelDB::DB.new(path, compression: true)
-
-          at_exit { @db.closed? || @db.close }
-        end
-
-        # @param address [String]
-        # @return [any]
-        def get(address)
-          JSON.load(@db.get(address.to_s), symbolize_names: true)
-        end
-
-        # @param address [String]
-        # @param object [Object]
-        # @return [void]
-        def put(address, object)
-          @db.put(address.to_s, object.to_json)
-        end
-
-        # @param data [Enumerator<(String, Object)>]
-        # @param bar [#increment, nil]
-        def batch_write(data, bar)
-          data.each do |(k, v)|
-            @db.put(k, v)
-            bar&.increment
-          end
-        end
-
-        # @param address [String]
-        # @return [void]
-        def delete(address)
-          @db.delete(address.to_s)
-        end
-
-        # @param address [String]
-        # @return [true, false]
-        def exist?(address)
-          @db.exists?(address.to_s)
-        end
-
-        # @return [Array<String>]
-        def keys
-          @db.keys
-        end
-
-        def stats
-          @db.stats
-        end
-
-        def clear
-          @db.destroy!
-        end
-
-        def sync
-          # nop
-        end
-      end
-    end
-  end
-end

data/lib/yoda/store/adapters/lmdb_adapter.rb

@@ -1,113 +0,0 @@
-require 'lmdb'
-require 'json'
-
-module Yoda
-  module Store
-    module Adapters
-      class LmdbAdapter < Base
-        class << self
-          def for(path)
-            @pool ||= {}
-            @pool[path] || (@pool[path] = new(path))
-          end
-
-          def type
-            :lmdb
-          end
-        end
-
-        # @param path [String] represents the path to store db.
-        def initialize(path)
-          Dir.mkdir(path) unless Dir.exist?(path)
-          @path = path
-          @env = LMDB.new(path)
-          @db = @env.database('main', create: true)
-
-          at_exit { @env.close }
-        end
-
-        # @param address [String]
-        # @return [any]
-        def get(address)
-          JSON.load(@db.get(address.to_s), symbolize_names: true)
-        end
-
-        # @param data [Enumerator<(String, Object)>]
-        # @param bar [#increment, nil]
-        def batch_write(data, bar)
-          env = LMDB.new(@path, mapsize: @env.info[:mapsize], writemap: true, mapasync: true, nosync: true)
-          db = env.database('main', create: true)
-          data.each do |(k, v)|
-            begin
-              db.put(k.to_s, v.to_json)
-            rescue LMDB::Error::MAP_FULL => _ex
-              @env.mapsize = @env.info[:mapsize] * 2
-              env.close
-              env = LMDB.new(@path, mapsize: @env.info[:mapsize], writemap: true, mapasync: true, nosync: true)
-              db = env.database('main', create: true)
-              db.put(k.to_s, v.to_json)
-            end
-            bar&.increment
-          end
-          env.close
-        end
-
-        # @param address [String]
-        # @param object [Object]
-        # @return [void]
-        def put(address, object)
-          do_put(address.to_s, object.to_json)
-        end
-
-        # @param address [String]
-        # @return [void]
-        def delete(address)
-          @db.delete(address.to_s)
-        end
-
-        # @param address [String]
-        # @return [true, false]
-        def exist?(address)
-          !!@db.get(address.to_s)
-        end
-
-        # @return [Array<String>]
-        def keys
-          Enumerator.new do |yielder|
-            @db.each { |(k, v)| yielder << k }
-          end.to_a
-        end
-
-        def stats
-          @db.stat
-        end
-
-        def clear
-          @db.clear
-        end
-
-        def sync
-          # @env.sync(force: true)
-        end
-
-        private
-
-        # @param address [String]
-        # @param value [String]
-        # @return [void]
-        def do_put(address, value)
-          LMDB.new(@path, mapsize: @env.info[:mapsize]) do |env|
-            db = env.database('main', create: true)
-            db.put(address, value)
-          end
-        rescue LMDB::Error::MAP_FULL => _ex
-          @env.mapsize = @env.info[:mapsize] * 2
-          LMDB.new(@path, mapsize: @env.info[:mapsize]) do |env|
-            db = env.database('main', create: true)
-            db.put(address, value)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/yoda/store/objects/project_status.rb

@@ -1,169 +0,0 @@
-module Yoda
-  module Store
-    module Objects
-      class ProjectStatus
-        include Serializable
-
-        # @return [Integer]
-        attr_reader :version
-
-        # @return [BundleStatus]
-        attr_reader :bundle
-
-        # @param specs [Array<Bundler::LazySpecification>]
-        # @return [BundleStatus]
-        def self.initial_build(specs:)
-          new(bundle: BundleStatus.initial_build(specs), version: Registry::REGISTRY_VERSION)
-        end
-
-        # @param bundle [BundleStatus]
-        # @param version [Integer] the version number of registry
-        def initialize(bundle:, version:)
-          @bundle = bundle
-          @version = version
-        end
-
-        def to_h
-          { bundle: bundle, version: version }
-        end
-
-        # Remember gem dependencies and loaded gems
-        class BundleStatus
-          include Serializable
-
-          # @return [Array<GemStatus>]
-          attr_reader :gem_statuses
-
-          # @return [StdStatus]
-          attr_reader :std_status
-
-          # @param specs [Array<Bundler::LazySpecification>]
-          # @return [BundleStatus]
-          def self.initial_build(specs)
-            gem_statuses = specs.map { |spec| ProjectStatus::GemStatus.initial_build(spec) }
-            std_status = StdStatus.initial_build
-            new(gem_statuses: gem_statuses, std_status: std_status)
-          end
-
-          # @param gem_statuses [Array<GemStatus>]
-          # @param std_status [StdStatus]
-          def initialize(gem_statuses:, std_status:)
-            @gem_statuses = gem_statuses
-            @std_status = std_status
-          end
-
-          def to_h
-            { gem_statuses: gem_statuses, std_status: std_status }
-          end
-
-          # @param name [String]
-          # @return [GemStatus, nil]
-          def [](name)
-            dictionary[name]
-          end
-
-          # @return [true, false]
-          def all_present?
-            gem_statuses.all?(&:present?) && std_status.all_present?
-          end
-
-          # @return [Array<GemStatus>]
-          def present_gems
-            gem_statuses.select(&:present?)
-          end
-
-          # @return [Array<GemStatus>]
-          def not_present_gems
-            gem_statuses.reject(&:present?)
-          end
-
-          private
-
-          # @return [Hash{String => GemStatus}]
-          def dictionary
-            @dictionary ||= gem_statuses.map do |gem_status|
-              [gem_status.name, gem_status]
-            end.to_h
-          end
-        end
-
-        # Remember ruby core and standard library state
-        class StdStatus
-          include Serializable
-          # @return [String]
-          attr_reader :version
-
-          # @return [true, false]
-          attr_reader :core_present, :std_present
-
-          # @return [StdStatus]
-          def self.initial_build
-            new(version: RUBY_VERSION, core_present: false, std_present: false)
-          end
-
-          # @param version [String]
-          # @param core_present [true, false] represents the flag if core's index file is present.
-          # @param std_present [true, false] represents the flag if standard library's index file is present.
-          def initialize(version:, core_present:, std_present:)
-            @version = version
-            @core_present = core_present
-            @std_present = std_present
-          end
-
-          # @return [true, false]
-          def all_present?
-            core_present? && std_present?
-          end
-
-          # @return [true, false]
-          def core_present?
-            core_present
-          end
-
-          # @return [true, false]
-          def std_present?
-            std_present
-          end
-
-          def to_h
-            { version: version, core_present: core_present, std_present: std_present }
-          end
-        end
-
-        # Remember each gem state
-        class GemStatus
-          include Serializable
-          # @return [String]
-          attr_reader :name, :version
-
-          # @return [true, false]
-          attr_reader :present
-
-          # @param gem [Bundler::LazySpecification]
-          # @return [GemStatus]
-          def self.initial_build(gem)
-            new(name: gem.name, version: gem.version, present: false)
-          end
-
-          # @param name [String]
-          # @param version [String]
-          # @param present [true, false] represents the flag if the specified gem's index file is present.
-          def initialize(name:, version:, present:)
-            @name = name
-            @version = version
-            @present = present
-          end
-
-          def to_h
-            { name: name, version: version, present: present }
-          end
-
-          # @return [true, false]
-          def present?
-            !!present
-          end
-        end
-      end
-    end
-  end
-end