solargraph 0.39.7

data/lib/solargraph/api_map/bundler_methods.rb

@@ -0,0 +1,27 @@
+require 'bundler'
+require 'shellwords'
+
+module Solargraph
+  class ApiMap
+    module BundlerMethods
+      module_function
+
+      # @param directory [String]
+      # @return [Hash]
+      def require_from_bundle directory
+        @require_from_bundle ||= begin
+          Solargraph.logger.info "Loading gems for bundler/require"
+          Documentor.specs_from_bundle(directory)
+        rescue BundleNotFoundError => e
+          Solargraph.logger.warn e.message
+          {}
+        end
+      end
+
+      # @return [void]
+      def reset_require_from_bundle
+        @require_from_bundle = nil
+      end
+    end
+  end
+end

data/lib/solargraph/api_map/cache.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class ApiMap
+    class Cache
+      def initialize
+        @methods = {}
+        @constants = {}
+        @qualified_namespaces = {}
+        @receiver_definitions = {}
+      end
+
+      def get_methods fqns, scope, visibility, deep
+        @methods[[fqns, scope, visibility.sort, deep]]
+      end
+
+      def set_methods fqns, scope, visibility, deep, value
+        @methods[[fqns, scope, visibility.sort, deep]] = value
+      end
+
+      def get_constants namespace, context
+        @constants[[namespace, context]]
+      end
+
+      def set_constants namespace, context, value
+        @constants[[namespace, context]] = value
+      end
+
+      def get_qualified_namespace name, context
+        @qualified_namespaces[[name, context]]
+      end
+
+      def set_qualified_namespace name, context, value
+        @qualified_namespaces[[name, context]] = value
+      end
+
+      def receiver_defined? path
+        @receiver_definitions.key? path
+      end
+
+      def get_receiver_definition path
+        @receiver_definitions[path]
+      end
+
+      def set_receiver_definition path, pin
+        @receiver_definitions[path] = pin
+      end
+
+      # @return [void]
+      def clear
+        @methods.clear
+        @constants.clear
+        @qualified_namespaces.clear
+        @receiver_definitions.clear
+      end
+
+      # @return [Boolean]
+      def empty?
+        @methods.empty? &&
+          @constants.empty? &&
+          @qualified_namespaces.empty? &&
+          @receiver_definitions.empty?
+      end
+    end
+  end
+end

data/lib/solargraph/api_map/source_to_yard.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class ApiMap
+    module SourceToYard
+
+      # Get the YARD CodeObject at the specified path.
+      #
+      # @param path [String]
+      # @return [YARD::CodeObjects::Base]
+      def code_object_at path
+        code_object_map[path]
+      end
+
+      # @return [Array<String>]
+      def code_object_paths
+        code_object_map.keys
+      end
+
+      # @param store [ApiMap::Store] ApiMap pin store
+      # @return [void]
+      def rake_yard store
+        YARD::Registry.clear
+        code_object_map.clear
+        store.namespace_pins.each do |pin|
+          next if pin.path.nil? || pin.path.empty?
+          if pin.code_object
+            code_object_map[pin.path] ||= pin.code_object
+            next
+          end
+          if pin.type == :class
+            code_object_map[pin.path] ||= YARD::CodeObjects::ClassObject.new(root_code_object, pin.path) { |obj|
+              next if pin.location.nil? || pin.location.filename.nil?
+              obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
+            }
+          else
+            code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path) { |obj|
+              next if pin.location.nil? || pin.location.filename.nil?
+              obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
+            }
+          end
+          code_object_map[pin.path].docstring = pin.docstring
+          store.get_includes(pin.path).each do |ref|
+            code_object_map[pin.path].instance_mixins.push code_object_map[ref] unless code_object_map[ref].nil? or code_object_map[pin.path].nil?
+          end
+          store.get_extends(pin.path).each do |ref|
+            code_object_map[pin.path].instance_mixins.push code_object_map[ref] unless code_object_map[ref].nil? or code_object_map[pin.path].nil?
+            code_object_map[pin.path].class_mixins.push code_object_map[ref] unless code_object_map[ref].nil? or code_object_map[pin.path].nil?
+          end
+        end
+        store.method_pins.each do |pin|
+          if pin.code_object
+            code_object_map[pin.path] ||= pin.code_object
+            next
+          end
+          code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(code_object_at(pin.namespace), pin.name, pin.scope) { |obj|
+            next if pin.location.nil? || pin.location.filename.nil?
+            obj.add_file pin.location.filename, pin.location.range.start.line
+          }
+          code_object_map[pin.path].docstring = pin.docstring
+          code_object_map[pin.path].visibility = pin.visibility || :public
+          code_object_map[pin.path].parameters = pin.parameters.map do |p|
+            [p.name, p.asgn_code]
+          end
+        end
+      end
+
+      private
+
+      # @return [Hash{String => YARD::CodeObjects::Base}]
+      def code_object_map
+        @code_object_map ||= {}
+      end
+
+      # @return [YARD::CodeObjects::RootObject]
+      def root_code_object
+        @root_code_object ||= YARD::CodeObjects::RootObject.new(nil, 'root')
+      end
+    end
+  end
+end

