yoda-language-server 0.4.0 → 0.5.0

data/lib/yoda/store/actions/import_std_library.rb

@@ -0,0 +1,35 @@
+module Yoda
+  module Store
+    module Actions
+      class ImportStdLibrary
+        # @return [Registry]
+        attr_reader :registry
+
+        class << self
+          # @return [true, false]
+          def run(registry)
+            new(registry).run
+          end
+        end
+
+        def initialize(registry)
+          @registry = registry
+        end
+
+        # @return [true, false]
+        def run
+          return false unless File.exist?(doc_path)
+          patch = YardImporter.import(doc_path)
+          registry.add_patch(patch)
+          true
+        end
+
+        private
+
+        def doc_path
+          File.expand_path("~/.yoda/sources/ruby-#{RUBY_VERSION}/.yardoc-stdlib")
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/adapters.rb

@@ -4,6 +4,7 @@ module Yoda
       require 'yoda/store/adapters/base'
       require 'yoda/store/adapters/leveldb_adapter'
       require 'yoda/store/adapters/lmdb_adapter'
+      require 'yoda/store/adapters/memory_adapter'
 
       # @return [Base.class]
       def self.default_adapter_class

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

@@ -0,0 +1,81 @@
+require 'json'
+
+module Yoda
+  module Store
+    module Adapters
+      # An adapter implementation to store object in memory.
+      # This implementation losts data on exit and we recommend to use this adapter only for test.
+      class MemoryAdapter < Base
+        class << self
+          def for(path)
+            @pool ||= {}
+            @pool[path] || (@pool[path] = new(path))
+          end
+
+          def type
+            :memory
+          end
+        end
+
+        # @return [Hash{String => String}]
+        attr_reader :db
+
+        # @param path [String, nil] represents the path to store db.
+        def initialize(path = nil)
+          @path = path
+          @db = {}
+        end
+
+        # @param address [String]
+        # @return [any]
+        def get(address)
+          JSON.load(db[address.to_s], symbolize_names: true)
+        end
+
+        # @param data [Enumerator<(String, Object)>]
+        # @param bar [ProgressBar, nil]
+        def batch_write(data, bar)
+          data.each do |(k, v)|
+            put(k, v)
+            bar&.increment
+          end
+        end
+
+        # @param address [String]
+        # @param object [Object]
+        # @return [void]
+        def put(address, object)
+          db[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.member?(address.to_s)
+        end
+
+        # @return [Array<String>]
+        def keys
+          db.keys
+        end
+
+        def stats
+          "No stats"
+        end
+
+        def clear
+          db.clear
+        end
+
+        def sync
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/objects.rb

@@ -4,6 +4,9 @@ module Yoda
       VALUE_REGEXP = /\A[0-9a-z]/
       MODULE_TAIL_PATTERN = /(?:::(\w+)|^(\w+))$/
 
+      require 'yoda/store/objects/serializable'
+      require 'yoda/store/objects/addressable'
+      require 'yoda/store/objects/patchable'
       require 'yoda/store/objects/base'
       require 'yoda/store/objects/namespace_object'
       require 'yoda/store/objects/class_object'
@@ -16,6 +19,7 @@ module Yoda
       require 'yoda/store/objects/patch'
       require 'yoda/store/objects/patch_set'
       require 'yoda/store/objects/tag'
+      require 'yoda/store/objects/project_status'
 
       class << self
         # @param hsh [Hash]

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

@@ -2,23 +2,11 @@ module Yoda
   module Store
     module Objects
       module Addressable
-        # @abstract
-        # @return [Symbol]
-        def kind
-          fail NotImplementedError
-        end
-
         # @abstract
         # @return [String]
         def address
           fail NotImplementedError
         end
-
-        # @abstract
-        # @return [Hash]
-        def to_hash
-          fail NotImplementedError
-        end
       end
     end
   end

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

@@ -3,16 +3,11 @@ module Yoda
     module Objects
       # @abstract
       class Base
-        class << self
-          def json_creatable?
-            true
-          end
-
-          # @param params [Hash]
-          def json_create(params)
-            new(params.map { |k, v| [k.to_sym, v] }.to_h)
-          end
+        include Addressable
+        include Serializable
+        include Patchable
 
+        class << self
           # @return [Array<Symbol>]
           def attr_names
             %i(path document tag_list sources primary_source)
@@ -74,11 +69,6 @@ module Yoda
           }
         end
 
-        # @return [String]
-        def to_json
-          to_h.merge(json_class: self.class.name).to_json
-        end
-
         # @param another [self]
         # @return [self]
         def merge(another)

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

@@ -48,11 +48,11 @@ module Yoda
             tag_list: one[:tag_list] + another[:tag_list],
             sources: one[:sources] + another[:sources],
             primary_source: one[:primary_source] || another[:primary_source],
-            instance_method_addresses: one[:instance_method_addresses] + another[:instance_method_addresses],
-            mixin_addresses: one[:mixin_addresses] + another[:mixin_addresses],
-            constant_addresses: one[:constant_addresses] + another[:constant_addresses],
+            instance_method_addresses: (one[:instance_method_addresses] + another[:instance_method_addresses]).uniq,
+            mixin_addresses: (one[:mixin_addresses] + another[:mixin_addresses]).uniq,
+            constant_addresses: (one[:constant_addresses] + another[:constant_addresses]).uniq,
             visibility: one[:visibility] || another[:visibility],
-            parameters: one[:parameters].empty? ? another[:parameters] : one[:parameters], 
+            parameters: one[:parameters].empty? ? another[:parameters] : one[:parameters],
             overloads: one[:overloads] + another[:overloads],
             superclass_path: select_superclass(one, another),
             value: one[:value] || another[:value],

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

@@ -0,0 +1,19 @@
+module Yoda
+  module Store
+    module Objects
+      module Patchable
+        # @abstract
+        # @return [Symbol]
+        def kind
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Hash]
+        def to_h
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+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

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

@@ -0,0 +1,39 @@
+module Yoda
+  module Store
+    module Objects
+      module Serializable
+        module ClassMethods
+          def json_creatable?
+            true
+          end
+
+          # @param params [Hash]
+          def json_create(params)
+            new(params.reject { |k, _v| k.to_sym == :json_class }.map { |k, v| [k.to_sym, v] }.to_h)
+          end
+        end
+
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+
+        # @abstract
+        # @return [Hash]
+        def to_h
+          fail NotImplementedError
+        end
+
+        # @return [String]
+        def to_json(*options)
+          to_h.merge(json_class: self.class.name).to_json
+        end
+
+        # Create a new instance which has the original parameters and overrided parameters.
+        # @param params [Hash{Symbol => Object}] parameters to override
+        def derive(params = {})
+          self.class.new(to_h.merge(params))
+        end
+      end
+    end
+  end
+end