yoda-language-server 0.4.0

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

@@ -0,0 +1,113 @@
+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 [ProgressBar, 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.rb

@@ -0,0 +1,46 @@
+module Yoda
+  module Store
+    module Objects
+      VALUE_REGEXP = /\A[0-9a-z]/
+      MODULE_TAIL_PATTERN = /(?:::(\w+)|^(\w+))$/
+
+      require 'yoda/store/objects/base'
+      require 'yoda/store/objects/namespace_object'
+      require 'yoda/store/objects/class_object'
+      require 'yoda/store/objects/value_object'
+      require 'yoda/store/objects/overload'
+      require 'yoda/store/objects/meta_class_object'
+      require 'yoda/store/objects/method_object'
+      require 'yoda/store/objects/merger'
+      require 'yoda/store/objects/module_object'
+      require 'yoda/store/objects/patch'
+      require 'yoda/store/objects/patch_set'
+      require 'yoda/store/objects/tag'
+
+      class << self
+        # @param hsh [Hash]
+        # @param [Addressable, nil]
+        def deserialize(hsh)
+          case hsh[:type].to_sym
+          when :class
+            ClassObject.new(hsh)
+          when :module
+            ModuleObject.new(hsh)
+          when :meta_class
+            MetaClassObject.new(hsh)
+          when :value
+            ValueObject.new(hsh)
+          when :method
+            MethodObject.new(hsh)
+          end
+        end
+
+        # @param path [Model::Path, String]
+        # @return [Array<Path>]
+        def lexical_scopes_of(path)
+          Model::Path.build(path).parent_paths.map { |name| Model::Path.build(name) } + [Model::Path.new('Object')]
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,116 @@
+module Yoda
+  module Store
+    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
+
+          # @return [Array<Symbol>]
+          def attr_names
+            %i(path document tag_list sources primary_source)
+          end
+        end
+
+        # @return [String]
+        attr_reader :path
+
+        # @return [String]
+        attr_reader :document
+
+        # @return [Array<Tag>]
+        attr_reader :tag_list
+
+        # @return [Array<(String, Integer, Integer)>]
+        attr_reader :sources
+
+        # @return [(String, Integer, Integer), nil]
+        attr_reader :primary_source
+
+        # @param path [String]
+        # @param document [String]
+        # @param tag_list [TagList, nil]
+        # @param sources [Array<(String, Integer, Integer)>]
+        # @param primary_source [(String, Integer, Integer), nil]
+        def initialize(path:, document: '', tag_list: [], sources: [], primary_source: nil, json_class: nil, kind: nil)
+          @path = path
+          @document = document
+          @tag_list = tag_list
+          @sources = sources
+          @primary_source = primary_source
+        end
+
+        # @return [String]
+        def name
+          fail NotImplementedError
+        end
+
+        # @return [Symbol]
+        def kind
+          fail NotImplementedError
+        end
+
+        # @return [String]
+        def address
+          path
+        end
+
+        # @return [Hash]
+        def to_h
+          {
+            kind: kind,
+            path: path,
+            document: document,
+            tag_list: tag_list,
+            sources: sources,
+            primary_source: primary_source
+          }
+        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)
+          self.class.new(merge_attributes(another))
+        end
+
+        def hash
+          ([self.class.name] + to_h.to_a).hash
+        end
+
+        def eql?(another)
+          self.class == another.class && to_h == another.to_h
+        end
+
+        def ==(another)
+          eql?(another)
+        end
+
+        private
+
+        # @param another [self]
+        # @return [Hash]
+        def merge_attributes(another)
+          {
+            path: path,
+            document: document + another.document,
+            tag_list: tag_list + another.tag_list,
+            sources: sources + another.sources,
+            primary_source: primary_source || another.primary_source,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Yoda
+  module Store
+    module Objects
+      class ClassObject < NamespaceObject
+        # @return [ScopedPath, nil]
+        attr_reader :superclass_path
+
+        # @return [Array<Symbol>]
+        def self.attr_names
+          super + %i(superclass_path)
+        end
+
+        # @param path [String]
+        # @param superclass_path [String, nil]
+        def initialize(superclass_path: nil, **kwargs)
+          super(kwargs)
+
+          @superclass_path = Model::ScopedPath.new(Objects.lexical_scopes_of(path), superclass_path) if superclass_path
+        end
+
+        def kind
+          :class
+        end
+
+        def to_h
+          super.merge(superclass_path: superclass_path&.path&.to_s)
+        end
+
+        private
+
+        # @param another [self]
+        # @return [Hash]
+        def merge_attributes(another)
+          super.merge(
+            superclass_path: select_superclass(another.superclass_path)&.path&.to_s,
+          )
+        end
+
+        # @param another [ScopedPath]
+        # @return [ScopedPath]
+        def select_superclass(another)
+          if %w(Object Exception).include?(another&.path&.to_s)
+            superclass_path || another
+          else
+            another || superclass_path
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Yoda
+  module Store
+    module Objects
+      class Merger
+        # @return [Array<Base>]
+        attr_reader :instances
+
+        # @param instances [Array<Base>]
+        def initialize(instances)
+          @instances = instances
+        end
+
+        # @return [Base]
+        def merged_instance
+          class_to_generate.new(attributes.select { |k, v| class_to_generate.attr_names.include?(k) }.to_h)
+        end
+
+        private
+
+        # @return [Base.class]
+        def class_to_generate
+          @class_to_generate ||= begin
+            if instances.any? { |el| el.is_a?(MetaClassObject) }
+              MetaClassObject
+            elsif instances.any? { |el| el.is_a?(ClassObject) }
+              ClassObject
+            elsif instances.any? { |el| el.is_a?(ModuleObject) }
+              ModuleObject
+            elsif instances.any? { |el| el.is_a?(MethodObject) }
+              MethodObject
+            else
+              ValueObject
+            end
+          end
+        end
+
+        # @return [Hash{ Symbol => Object }]
+        def attributes
+          @attributes ||= instances.map { |i| default_attributes.merge(i.to_h) }.reduce { |a, b| merge_attributes(a, b) }
+        end
+
+        # @param one [Hash{ Symbol => Object }]
+        # @param another [Hash{ Symbol => Object }]
+        def merge_attributes(one, another)
+          {
+            path: one[:path] || another[:path],
+            document: one[:document] + (one[:document].empty? || another[:document].empty? ? '' : "\n") + another[:document],
+            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],
+            visibility: one[:visibility] || another[:visibility],
+            parameters: one[:parameters].empty? ? another[:parameters] : one[:parameters], 
+            overloads: one[:overloads] + another[:overloads],
+            superclass_path: select_superclass(one, another),
+            value: one[:value] || another[:value],
+          }
+        end
+
+        # @return [Hash{ Symbol => Object }]
+        def default_attributes
+          {
+            path: nil,
+            document: '',
+            tag_list: [],
+            sources: [],
+            primary_source: nil,
+            instance_method_addresses: [],
+            mixin_addresses: [],
+            constant_addresses: [],
+            visibility: nil,
+            parameters: [],
+            overloads: [],
+            superclass_path: nil,
+            value: nil,
+          }
+        end
+
+        # @param one [Hash{ Symbol => Object }]
+        # @param another [Hash{ Symbol => Object }]
+        # @return [ScopedPath]
+        def select_superclass(one, another)
+          if %w(Object Exception).include?(another[:path].to_s)
+            one[:superclass_path] || another[:superclass_path]
+          else
+            another[:superclass_path] || one[:superclass_path]
+          end
+        end
+      end
+    end
+  end
+end