data/lib/solargraph/api_map/store.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Solargraph
+  class ApiMap
+    class Store
+      # @return [Array<Solargraph::Pin::Base>]
+      attr_reader :pins
+
+      # @param pins [Array<Solargraph::Pin::Base>]
+      def initialize pins = []
+        @pins = pins
+        index
+      end
+
+      # @param fqns [String]
+      # @param visibility [Array<Symbol>]
+      # @return [Array<Solargraph::Pin::Base>]
+      def get_constants fqns, visibility = [:public]
+        namespace_children(fqns).select { |pin|
+          !pin.name.empty? && (pin.is_a?(Pin::Namespace) || pin.is_a?(Pin::Constant)) && visibility.include?(pin.visibility)
+        }
+      end
+
+      # @param fqns [String]
+      # @param scope [Symbol]
+      # @param visibility [Array<Symbol>]
+      # @return [Array<Solargraph::Pin::Base>]
+      def get_methods fqns, scope: :instance, visibility: [:public]
+        namespace_children(fqns).select do |pin|
+          pin.is_a?(Pin::BaseMethod) && pin.scope == scope && visibility.include?(pin.visibility)
+        end
+      end
+
+      # @param fqns [String]
+      # @return [String, nil]
+      def get_superclass fqns
+        return superclass_references[fqns].first if superclass_references.key?(fqns)
+        return 'Object' if fqns != 'BasicObject' && namespace_exists?(fqns)
+        return 'Object' if fqns == 'Boolean'
+        nil
+      end
+
+      # @param fqns [String]
+      # @return [Array<String>]
+      def get_includes fqns
+        include_references[fqns] || []
+      end
+
+      # @param fqns [String]
+      # @return [Array<String>]
+      def get_prepends fqns
+        prepend_references[fqns] || []
+      end
+
+      # @param fqns [String]
+      # @return [Array<String>]
+      def get_extends fqns
+        extend_references[fqns] || []
+      end
+
+      # @param path [String]
+      # @return [Array<Solargraph::Pin::Base>]
+      def get_path_pins path
+        path_pin_hash[path] || []
+      end
+
+      # @param fqns [String]
+      # @param scope [Symbol] :class or :instance
+      # @return [Array<Solargraph::Pin::Base>]
+      def get_instance_variables(fqns, scope = :instance)
+        all_instance_variables.select { |pin|
+          pin.binder.namespace == fqns && pin.binder.scope == scope
+        }
+      end
+
+      # @param fqns [String]
+      # @return [Array<Solargraph::Pin::Base>]
+      def get_class_variables(fqns)
+        namespace_children(fqns).select{|pin| pin.is_a?(Pin::ClassVariable)}
+      end
+
+      # @return [Array<Solargraph::Pin::Base>]
+      def get_symbols
+        symbols.uniq(&:name)
+      end
+
+      # @param fqns [String]
+      # @return [Boolean]
+      def namespace_exists?(fqns)
+        fqns_pins(fqns).any?
+      end
+
+      # @return [Set<String>]
+      def namespaces
+        @namespaces ||= Set.new
+      end
+
+      # @return [Array<Solargraph::Pin::Base>]
+      def namespace_pins
+        @namespace_pins ||= []
+      end
+
+      # @return [Array<Solargraph::Pin::Base>]
+      def method_pins
+        @method_pins ||= []
+      end
+
+      # @param fqns [String]
+      # @return [Array<String>]
+      def domains(fqns)
+        result = []
+        fqns_pins(fqns).each do |nspin|
+          result.concat nspin.domains
+        end
+        result
+      end
+
+      # @return [Hash]
+      def named_macros
+        @named_macros ||= begin
+          result = {}
+          pins.each do |pin|
+            pin.macros.select{|m| m.tag.tag_name == 'macro' && !m.tag.text.empty? }.each do |macro|
+              next if macro.tag.name.nil? || macro.tag.name.empty?
+              result[macro.tag.name] = macro
+            end
+          end
+          result
+        end
+      end
+
+      # @return [Array<Pin::Block>]
+      def block_pins
+        @block_pins ||= []
+      end
+
+      def inspect
+        # Avoid insane dumps in specs
+        to_s
+      end
+
+      private
+
+      # @param fqns [String]
+      # @return [Array<Solargraph::Pin::Namespace>]
+      def fqns_pins fqns
+        return [] if fqns.nil?
+        if fqns.include?('::')
+          parts = fqns.split('::')
+          name = parts.pop
+          base = parts.join('::')
+        else
+          base = ''
+          name = fqns
+        end
+        fqns_pins_map[[base, name]]
+      end
+
+      def fqns_pins_map
+        @fqns_pins_map ||= Hash.new do |h, (base, name)|
+          value = namespace_children(base).select { |pin| pin.name == name && pin.is_a?(Pin::Namespace) }
+          h[[base, name]] = value
+        end
+      end
+
+      # @return [Array<Solargraph::Pin::Symbol>]
+      def symbols
+        @symbols ||= []
+      end
+
+      def superclass_references
+        @superclass_references ||= {}
+      end
+
+      def include_references
+        @include_references ||= {}
+      end
+
+      def prepend_references
+        @prepend_references ||= {}
+      end
+
+      def extend_references
+        @extend_references ||= {}
+      end
+
+      # @param name [String]
+      # @return [Array<Solargraph::Pin::Base>]
+      def namespace_children name
+        namespace_map[name] || []
+      end
+
+      # @return [Hash]
+      def namespace_map
+        @namespace_map ||= {}
+      end
+
+      def all_instance_variables
+        @all_instance_variables ||= []
+      end
+
+      def path_pin_hash
+        @path_pin_hash ||= {}
+      end
+
+      # @return [void]
+      def index
+        namespace_map.clear
+        namespaces.clear
+        namespace_pins.clear
+        method_pins.clear
+        symbols.clear
+        block_pins.clear
+        all_instance_variables.clear
+        path_pin_hash.clear
+        namespace_map[''] = []
+        override_pins = []
+        pins.each do |pin|
+          namespace_map[pin.namespace] ||= []
+          namespace_map[pin.namespace].push pin
+          namespaces.add pin.path if pin.is_a?(Pin::Namespace) && !pin.path.empty?
+          namespace_pins.push pin if pin.is_a?(Pin::Namespace)
+          method_pins.push pin if pin.is_a?(Pin::BaseMethod)
+          symbols.push pin if pin.is_a?(Pin::Symbol)
+          if pin.is_a?(Pin::Reference::Include)
+            include_references[pin.namespace] ||= []
+            include_references[pin.namespace].push pin.name
+          elsif pin.is_a?(Pin::Reference::Prepend)
+            prepend_references[pin.namespace] ||= []
+            prepend_references[pin.namespace].push pin.name
+          elsif pin.is_a?(Pin::Reference::Extend)
+            extend_references[pin.namespace] ||= []
+            extend_references[pin.namespace].push pin.name
+          elsif pin.is_a?(Pin::Reference::Superclass)
+            superclass_references[pin.namespace] ||= []
+            superclass_references[pin.namespace].push pin.name
+          elsif pin.is_a?(Pin::Block)
+            block_pins.push pin
+          elsif pin.is_a?(Pin::InstanceVariable)
+            all_instance_variables.push pin
+          elsif pin.is_a?(Pin::Reference::Override)
+            override_pins.push pin
+          end
+          if pin.path
+            path_pin_hash[pin.path] ||= []
+            path_pin_hash[pin.path].push pin
+          end
+        end
+        override_pins.each do |ovr|
+          pin = get_path_pins(ovr.name).first
+          next if pin.nil?
+          (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
+            pin.docstring.delete_tags tag.to_sym
+          end
+          ovr.tags.each do |tag|
+            pin.docstring.add_tag(tag)
+          end
+        end
+        # @todo This is probably not the best place for these overrides
+        superclass_references['Integer'] = ['Numeric']
+        superclass_references['Float'] = ['Numeric']
+      end
+    end
+  end
+end

data/lib/solargraph/bundle.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # An aggregation of a workspace and additional sources to be cataloged in an
+  # ApiMap.
+  #
+  class Bundle
+    # @return [Workspace]
+    attr_reader :workspace
+
+    # @return [Array<Source>]
+    attr_reader :opened
+
+    # @param workspace [Workspace]
+    # @param opened [Array<Source>]
+    def initialize workspace: Workspace.new, opened: []
+      @workspace = workspace
+      @opened = opened
+    end
+
+    # @return [Array<Source>]
+    def sources
+      @sources ||= (opened + workspace.sources).uniq(&:filename)
+    end
+  end
+end